clearice\argparser\ArgumentParser

Complexity

Total Complexity

54

Size/Duplication

Total Lines	346
Duplicated Lines	0 %

Test Coverage

Coverage

95.8%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	addToOptionCache()	0	11	3
A	__construct()	0	4	1
A	getNextValueOrFail()	0	7	3
B	parseArgumentArray()	0	12	5
A	fillInDefaults()	0	5	4
A	validateOption()	0	7	4
A	addCommand()	0	9	3
B	validateRequired()	0	12	6
A	parseShortArgument()	0	16	3
A	addOption()	0	8	1
A	assignValue()	0	6	3
A	maybeShowHelp()	0	5	4
A	parse()	0	19	3
A	enableHelp()	0	9	2
A	getHelpMessage()	0	6	1
A	parseLongArgument()	0	17	3
A	parseCommand()	0	5	3
A	retrieveOptionFromCache()	0	6	2

<?php

namespace clearice\argparser;
use clearice\utils\ProgramControl;


/**
 * Class ArgumentParser
 *
 * @package clearice\argparser
 */
class ArgumentParser
{
    private $description;

    private $footer;

    private $name;

    private $commands = [];

    /**
     * @var array
     */
    private $optionsCache = [];

    /**
     * All the possible options for arguments.
     * @var array
     */
    private $options = [];

    /**
     * An instance of the help generator.
     * @var HelpMessageGenerator
     */
    private $helpGenerator;

    private $programControl;

    private $helpEnabled = false;

    public function __construct($helpWriter = null, $programControl = null)
    {
        $this->helpGenerator = $helpWriter ?? new HelpMessageGenerator();
        $this->programControl = $programControl ?? new ProgramControl();
    }

    /**
     * Add a value to the available possible options for later parsing.
     *
     * @param string $key
     * @param array $value
     * @throws OptionExistsException
     */
    private function addToOptionCache(string $key, array $value) : void
    {
        if (!isset($value[$key])) {
            return;
        }
        $cacheKey = "${value['command']}${value[$key]}";
        if (!isset($this->optionsCache[$cacheKey])) {
            $this->optionsCache[$cacheKey] = $value;
        } else {
            throw new OptionExistsException(
                "An argument option with $key {$value['command']} {$value[$key]} already exists."
            );
        }
    }

    /**
     * @param string $key
     * @param string $name
     * @return mixed
     * @throws InvalidArgumentException
     */
    private function retrieveOptionFromCache(string $key, string $name)
    {
        if(!isset($this->optionsCache[$key])) {
            throw new InvalidArgumentException("Unknown option '$name'. Please run with `--help` for more information on valid options.");
        }
        return $this->optionsCache[$key];
    }

    /**
     * @param array $option
     * @throws InvalidArgumentDescriptionException
     * @throws UnknownCommandException
     */
    private function validateOption($option) : void
    {
        if (!isset($option['name'])) {
            throw new InvalidArgumentDescriptionException("Argument must have a name");
        }
        if (isset($option['command']) && !isset($this->commands[$option['command']])) {
            throw new UnknownCommandException("The command {$option['command']} is unknown");
        }
    }

    /**
     * Add an option to be parsed.
     * Arguments are presented as a structured array with the following possible keys.
     *
     *  name: The name of the option prefixed with a double dash --
     *  short_name: A shorter single character option prefixed with a single dash -
     *  type: Required for all options that take values. An option specified without a type is considered to be a
     *        boolean flag.
     *  repeats: A boolean value that states whether the option can be repeated or not. Repeatable options are returned
     *        as arrays.
     *  default: A default value for the option.
     *  help: A help message for the option
     *
     * @param array $option
     * @throws OptionExistsException
     * @throws InvalidArgumentDescriptionException
     * @throws UnknownCommandException
     */
    public function addOption(array $option): void
    {
        $this->validateOption($option);
        $option['command'] = $option['command'] ?? '';
        $option['repeats'] = $option['repeats'] ?? false;
        $this->options[] = $option;
        $this->addToOptionCache('name', $option);
        $this->addToOptionCache('short_name', $option);
    }

    /**
     * @param $arguments
     * @param $argPointer
     * @return mixed
     * @throws InvalidValueException
     */
    private function getNextValueOrFail($arguments, &$argPointer, $name)
    {
        if (isset($arguments[$argPointer + 1]) && $arguments[$argPointer + 1][0] != '-') {
            $argPointer++;
            return $arguments[$argPointer];
        } else {
            throw new InvalidValueException("A value must be passed along with argument $name.");
        }
    }

    /**
     * Parse a long argument that is prefixed with a double dash "--"
     *
     * @param $arguments
     * @param $argPointer
     * @throws InvalidValueException
     * @throws InvalidArgumentException
     */
    private function parseLongArgument($command, $arguments, &$argPointer, &$output)
    {
        $string = substr($arguments[$argPointer], 2);
        preg_match("/(?<name>[a-zA-Z_0-9-]+)(?<equal>=?)(?<value>.*)/", $string, $matches);
        $key = $command . $matches['name'];
        $option = $this->retrieveOptionFromCache($key, $matches['name']);
        $value = true;

        if (isset($option['type'])) {
            if ($matches['equal'] === '=') {
                $value = $matches['value'];
            } else {
                $value = $this->getNextValueOrFail($arguments, $argPointer, $matches['name']);
            }
        }

        $this->assignValue($option, $output, $option['name'], $value);
    }

