package io.micronaut.core.cli;
import io.micronaut.core.annotation.Internal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
@Internal
class DefaultCommandLine implements CommandLine {
private Properties systemProperties = new Properties();
private LinkedHashMap<String, Object> undeclaredOptions = new LinkedHashMap<>();
private LinkedHashMap<Option, Object> declaredOptions = new LinkedHashMap<>();
private List<String> remainingArgs = new ArrayList<>();
private String[] rawArguments = new String[0];
@Override
public CommandLine parseNew(String[] args) {
DefaultCommandLine defaultCommandLine = new DefaultCommandLine();
defaultCommandLine.systemProperties.putAll(systemProperties);
defaultCommandLine.undeclaredOptions.putAll(undeclaredOptions);
defaultCommandLine.declaredOptions.putAll(declaredOptions);
CommandLineParser parser = new CommandLineParser();
return parser.parse(defaultCommandLine, args);
}
@Override
public Map<Option, Object> getOptions() {
return declaredOptions;
}
@Override
public List<String> getRemainingArgs() {
return remainingArgs;
}
@Override
public Properties getSystemProperties() {
return systemProperties;
}
@Override
public boolean hasOption(String name) {
return declaredOptions.containsKey(new Option(name, null)) || undeclaredOptions.containsKey(name);
}
@Override
public Object optionValue(String name) {
Option opt = new Option(name, null);
if (declaredOptions.containsKey(opt)) {
return declaredOptions.get(opt);
}
if (undeclaredOptions.containsKey(name)) {
return undeclaredOptions.get(name);
}
return null;
}
@Override
public String getRemainingArgsString() {
return remainingArgsToString(" ", false);
}
@Override
public Map.Entry<String, Object> lastOption() {
final Iterator<Map.Entry<String, Object>> i = undeclaredOptions.entrySet().iterator();
while (i.hasNext()) {
Map.Entry<String, Object> next = i.next();
if (!i.hasNext()) {
return next;
}
}
return null;
}
@Override
public String getRemainingArgsWithOptionsString() {
return remainingArgsToString(" ", true);
}
@Override
public Map<String, Object> getUndeclaredOptions() {
return Collections.unmodifiableMap(undeclaredOptions);
}
@Override
public String[] getRawArguments() {
return rawArguments;
}
void addDeclaredOption(Option option) {
addDeclaredOption(option, Boolean.TRUE);
}
void addUndeclaredOption(String option) {
undeclaredOptions.put(option, Boolean.TRUE);
}
void addUndeclaredOption(String option, Object value) {
undeclaredOptions.put(option, value);
}
void addDeclaredOption(Option option, Object value) {
declaredOptions.put(option, value);
}
void addRemainingArg(String arg) {
remainingArgs.add(arg);
}
void addSystemProperty(String name, String value) {
systemProperties.put(name, value);
}
void setRawArguments(String[] args) {
this.rawArguments = args;
}
private String remainingArgsToString(String separator, boolean includeOptions) {
StringBuilder sb = new StringBuilder();
String sep = "";
List<String> args = new ArrayList<>(remainingArgs);
if (includeOptions) {
for (Map.Entry<String, Object> entry : undeclaredOptions.entrySet()) {
if (entry.getValue() instanceof Boolean && ((Boolean) entry.getValue())) {
args.add('-' + entry.getKey());
} else {
args.add('-' + entry.getKey() + '=' + entry.getValue());
}
}
}
for (String arg : args) {
sb.append(sep).append(arg);
sep = separator;
}
return sb.toString();
}
}