org.apache.commons.exec.CommandLine Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.commons.exec;
import org.apache.commons.exec.util.StringUtils;
import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Map;
/**
* CommandLine objects help handling command lines specifying processes to
* execute. The class can be used to a command line by an application.
*/
public class CommandLine {
/**
* The arguments of the command.
*/
private final Vector arguments = new Vector();
/**
* The program to execute.
*/
private final String executable;
/**
* A map of name value pairs used to expand command line arguments
*/
private Map substitutionMap;
/**
* Was a file being used to set the executable?
*/
private final boolean isFile;
/**
* Create a command line from a string.
*
* @param line the first element becomes the executable, the rest the arguments
* @return the parsed command line
* @throws IllegalArgumentException If line is null or all whitespace
*/
public static CommandLine parse(final String line) {
return parse(line, null);
}
/**
* Create a command line from a string.
*
* @param line the first element becomes the executable, the rest the arguments
* @param substitutionMap the name/value pairs used for substitution
* @return the parsed command line
* @throws IllegalArgumentException If line is null or all whitespace
*/
public static CommandLine parse(final String line, Map substitutionMap) {
if (line == null) {
throw new IllegalArgumentException("Command line can not be null");
} else if (line.trim().length() == 0) {
throw new IllegalArgumentException("Command line can not be empty");
} else {
String[] tmp = translateCommandline(line);
CommandLine cl = new CommandLine(tmp[0]);
cl.setSubstitutionMap(substitutionMap);
for (int i = 1; i < tmp.length; i++) {
cl.addArgument(tmp[i]);
}
return cl;
}
}
/**
* Create a command line without any arguments.
*
* @param executable the executable
*/
public CommandLine(String executable) {
this.isFile=false;
this.executable=getExecutable(executable);
}
/**
* Create a command line without any arguments.
*
* @param executable the executable file
*/
public CommandLine(File executable) {
this.isFile=true;
this.executable=getExecutable(executable.getAbsolutePath());
}
/**
* Copy constructor.
*
* @param other the instance to copy
*/
public CommandLine(CommandLine other)
{
this.executable = other.getExecutable();
this.isFile = other.isFile();
this.arguments.addAll(other.arguments);
if(other.getSubstitutionMap() != null)
{
this.substitutionMap = new HashMap();
Iterator iterator = other.substitutionMap.keySet().iterator();
while(iterator.hasNext())
{
Object key = iterator.next();
this.substitutionMap.put(key, other.getSubstitutionMap().get(key));
}
}
}
/**
* Returns the executable.
*
* @return The executable
*/
public String getExecutable() {
// Expand the executable and replace '/' and '\\' with the platform
// specific file separator char. This is safe here since we know
// that this is a platform specific command.
return StringUtils.fixFileSeparatorChar(expandArgument(executable));
}
/**
* Was a file being used to set the executable?
*
* @return true if a file was used for setting the executable
*/
public boolean isFile(){
return isFile;
}
/**
* Add multiple arguments. Handles parsing of quotes and whitespace.
*
* @param arguments An array of arguments
* @return The command line itself
*/
public CommandLine addArguments(final String[] arguments) {
return this.addArguments(arguments, true);
}
/**
* Add multiple arguments.
*
* @param arguments An array of arguments
* @param handleQuoting Add the argument with/without handling quoting
* @return The command line itself
*/
public CommandLine addArguments(final String[] arguments, boolean handleQuoting) {
if (arguments != null) {
for (int i = 0; i < arguments.length; i++) {
addArgument(arguments[i], handleQuoting);
}
}
return this;
}
/**
* Add multiple arguments. Handles parsing of quotes and whitespace.
* Please note that the parsing can have undesired side-effects therefore
* it is recommended to build the command line incrementally.
*
* @param arguments An string containing multiple arguments.
* @return The command line itself
*/
public CommandLine addArguments(final String arguments) {
return this.addArguments(arguments, true);
}
/**
* Add multiple arguments. Handles parsing of quotes and whitespace.
* Please note that the parsing can have undesired side-effects therefore
* it is recommended to build the command line incrementally.
*
* @param arguments An string containing multiple arguments.
* @param handleQuoting Add the argument with/without handling quoting
* @return The command line itself
*/
public CommandLine addArguments(final String arguments, boolean handleQuoting) {
if (arguments != null) {
String[] argumentsArray = translateCommandline(arguments);
addArguments(argumentsArray, handleQuoting);
}
return this;
}
/**
* Add a single argument. Handles quoting.
*
* @param argument The argument to add
* @return The command line itself
* @throws IllegalArgumentException If argument contains both single and double quotes
*/
public CommandLine addArgument(final String argument) {
return this.addArgument(argument, true);
}
/**
* Add a single argument.
*
* @param argument The argument to add
* @param handleQuoting Add the argument with/without handling quoting
* @return The command line itself
*/
public CommandLine addArgument(final String argument, boolean handleQuoting) {
if (argument == null)
{
return this;
}
// check if we can really quote the argument - if not throw an
// IllegalArgumentException
if (handleQuoting)
{
StringUtils.quoteArgument(argument);
}
arguments.add(new Argument(argument, handleQuoting));
return this;
}
/**
* Returns the expanded and quoted command line arguments.
*
* @return The quoted arguments
*/
public String[] getArguments() {
Argument currArgument;
String expandedArgument;
String[] result = new String[arguments.size()];
for(int i=0; i