    /**
     * Parse a short argument that is prefixed with a single dash '-'
     *
     * @param $command
     * @param $arguments
     * @param $argPointer
     * @throws InvalidValueException
     * @throws InvalidArgumentException
     */
    private function parseShortArgument($command, $arguments, &$argPointer, &$output)
    {
        $argument = $arguments[$argPointer];
        $key = $command . substr($argument, 1, 1);
        $option = $this->retrieveOptionFromCache($key, substr($argument, 1, 1));
        $value = true;

        if (isset($option['type'])) {
            if (substr($argument, 2) != "") {
                $value = substr($argument, 2);
            } else {
                $value = $this->getNextValueOrFail($arguments, $argPointer, $option['name']);
            }
        }

        $this->assignValue($option, $output, $option['name'], $value);
    }

    private function assignValue($option, &$output, $key, $value)
    {
        if($option['repeats']) {
            $output[$key] = isset($output[$key]) ? array_merge($output[$key], [$value]) : [$value];
        } else {
            $output[$key] = $value;
        }
    }

    /**
     * @param $arguments
     * @param $argPointer
     * @param $output
     * @throws InvalidValueException
     * @throws InvalidArgumentException
     */
    private function parseArgumentArray($arguments, &$argPointer, &$output)
    {
        $numArguments = count($arguments);
        $command = $output['__command'] ?? '';
        for (; $argPointer < $numArguments; $argPointer++) {
            $arg = $arguments[$argPointer];
            if (substr($arg, 0, 2) == "--") {
                $this->parseLongArgument($command, $arguments, $argPointer, $output);
            } else if ($arg[0] == '-') {
                $this->parseShortArgument($command, $arguments, $argPointer, $output);
            } else {
                $output['__args'] = isset($output['__args']) ? array_merge($output['__args'], [$arg]) : [$arg];
            }
        }
    }

    /**
     * @param $output
     * @throws HelpMessageRequestedException
     */
    private function maybeShowHelp($output)
    {
        if ((isset($output['help']) && $output['help'] && $this->helpEnabled)) {
            print $this->getHelpMessage($output['__command'] ?? null);
            throw new HelpMessageRequestedException();
        }
    }

    private function parseCommand($arguments, &$argPointer, &$output)
    {
        if (count($arguments) > 1 && isset($this->commands[$arguments[$argPointer]])) {
            $output["__command"] = $arguments[$argPointer];
            $argPointer++;
        }
    }

    /**
     * @param $parsed
     * @throws InvalidArgumentException
     */
    private function fillInDefaults(&$parsed)
    {
        foreach($this->options as $option) {
            if(!isset($parsed[$option['name']]) && isset($option['default'])) {
                $parsed[$option['name']] = $option['default'];
            }
        }
    }

    /**
     * @throws InvalidArgumentException
     */
    private function validateRequired()
    {
        $required = [];
        foreach($this->options as $option) {
            if(isset($option['required']) && $option['required'] && !isset($parsed[$option['name']])) {

The variable $parsed seems to never exist and therefore isset should always be false.

                $required[] = $option['name'];
            }
        }

        if(!empty(($required))) {
            throw new InvalidArgumentException(
                sprintf("The following options are required: %s. Pass the --help option for more information about possible options.", implode(", $required"))

', '.$required of type string is incompatible with the type array expected by parameter $pieces of implode().

            );
        }

    }

    /**
     * Parses command line arguments and return a structured array of options and their associated values.
     *
     * @param array $arguments An optional array of arguments that would be parsed instead of those passed to the CLI.
     * @return array
     * @throws InvalidValueException
     */
    public function parse($arguments = null)
    {
        try{
            global $argv;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

            $arguments = $arguments ?? $argv;
            $argPointer = 1;
            $parsed = [];
            $this->name = $this->name ?? $arguments[0];
            $this->parseCommand($arguments, $argPointer, $parsed);
            $this->parseArgumentArray($arguments, $argPointer, $parsed);
            $this->validateRequired();
            $this->fillInDefaults($parsed);
            $this->maybeShowHelp($parsed);
            return $parsed;
        } catch (HelpMessageRequestedException $exception) {
            $this->programControl->quit();
        } catch (InvalidArgumentException $exception) {
            print $exception->getMessage();
            $this->programControl->quit();
        }
    }

    /**
     * Enables help messages so they show automatically.
     *
     * @param string $name
     * @param string $description
     * @param string $footer
     *
     * @throws InvalidArgumentDescriptionException
     * @throws OptionExistsException
     * @throws UnknownCommandException
     */
    public function enableHelp(string $description = null, string $footer = null, string $name = null) : void
    {
        $this->name = $name;
        $this->description = $description;
        $this->footer = $footer;
        $this->helpEnabled = true;
        $this->addOption(['name' => 'help', 'short_name' => 'h', 'help' => "display this help message"]);
        foreach($this->commands as $command) {
            $this->addOption(['name' => 'help', 'help' => 'display this help message', 'command' => $command['name']]);
        }
    }

    public function getHelpMessage($command = '')
    {
        return $this->helpGenerator->generate(
            $this->name, $command ?? null,
            ['options' => $this->options, 'commands' => $this->commands],
            $this->description, $this->footer
        );
    }

    /**
     * @param $command
     * @throws CommandExistsException
     * @throws InvalidArgumentDescriptionException
     */
    public function addCommand($command)
    {
        if (!isset($command['name'])) {
            throw new InvalidArgumentDescriptionException("Command description must contain a name");
        }
        if (isset($this->commands[$command['name']])) {
            throw new CommandExistsException("Command ${command['name']} already exists.");
        }
        $this->commands[$command['name']] = $command;
    }
}