src/main/java/org/apache/commons/exec/CommandLine.java - commons-exec - Git at Google

 /*
  * 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
  *
  *   https://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 java.io.File;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.StringTokenizer;

 import org.apache.commons.exec.util.StringUtils;

 /**
  * 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 {

     /**
      * Encapsulates a command line argument.
      */
     static final class Argument {

         /**
          * Argument value.
          */
         private final String value;

         /**
          * Whether to quote arguments.
          */
         private final boolean handleQuoting;

         private Argument(final String value, final boolean handleQuoting) {
             this.value = value.trim();
             this.handleQuoting = handleQuoting;
         }

         private String getValue() {
             return value;
         }

         private boolean isHandleQuoting() {
             return handleQuoting;
         }
     }

     /**
      * 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, final Map<String, ?> substitutionMap) {
         if (line == null) {
             throw new IllegalArgumentException("Command line cannot be null");
         }
         if (line.trim().isEmpty()) {
             throw new IllegalArgumentException("Command line cannot be empty");
         }
         final String[] tmp = translateCommandline(line);
         final CommandLine cl = new CommandLine(tmp[0]);
         cl.setSubstitutionMap(substitutionMap);
         for (int i = 1; i < tmp.length; i++) {
             cl.addArgument(tmp[i]);
         }
         return cl;
     }

     /**
      * Crack a command line.
      *
      * @param toProcess the command line to process.
      * @return the command line broken into strings. An empty or null toProcess parameter results in a zero sized array.
      */
     private static String[] translateCommandline(final String toProcess) {
         if (toProcess == null || toProcess.trim().isEmpty()) {
             // no command? no string
             return new String[0];
         }
         // parse with a simple finite state machine.
         final int normal = 0;
         final int inQuote = 1;
         final int inDoubleQuote = 2;
         int state = normal;
         final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);
         final ArrayList<String> list = new ArrayList<>();
         StringBuilder current = new StringBuilder();
         boolean lastTokenHasBeenQuoted = false;
         while (tok.hasMoreTokens()) {
             final String nextTok = tok.nextToken();
             switch (state) {
             case inQuote:
                 if ("\'".equals(nextTok)) {
                     lastTokenHasBeenQuoted = true;
                     state = normal;
                 } else {
                     current.append(nextTok);
                 }
                 break;
             case inDoubleQuote:
                 if ("\"".equals(nextTok)) {
                     lastTokenHasBeenQuoted = true;
                     state = normal;
                 } else {
                     current.append(nextTok);
                 }
                 break;
             default:
                 switch (nextTok) {
                 case "\'":
                     state = inQuote;
                     break;
                 case "\"":
                     state = inDoubleQuote;
                     break;
                 case " ":
                     if (lastTokenHasBeenQuoted || current.length() != 0) {
                         list.add(current.toString());
                         current = new StringBuilder();
                     }
                     break;
                 default:
                     current.append(nextTok);
                     break;
                 }
                 lastTokenHasBeenQuoted = false;
                 break;
             }
         }
         if (lastTokenHasBeenQuoted || current.length() != 0) {
             list.add(current.toString());
         }
         if (state == inQuote || state == inDoubleQuote) {
             throw new IllegalArgumentException("Unbalanced quotes in " + toProcess);
         }
         final String[] args = new String[list.size()];
         return list.toArray(args);
     }

     /**
      * The arguments of the command.
      */
     private final List<Argument> arguments = new ArrayList<>();

     /**
      * The program to execute.
      */
     private final String executable;

     /**
      * A map of name value pairs used to expand command line arguments.
      */
     private Map<String, ?> substitutionMap; // This can contain values other than Strings.

     /**
      * Tests whether a file was used to set the executable.
      */
     private final boolean isFile;

     /**
      * Copy constructor.
      *
      * @param other the instance to copy.
      */
     public CommandLine(final CommandLine other) {
         this.executable = other.getExecutable();
         this.isFile = other.isFile();
         this.arguments.addAll(other.arguments);
         if (other.getSubstitutionMap() != null) {
             this.substitutionMap = new HashMap<>(other.getSubstitutionMap());
         }
     }

     /**
      * Constructs a command line without any arguments.
      *
      * @param executable the executable file.
      */
     public CommandLine(final File executable) {
         this.isFile = true;
         this.executable = toCleanExecutable(executable.getAbsolutePath());
     }

     /**
      * Constructs a command line without any arguments.
      *
      * @param executable the executable file.
      * @since 1.5.0
      */
     public CommandLine(final Path executable) {
         this.isFile = true;
         this.executable = toCleanExecutable(executable.toAbsolutePath().toString());
     }

     /**
      * Constructs a command line without any arguments.
      *
      * @param executable the executable.
      * @throws NullPointerException     on null input.
      * @throws IllegalArgumentException on empty input.
      */
     public CommandLine(final String executable) {
         this.isFile = false;
         this.executable = toCleanExecutable(executable);
     }

     /**
      * 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 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, final 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;
     }

     /**
      * 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 addArguments A string containing multiple arguments.
      * @return The command line itself.
      */
     public CommandLine addArguments(final String addArguments) {
         return addArguments(addArguments, 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 addArguments  A string containing multiple arguments.
      * @param handleQuoting Add the argument with/without handling quoting.
      * @return The command line itself.
      */
     public CommandLine addArguments(final String addArguments, final boolean handleQuoting) {
         if (addArguments != null) {
             final String[] argumentsArray = translateCommandline(addArguments);
             addArguments(argumentsArray, handleQuoting);
         }
         return this;
     }

     /**
      * Add multiple arguments. Handles parsing of quotes and whitespace.
      *
      * @param addArguments An array of arguments.
      * @return The command line itself.
      */
     public CommandLine addArguments(final String[] addArguments) {
         return addArguments(addArguments, true);
     }

     /**
      * Add multiple arguments.
      *
      * @param addArguments  An array of arguments.
      * @param handleQuoting Add the argument with/without handling quoting.
      * @return The command line itself.
      */
     public CommandLine addArguments(final String[] addArguments, final boolean handleQuoting) {
         if (addArguments != null) {
             for (final String addArgument : addArguments) {
                 addArgument(addArgument, handleQuoting);
             }
         }
         return this;
     }

     /**
      * Expand variables in a command line argument.
      *
      * @param argument the argument.
      * @return the expanded string.
      */
     private String expandArgument(final String argument) {
         final StringBuffer stringBuffer = StringUtils.stringSubstitution(argument, getSubstitutionMap(), true);
         return stringBuffer.toString();
     }

     /**
      * Gets the expanded and quoted command line arguments.
      *
      * @return The quoted arguments.
      */
     public String[] getArguments() {
         Argument currArgument;
         String expandedArgument;
         final String[] result = new String[arguments.size()];
         for (int i = 0; i < result.length; i++) {
             currArgument = arguments.get(i);
             expandedArgument = expandArgument(currArgument.getValue());
             result[i] = currArgument.isHandleQuoting() ? StringUtils.quoteArgument(expandedArgument) : expandedArgument;
         }
         return result;
     }

     /**
      * Gets 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));
     }

     /**
      * Gets the substitution map.
      *
      * @return the substitution map.
      */
     public Map<String, ?> getSubstitutionMap() {
         return substitutionMap;
     }

     /**
      * Tests whether a file was used to set the executable.
      *
      * @return true whether a file was used for setting the executable.
      */
     public boolean isFile() {
         return isFile;
     }

     /**
      * Sets the substitutionMap to expand variables in the command line.
      *
      * @param substitutionMap the map
      */
     public void setSubstitutionMap(final Map<String, ?> substitutionMap) {
         this.substitutionMap = substitutionMap;
     }

     /**
      * Cleans the executable string. The argument is trimmed and '/' and '\\' are replaced with the platform specific file separator char
      *
      * @param dirtyExecutable the executable.
      * @return the platform-specific executable string.
      * @throws NullPointerException     on null input.
      * @throws IllegalArgumentException on empty input.
      */
     private String toCleanExecutable(final String dirtyExecutable) {
         Objects.requireNonNull(dirtyExecutable, "dirtyExecutable");
         if (dirtyExecutable.trim().isEmpty()) {
             throw new IllegalArgumentException("Executable cannot be empty");
         }
         return StringUtils.fixFileSeparatorChar(dirtyExecutable);
     }

     /**
      * Stringify operator returns the command line as a string.
      * Parameters are correctly quoted when containing a space or left untouched if they are already
      * quoted.
      *
      * @return the command line as single string.
      */
     @Override
     public String toString() {
         return "[" + String.join(", ", toStrings()) + "]";
     }

     /**
      * Converts the command line as an array of strings.
      *
      * @return The command line as a string array.
      */
     public String[] toStrings() {
         final String[] result = new String[arguments.size() + 1];
         result[0] = getExecutable();
         System.arraycopy(getArguments(), 0, result, 1, result.length - 1);
         return result;
     }
 }
	/*
	* 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
	*
	* https://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 java.io.File;
	import java.nio.file.Path;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.StringTokenizer;

	import org.apache.commons.exec.util.StringUtils;

	/**
	* 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 {

	/**
	* Encapsulates a command line argument.
	*/
	static final class Argument {

	/**
	* Argument value.
	*/
	private final String value;

	/**
	* Whether to quote arguments.
	*/
	private final boolean handleQuoting;

	private Argument(final String value, final boolean handleQuoting) {
	this.value = value.trim();
	this.handleQuoting = handleQuoting;
	}

	private String getValue() {
	return value;
	}

	private boolean isHandleQuoting() {
	return handleQuoting;
	}
	}

	/**
	* 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, final Map<String, ?> substitutionMap) {
	if (line == null) {
	throw new IllegalArgumentException("Command line cannot be null");
	}
	if (line.trim().isEmpty()) {
	throw new IllegalArgumentException("Command line cannot be empty");
	}
	final String[] tmp = translateCommandline(line);
	final CommandLine cl = new CommandLine(tmp[0]);
	cl.setSubstitutionMap(substitutionMap);
	for (int i = 1; i < tmp.length; i++) {
	cl.addArgument(tmp[i]);
	}
	return cl;
	}

	/**
	* Crack a command line.
	*
	* @param toProcess the command line to process.
	* @return the command line broken into strings. An empty or null toProcess parameter results in a zero sized array.
	*/
	private static String[] translateCommandline(final String toProcess) {
	if (toProcess == null \|\| toProcess.trim().isEmpty()) {
	// no command? no string
	return new String[0];
	}
	// parse with a simple finite state machine.
	final int normal = 0;
	final int inQuote = 1;
	final int inDoubleQuote = 2;
	int state = normal;
	final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);
	final ArrayList<String> list = new ArrayList<>();
	StringBuilder current = new StringBuilder();
	boolean lastTokenHasBeenQuoted = false;
	while (tok.hasMoreTokens()) {
	final String nextTok = tok.nextToken();
	switch (state) {
	case inQuote:
	if ("\'".equals(nextTok)) {
	lastTokenHasBeenQuoted = true;
	state = normal;
	} else {
	current.append(nextTok);
	}
	break;
	case inDoubleQuote:
	if ("\"".equals(nextTok)) {
	lastTokenHasBeenQuoted = true;
	state = normal;
	} else {
	current.append(nextTok);
	}
	break;
	default:
	switch (nextTok) {
	case "\'":
	state = inQuote;
	break;
	case "\"":
	state = inDoubleQuote;
	break;
	case " ":
	if (lastTokenHasBeenQuoted \|\| current.length() != 0) {
	list.add(current.toString());
	current = new StringBuilder();
	}
	break;
	default:
	current.append(nextTok);
	break;
	}
	lastTokenHasBeenQuoted = false;
	break;
	}
	}
	if (lastTokenHasBeenQuoted \|\| current.length() != 0) {
	list.add(current.toString());
	}
	if (state == inQuote \|\| state == inDoubleQuote) {
	throw new IllegalArgumentException("Unbalanced quotes in " + toProcess);
	}
	final String[] args = new String[list.size()];
	return list.toArray(args);
	}

	/**
	* The arguments of the command.
	*/
	private final List<Argument> arguments = new ArrayList<>();

	/**
	* The program to execute.
	*/
	private final String executable;

	/**
	* A map of name value pairs used to expand command line arguments.
	*/
	private Map<String, ?> substitutionMap; // This can contain values other than Strings.

	/**
	* Tests whether a file was used to set the executable.
	*/
	private final boolean isFile;

	/**
	* Copy constructor.
	*
	* @param other the instance to copy.
	*/
	public CommandLine(final CommandLine other) {
	this.executable = other.getExecutable();
	this.isFile = other.isFile();
	this.arguments.addAll(other.arguments);
	if (other.getSubstitutionMap() != null) {
	this.substitutionMap = new HashMap<>(other.getSubstitutionMap());
	}
	}

	/**
	* Constructs a command line without any arguments.
	*
	* @param executable the executable file.
	*/
	public CommandLine(final File executable) {
	this.isFile = true;
	this.executable = toCleanExecutable(executable.getAbsolutePath());
	}

	/**
	* Constructs a command line without any arguments.
	*
	* @param executable the executable file.
	* @since 1.5.0
	*/
	public CommandLine(final Path executable) {
	this.isFile = true;
	this.executable = toCleanExecutable(executable.toAbsolutePath().toString());
	}

	/**
	* Constructs a command line without any arguments.
	*
	* @param executable the executable.
	* @throws NullPointerException on null input.
	* @throws IllegalArgumentException on empty input.
	*/
	public CommandLine(final String executable) {
	this.isFile = false;
	this.executable = toCleanExecutable(executable);
	}

	/**
	* 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 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, final 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;
	}

	/**
	* 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 addArguments A string containing multiple arguments.
	* @return The command line itself.
	*/
	public CommandLine addArguments(final String addArguments) {
	return addArguments(addArguments, 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 addArguments A string containing multiple arguments.
	* @param handleQuoting Add the argument with/without handling quoting.
	* @return The command line itself.
	*/
	public CommandLine addArguments(final String addArguments, final boolean handleQuoting) {
	if (addArguments != null) {
	final String[] argumentsArray = translateCommandline(addArguments);
	addArguments(argumentsArray, handleQuoting);
	}
	return this;
	}

	/**
	* Add multiple arguments. Handles parsing of quotes and whitespace.
	*
	* @param addArguments An array of arguments.
	* @return The command line itself.
	*/
	public CommandLine addArguments(final String[] addArguments) {
	return addArguments(addArguments, true);
	}

	/**
	* Add multiple arguments.
	*
	* @param addArguments An array of arguments.
	* @param handleQuoting Add the argument with/without handling quoting.
	* @return The command line itself.
	*/
	public CommandLine addArguments(final String[] addArguments, final boolean handleQuoting) {
	if (addArguments != null) {
	for (final String addArgument : addArguments) {
	addArgument(addArgument, handleQuoting);
	}
	}
	return this;
	}

	/**
	* Expand variables in a command line argument.
	*
	* @param argument the argument.
	* @return the expanded string.
	*/
	private String expandArgument(final String argument) {
	final StringBuffer stringBuffer = StringUtils.stringSubstitution(argument, getSubstitutionMap(), true);
	return stringBuffer.toString();
	}

	/**
	* Gets the expanded and quoted command line arguments.
	*
	* @return The quoted arguments.
	*/
	public String[] getArguments() {
	Argument currArgument;
	String expandedArgument;
	final String[] result = new String[arguments.size()];
	for (int i = 0; i < result.length; i++) {
	currArgument = arguments.get(i);
	expandedArgument = expandArgument(currArgument.getValue());
	result[i] = currArgument.isHandleQuoting() ? StringUtils.quoteArgument(expandedArgument) : expandedArgument;
	}
	return result;
	}

	/**
	* Gets 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));
	}

	/**
	* Gets the substitution map.
	*
	* @return the substitution map.
	*/
	public Map<String, ?> getSubstitutionMap() {
	return substitutionMap;
	}

	/**
	* Tests whether a file was used to set the executable.
	*
	* @return true whether a file was used for setting the executable.
	*/
	public boolean isFile() {
	return isFile;
	}

	/**
	* Sets the substitutionMap to expand variables in the command line.
	*
	* @param substitutionMap the map
	*/
	public void setSubstitutionMap(final Map<String, ?> substitutionMap) {
	this.substitutionMap = substitutionMap;
	}

	/**
	* Cleans the executable string. The argument is trimmed and '/' and '\\' are replaced with the platform specific file separator char
	*
	* @param dirtyExecutable the executable.
	* @return the platform-specific executable string.
	* @throws NullPointerException on null input.
	* @throws IllegalArgumentException on empty input.
	*/
	private String toCleanExecutable(final String dirtyExecutable) {
	Objects.requireNonNull(dirtyExecutable, "dirtyExecutable");
	if (dirtyExecutable.trim().isEmpty()) {
	throw new IllegalArgumentException("Executable cannot be empty");
	}
	return StringUtils.fixFileSeparatorChar(dirtyExecutable);
	}

	/**
	* Stringify operator returns the command line as a string.
	* Parameters are correctly quoted when containing a space or left untouched if they are already
	* quoted.
	*
	* @return the command line as single string.
	*/
	@Override
	public String toString() {
	return "[" + String.join(", ", toStrings()) + "]";
	}

	/**
	* Converts the command line as an array of strings.
	*
	* @return The command line as a string array.
	*/
	public String[] toStrings() {
	final String[] result = new String[arguments.size() + 1];
	result[0] = getExecutable();
	System.arraycopy(getArguments(), 0, result, 1, result.length - 1);
	return result;
	}
	}