@Override
public ParserState onComplete() {
if (getHasArgument() && values.isEmpty()) {
throw new CommandLineArgumentException(
String.format("No argument was provided for command-line option '%s'.", optionString));
}
ParsedCommandLineOption parsedOption = commandLine.addOption(optionString.option, option);
if (values.size() + parsedOption.getValues().size() > 1
&& !option.getAllowsMultipleArguments()) {
throw new CommandLineArgumentException(
String.format(
"Multiple arguments were provided for command-line option '%s'.", optionString));
}
for (String value : values) {
parsedOption.addArgument(value);
}
if (option.getDeprecationWarning() != null) {
new PrintStream(CommandLineParser.this.deprecationPrinter)
.println(
"The "
+ optionString
+ " option is deprecated - "
+ option.getDeprecationWarning());
}
if (option.getSubcommand() != null) {
return state.onNonOption(option.getSubcommand());
}
return state;
}
/**
* Prints a usage message to the given stream.
*
* @param out The output stream to write to.
*/
public void printUsage(OutputStream out) {
Formatter formatter = new Formatter(out);
Set<CommandLineOption> orderedOptions = new TreeSet<CommandLineOption>(new OptionComparator());
orderedOptions.addAll(optionsByString.values());
Map<String, String> lines = new LinkedHashMap<String, String>();
for (CommandLineOption option : orderedOptions) {
Set<String> orderedOptionStrings = new TreeSet<String>(new OptionStringComparator());
orderedOptionStrings.addAll(option.getOptions());
List<String> prefixedStrings = new ArrayList<String>();
for (String optionString : orderedOptionStrings) {
if (optionString.length() == 1) {
prefixedStrings.add("-" + optionString);
} else {
prefixedStrings.add("--" + optionString);
}
}
lines.put(GUtil.join(prefixedStrings, ", "), GUtil.elvis(option.getDescription(), ""));
}
int max = 0;
for (String optionStr : lines.keySet()) {
max = Math.max(max, optionStr.length());
}
for (Map.Entry<String, String> entry : lines.entrySet()) {
if (entry.getValue().length() == 0) {
formatter.format("%s%n", entry.getKey());
} else {
formatter.format("%-" + max + "s %s%n", entry.getKey(), entry.getValue());
}
}
formatter.flush();
}
/**
* Specifies that the given set of options are mutually-exclusive. Only one of the given options
* will be selected. The parser ignores all but the last of these options.
*/
public CommandLineParser allowOneOf(String... options) {
Set<CommandLineOption> commandLineOptions = new HashSet<CommandLineOption>();
for (String option : options) {
commandLineOptions.add(optionsByString.get(option));
}
for (CommandLineOption commandLineOption : commandLineOptions) {
commandLineOption.groupWith(commandLineOptions);
}
return this;
}
@Override
public ParserState onStartNextArg() {
if (option.getAllowsArguments() && values.isEmpty()) {
return new MissingOptionArgState(this);
}
return onComplete();
}
/**
* Defines a new option. By default, the option takes no arguments and has no description.
*
* @param options The options values.
* @return The option, which can be further configured.
*/
public CommandLineOption option(String... options) {
for (String option : options) {
if (optionsByString.containsKey(option)) {
throw new IllegalArgumentException(
String.format("Option '%s' is already defined.", option));
}
if (option.startsWith("-")) {
throw new IllegalArgumentException(
String.format("Cannot add option '%s' as an option cannot start with '-'.", option));
}
}
CommandLineOption option = new CommandLineOption(Arrays.asList(options));
for (String optionStr : option.getOptions()) {
this.optionsByString.put(optionStr, option);
}
return option;
}
public void parse(String[] args) {
for (String argument : args) {
String[] keyValue = argument.split("=");
if (options.containsKey(keyValue[0])) {
switch (((CommandLineOption<?>) options.get(keyValue[0])).getOptionType()) {
case FILE:
CommandLineOption<File> fileOption = (CommandLineOption<File>) options.get(keyValue[0]);
if (keyValue.length == 2) {
fileOption.setValue(new File(keyValue[1]));
} else {
parseErrors.add("Option should have a key and a value.");
}
break;
/* EX1 : reproduire le comportement de 'case FILE', pour STRING,INTEGER, ... */
case STRING:
CommandLineOption<String> StringOption =
(CommandLineOption<String>) options.get(keyValue[0]);
if (keyValue.length == 2) {
StringOption.setValue(new String(keyValue[1]));
} else {
parseErrors.add("Option should have a key and a value.");
}
break;
case INTEGER:
CommandLineOption<Integer> IntegerOption =
(CommandLineOption<Integer>) options.get(keyValue[0]);
if (keyValue.length == 2) {
IntegerOption.setValue(new Integer(keyValue[1]));
} else {
parseErrors.add("Option should have a key and a value.");
}
break;
case DOUBLE:
CommandLineOption<Double> DoubleOption =
(CommandLineOption<Double>) options.get(keyValue[0]);
if (keyValue.length == 2) {
DoubleOption.setValue(new Double(keyValue[1]));
} else {
parseErrors.add("Option should have a key and a value.");
}
break;
default:
parseErrors.add("Unrecognize option type.");
}
}
}
}
public int compare(CommandLineOption option1, CommandLineOption option2) {
String min1 = Collections.min(option1.getOptions(), new OptionStringComparator());
String min2 = Collections.min(option2.getOptions(), new OptionStringComparator());
return new CaseInsensitiveStringComparator().compare(min1, min2);
}
@Override
public boolean getHasArgument() {
return option.getAllowsArguments();
}
public void addOption(CommandLineOption<?> option) {
if (option != null) {
options.put(option.getKey(), option);
}
}
/**
* Parse the command line, validate the arguments and make them available through the getValue()
* and isExists() methods.
*
* @param args the command line arguments, usually from the main() method
* @param caseSensitive if true then the argument names must match exactly, else a case
* insensitive match is used.
*/
public void parse(String[] args, boolean caseSensitive) {
args = concatenateDelimitedArgs(args);
for (String arg : args) {
String[] nameValue = arg.split("=");
String name = null;
String value = null;
if (nameValue.length > 0) name = nameValue[0];
if (nameValue.length > 1) value = nameValue[1];
if (name != null) {
CommandLineOption commandLineArg = null;
if (caseSensitive) commandLineArg = commandLineDefinition.valueOf(name);
else commandLineArg = commandLineDefinition.valueOfIgnoreCase(name);
if (commandLineArg != null) {
try {
Object typedObject = createTypedObject(value, commandLineArg.getType());
nameValuePairs.put(commandLineArg, typedObject);
} catch (NumberFormatException x) {
parseErrorMessages.add(
"Incorrect format for value of parameter '"
+ name
+ "', must be parsable to type '"
+ commandLineArg.getType().toString()
+ "'.");
}
} else parseErrorMessages.add("Unknown parameter '" + name + "'.");
}
}
for (Iterator<? extends CommandLineOption> iter = commandLineDefinition.iterator();
iter.hasNext(); ) {
CommandLineOption arg = iter.next();
if (arg.isRequired() && !nameValuePairs.containsKey(arg))
parseErrorMessages.add(
"Required parameter '"
+ arg.toString()
+ "' is not provided on the command line, use "
+ arg.toString()
+ ((arg.getType() == null) ? "." : "=<value>."));
if (nameValuePairs.containsKey(arg)
&& (arg.getType() != null)
&& nameValuePairs.get(arg) == null)
parseErrorMessages.add(
"Parameter '"
+ arg.toString()
+ "' must have a value and it does not, use "
+ arg.toString()
+ "=<value>.");
}
if (parseErrorMessages.size() > 0)
parseErrorMessages.add(
"Valid parameters are: \n" + commandLineDefinition.getUselessMessage());
}
public static void main(String[] args) throws Exception {
CommandLineOption op = new CommandLineOption(args);
CommandLineOption.Option[] ops = op.getOptions();
String fn = null, output = null, baseDir = ".", inits = null, setting = null;
for (CommandLineOption.Option o : ops) {
if (o.name == null) {
fn = o.value;
} else {
switch (o.name) {
case "-o":
case "--output":
output = o.value;
break;
case "-d":
case "--directory":
baseDir = o.value;
break;
case "-s":
case "--setting":
setting = o.value;
break;
case "-i":
case "--init":
inits = o.value;
break;
case "-h":
case "--help":
System.out.println("[-OPTIONS] -s settingfile1[,settigfile2] input file name");
System.out.println(" -d,--direcoty:作業ディレクトリを指定します。指定しない場合は弦座のディレクトリになります。");
System.out.println(" -i,--init :ファイルを読み込む前に実行するマクロの初期化ファイルです。必須オプションです。");
System.out.println(" -o,--output :出力ファイル名を指定してください");
System.out.println(" -s,--setting :RootDocumentをHTMLDOMに変換する為の設定ファイルです。必須オプションです。");
System.out.println(" -h,--help :このヘルプを出力します");
return;
}
}
}
if (fn == null) {
System.out.println("開発のテストモードで起動します。");
testMain();
return;
// System.out.println("入力ファイルを指定してください");
// return;
}
if (inits == null) {
System.err.println("マクロ初期化ファイルが指定されていません。");
return;
}
if (setting == null) {
System.err.println("設定ファイルが指定されていません。");
return;
}
Path base = Paths.get(baseDir).toAbsolutePath();
Path file = base.resolve(fn);
if (!Files.isReadable(file)) {
System.err.println("ファイルを読み込むことが出来ません。" + file.toString());
return;
}
LamuriyanEngine engine = new LamuriyanEngine(fn, base);
String[] s = inits.split(",");
ArrayList<Path> paths = new ArrayList<>();
for (String ss : s) {
paths.add(Paths.get(ss));
}
engine.setInitFiles(paths);
engine.evaluate();
RootDocument root = engine.getDocument();
HTMLConverter converter = new HTMLConverter(root, Paths.get(setting));
converter.convert();
if (output == null) {
System.out.println(converter.toHTML());
} else {
Path out = Paths.get(output);
if (!Files.exists(out)) Files.createFile(out);
FileWriter fw = new FileWriter(out.toFile());
fw.write(converter.toHTML());
}
}
