act.cli.util.CommandLineParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of act Show documentation
Show all versions of act Show documentation
The ACT full stack MVC framework
package act.cli.util;
/*-
* #%L
* ACT Framework
* %%
* Copyright (C) 2014 - 2017 ActFramework
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
import act.cli.InvalidCommandLineException;
import org.osgl.util.C;
import org.osgl.util.E;
import org.osgl.util.S;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Parse a command line
*/
public class CommandLineParser {
private String command;
private String raw;
/*
* Map value part to lead part. E.g.
* {@code -n 10} create an entry ("-n", "10") and
* {@code -b} create an entry ("-b", "true")
*/
private Map options;
private List arguments;
static final Pattern P_QUOTATION = Pattern.compile("([^\"]\\S*|\".+?\")\\s*");
static final Pattern P_APOSTROPHE = Pattern.compile("([^\']\\S*|\'.+?\')\\s*");
public CommandLineParser(String line) {
E.illegalArgumentIf(S.blank(line));
raw = line.trim();
options = new HashMap<>();
List sl = new ArrayList<>();
Pattern ptn = choosePattern(raw);
Matcher m = ptn.matcher(raw);
while (m.find()) {
String s = m.group(1);
if (ptn == P_QUOTATION) {
s = S.strip(s, "\"", "\"");
} else {
s = S.strip(s, "\'", "\'");
}
sl.add(s);
}
parse(sl);
}
private Pattern choosePattern(String s) {
Pattern ptn = P_APOSTROPHE;
int p1 = s.indexOf('"');
if (p1 > -1) {
int p2 = s.indexOf('\'');
if (p2 < 0 || p1 < p2) {
ptn = P_QUOTATION;
}
}
return ptn;
}
public Map getOptions() {
return options;
}
public List getArguments() {
return arguments;
}
public String commandLine() {
return raw;
}
private void parse(List tokens) {
command = tokens.remove(0).intern();
arguments = new ArrayList<>();
String lead = null;
for (String cur : tokens) {
// is cur token an number?
boolean isNumberic = false;
try {
Double.parseDouble(cur);
isNumberic = true;
} catch (Exception e) {
// ignore
}
if (!isNumberic && cur.startsWith("-")) {
// todo handle --option=a, --option:b style
String[] sa = cur.split("[=:]");
switch (sa.length) {
case 1:
break;
case 2:
options.put(sa[0], sa[1]);
continue;
default:
throw new InvalidCommandLineException("uknown option: %s", cur);
}
if (null != lead) {
options.put(lead, "true");
}
lead = cur;
} else {
if (null != lead) {
options.put(lead, cur);
lead = null;
} else {
arguments.add(cur);
}
}
}
if (null != lead) {
options.put(lead, "true");
}
}
public String command() {
return command;
}
public List arguments() {
return C.list(arguments);
}
public String argument(int id) {
if (id >= arguments.size()) {
return null;
}
return arguments.get(id);
}
public int argumentCount() {
return arguments.size();
}
public int optionCount() {
return arguments.size();
}
/**
* When a command has only one option and no arguments the
* user can supply the option as argument to suppress leads typing.
*
* This method will return the single argument as an option with
* any leads. If the parser found there are more than one argument
* or there are options then this method will return `null`
* @return
*/
public String argumentAsOption() {
if (1 == argumentCount() && 0 == options.size()) {
return argument(0);
}
return null;
}
public boolean getBoolean(String lead1, String lead2) {
String s = o(lead1, lead2);
return "true" == s;
}
public Boolean getBooleanObject(String lead1, String lead2) {
return getBoolean(lead1, lead2);
}
public byte getByte(String lead1, String lead2, Byte def) {
Byte b = getByteObject(lead1, lead2, def);
if (null != b) {
return b;
}
throw new InvalidCommandLineException("Cannot get byte type option");
}
public Byte getByteObject(String lead1, String lead2, Byte def) {
String s = o(lead1, lead2);
return null == s ? def : Byte.valueOf(s);
}
public char getChar(String lead1, String lead2, Character def) {
Character c = getCharObject(lead1, lead2, def);
if (null != c) {
return c;
}
throw new InvalidCommandLineException("Cannot get char type option");
}
public Character getCharObject(String lead1, String lead2, Character def) {
String s = o(lead1, lead2);
return null == s ? def : s.charAt(0);
}
public short getShort(String lead1, String lead2, Short def) {
Short o = getShortObject(lead1, lead2, def);
if (null != o) {
return o;
}
throw new InvalidCommandLineException("Cannot get short type option");
}
public Short getShortObject(String lead1, String lead2, Short def) {
String s = o(lead1, lead2);
return null == s ? def : Short.valueOf(s);
}
public int getInt(String lead1, String lead2, Integer def) {
Integer n = getIntObject(lead1, lead2, def);
if (null != n) {
return n;
}
throw new InvalidCommandLineException("Cannot get int type option");
}
public Integer getIntObject(String lead1, String lead2, Integer def) {
String s = o(lead1, lead2);
return null == s ? def : Integer.valueOf(s);
}
public float getFloat(String lead1, String lead2, Float def) {
Float o = getFloatObject(lead1, lead2, def);
if (null != o) {
return o;
}
throw new InvalidCommandLineException("Cannot get float type option");
}
public Float getFloatObject(String lead1, String lead2, Float def) {
String s = o(lead1, lead2);
return null == s ? def : Float.valueOf(s);
}
public long getLong(String lead1, String lead2, Long def) {
Long o = getLongObject(lead1, lead2, def);
if (null != o) {
return o;
}
throw new InvalidCommandLineException("Cannot get long type option");
}
public Double getDoubleObject(String lead1, String lead2, Double def) {
String s = o(lead1, lead2);
return null == s ? def : Double.valueOf(s);
}
public double getDouble(String lead1, String lead2, Double def) {
Double o = getDoubleObject(lead1, lead2, def);
if (null != o) {
return o;
}
throw new InvalidCommandLineException("Cannot get double type option");
}
public Long getLongObject(String lead1, String lead2, Long def) {
String s = o(lead1, lead2);
return null == s ? def : Long.valueOf(s);
}
public String getString(String lead1, String lead2) {
return o(lead1, lead2);
}
private String o(String lead1, String lead2) {
String s = options.get(lead1);
return null == s ? options.get(lead2) : s;
}
}