CommandLineInputProcessor.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * 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.
 */
package com.motorolamobility.preflighting.internal.commandinput;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.osgi.util.NLS;

import com.motorolamobility.preflighting.core.validation.ComplexParameter;
import com.motorolamobility.preflighting.core.validation.Parameter;
import com.motorolamobility.preflighting.i18n.PreflightingNLS;
import com.motorolamobility.preflighting.internal.commandinput.exception.ParameterParseException;

/**
 * Process command line commands below:
 */
public class CommandLineInputProcessor
{
    /**
     * White space character
     */
    private static final String WHITE_SPACE = " "; //$NON-NLS-1$

    /**
     * Simple parameter marker character
     */
    private static final String PARAMETER_MARKER = "-"; //$NON-NLS-1$

    /**
     * Simple parameter separator
     */
    private static final String COMPLEX_PARAMETER_SEPARATOR = "="; //$NON-NLS-1$

    /**
     * 
     * @param params
     * @return
     * @throws ParameterParseException
     */
    public List<Parameter> processCommandLine(String params) throws ParameterParseException
    {
        // Parse command line arguments and create parameters
        List<Parameter> commandLineParameters = new ArrayList<Parameter>();

        // if no parameters were passed, assume help will be printed
        if (params.length() == 0)
        {
            Parameter helpParameter =
                    new Parameter(ApplicationParameterInterpreter.PARAM_HELP, null);
            commandLineParameters.add(helpParameter);
        }
        else
        {
            // find the pattern " -", which is expected to separate each parameter
            String regex = "((?!(\\s+" + PARAMETER_MARKER + ")).)*"; //$NON-NLS-1$ //$NON-NLS-2$
            Pattern pat = Pattern.compile(regex);
            Matcher matcher = pat.matcher(params);
            Parameter commandLineparameter = null;

            // for each parameter part found, process it
            while (matcher.find())
            {
                String parameterValues = params.substring(matcher.start(), matcher.end());

                if (parameterValues.length() > 0)
                {
                    commandLineparameter = getCommandLineParameter(parameterValues);
                    commandLineParameters.add(commandLineparameter);
                }
            }
        }
        return commandLineParameters;
    }

    /**
     * Gets a parameter from command line. Command line arguments are passed to the 
     * application like this: -arg foo bar -c check1 name1=val1 name2=val2
     * 
     * The parameter for this example is:
     * name = arg
     * values = foo, bar
     * 
     * @param parameterValues String containing the parameter and its values. Eg: -arg foo bar
     * @return And instance of object Parameter
     * @throws ParameterParseException 
     */
    private Parameter getCommandLineParameter(String parameterValues)
            throws ParameterParseException
    {

        Parameter parameter = null;

        if (parameterValues.indexOf(COMPLEX_PARAMETER_SEPARATOR) == -1)
        {

            // Its a simple parameter, example: -param1 value1 or example: -param2
            parameter = getParameterFromCommandLine(parameterValues);

        }
        else
        {
            // Its a complex parameter, example: -c checker1 file=C:\arg.txt version=2
            parameter = getComplexParameterFromCommandLine(parameterValues);
        }

        return parameter;
    }

    /**
     * Get a complex parameter from command line. Example: -c checker1 param1=val1 param2=var2
     * @param values String[] containing the complex parameter. For example, for command line -c checker1 param1=val1 param2=var2
     * the contents of values are: [[c] [check1] [param1=val1] [param2=val2]]
     * @return Instance of Parameter, containing a ComplexParameter
     * @throws ParameterParseException 
     */
    private Parameter getComplexParameterFromCommandLine(String parameterValues)
            throws ParameterParseException
    {
        // complex parameter example: -c checker param1=val1 param2=val2
        ComplexParameter parameter = new ComplexParameter();

        String[] values = parameterValues.split(WHITE_SPACE);

        if (values.length < 3)
        {
            throw new ParameterParseException(NLS.bind(
                    PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
        }
        else
        {

            String parameterType = values[0];

            if (parameterType.startsWith(PARAMETER_MARKER))
            {
                parameterType = parameterType.substring(1);
            }
            parameter.setParameterType(parameterType);
            parameter.setValue(values[1]);

            int lenghtToCut = values[0].length() + values[1].length() + 2;
            String subParameters = parameterValues.substring(lenghtToCut);

            String[] checkSyntax = subParameters.split("\\s*\\w+\\s*" + COMPLEX_PARAMETER_SEPARATOR //$NON-NLS-1$
                    + "\\s*\\w+\\s*"); //$NON-NLS-1$
            if (checkSyntax.length > 0)
            {
                throw new ParameterParseException(NLS.bind(
                        PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
            }

            Pattern pat = Pattern.compile("\\w+\\s*" + COMPLEX_PARAMETER_SEPARATOR + "\\s*\\w+"); //$NON-NLS-1$ //$NON-NLS-2$
            Matcher matcher = pat.matcher(subParameters);

            while (matcher.find())
            {
                String part = subParameters.substring(matcher.start(), matcher.end());
                String[] pair = part.split(COMPLEX_PARAMETER_SEPARATOR);
                parameter.addParameter(pair[0].trim(), pair[1].trim());
            }
        }
        return parameter;
    }

    /**
     * Get a parameter from command line (example -param value), passed as a String[].
     * @param parameterValues parameter values
     * @return Instance of Parameter
     * @throws ParameterParseException 
     */
    private Parameter getParameterFromCommandLine(String parameterValues)
            throws ParameterParseException
    {
        Parameter parameter = new Parameter();

        // find first white space to separate tag from value
        int indexOfFirstWhiteSpace = parameterValues.indexOf(WHITE_SPACE);
        String parameterType = null;
        String parameterValue = null;

        // if there is no whitespace, everything is the parameter value necessary
        if (indexOfFirstWhiteSpace >= 0)
        {
            // substring original string from character 1 (skip "-"), to first
            // whitespace character
            parameterType = parameterValues.substring(1, indexOfFirstWhiteSpace);
            // retrieve the rest of the original string (starting from first whitespace)
            // as the value for the parameter
            parameterValue = parameterValues.substring(indexOfFirstWhiteSpace).trim();
        }
        else
        {
            // skip "-"
            parameterType = parameterValues.substring(1);
        }

        // check for unexpected format (both parts of the parameter empty)
        if (((parameterValue == null) || (parameterValue.length() == 0))
                && ((parameterType == null) || (parameterType.length() == 0)))
        {
            throw new ParameterParseException(NLS.bind(
                    PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
        }

        // store parameter type and value
        parameter.setParameterType(parameterType);
        if ((parameterValue != null) && (parameterValue.length() > 0))
        {
            parameter.setValue(parameterValue);
        }

        return parameter;
    }
}