railt / console

src/SignatureParser.php

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Console;

use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;

/**
 * Class SignatureParser
 */
class SignatureParser
{
    /**
     * @var string
     */
    private $name;

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

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

    /**
     * SignatureParser constructor.
     * @param string $signature
     * @throws \InvalidArgumentException
     */
    public function __construct(string $signature)
    {
        [$this->name, $this->arguments, $this->options] = $this->parse($signature);
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @return array
     */
    public function getArguments(): array
    {
        return $this->arguments;
    }

    /**
     * @return array
     */
    public function getOptions(): array
    {
        return $this->options;
    }

    /**
     * Parse the given console command definition into an array.
     *
     * @param string $expression
     * @return array
     * @throws \InvalidArgumentException
     */
    protected function parse($expression): array
    {
        $name = $this->name($expression);

        if (\preg_match_all('/\{\s*(.*?)\s*\}/', $expression, $matches) && \count($matches[1])) {
            return \array_merge([$name], $this->parameters($matches[1]));
        }

        return [$name, [], []];
    }

    /**
     * Extract the name of the command from the expression.
     *
     * @param string $expression
     * @return string
     * @throws \InvalidArgumentException
     */
    protected function name($expression): string
    {
        if (\trim($expression) === '') {
            throw new \InvalidArgumentException('Console command definition is empty.');
        }

        if (! \preg_match('/[\S]+/', $expression, $matches)) {
            throw new \InvalidArgumentException('Unable to determine command name from signature.');
        }

        return $matches[0];
    }

    /**
     * Extract all of the parameters from the tokens.
     *
     * @param array $tokens
     * @return array
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    protected function parameters(array $tokens): array
    {
        [$arguments, $options] = [[], []];

        foreach ($tokens as $token) {
            if (\preg_match('/-{2,}(.*)/', $token, $matches)) {
                $options[] = $this->parseOption($matches[1]);

$options was never initialized. Although not strictly required by PHP, it is generally a good practice to add $options = array(); before regardless.

            } else {
                $arguments[] = $this->parseArgument($token);

$arguments was never initialized. Although not strictly required by PHP, it is generally a good practice to add $arguments = array(); before regardless.

            }
        }

        return [$arguments, $options];
    }

    /**
     * Parse an option expression.
     *
     * @param string $token
     * @return \Symfony\Component\Console\Input\InputOption
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    protected function parseOption($token): ?InputOption
    {
        [$token, $description] = $this->extractDescription($token);

        $matches = \preg_split('/\s*\|\s*/', $token, 2);

        if (isset($matches[1])) {
            [$shortcut, $token] = [$matches[0], $matches[1]];
        } else {
            $shortcut = null;
        }

        switch (true) {
            case $this->endsWith($token, '='):
                return new InputOption(\trim($token, '='), $shortcut, InputOption::VALUE_OPTIONAL, $description);

            case $this->endsWith($token, '=*'):
                return new InputOption(\trim($token, '=*'), $shortcut, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, $description);

            case \preg_match('/(.+)\=\*(.+)/', $token, $matches):
                return new InputOption($matches[1], $shortcut, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, $description, \preg_split('/,\s?/', $matches[2]));

            case \preg_match('/(.+)\=(.+)/', $token, $matches):
                return new InputOption($matches[1], $shortcut, InputOption::VALUE_OPTIONAL, $description, $matches[2]);

            default:
                return new InputOption($token, $shortcut, InputOption::VALUE_NONE, $description);
        }
    }

    /**
     * Parse the token into its token and description segments.
     *
     * @param  string $token
     * @return array
     */
    protected function extractDescription($token): array
    {
        $parts = \preg_split('/\s+:\s+/', \trim($token), 2);

        return \count($parts) === 2 ? $parts : [$token, ''];
    }

    /**
     * @param string $haystack
     * @param string $needle
     * @return bool
     */
    private function endsWith(string $haystack, string $needle): bool
    {
        return \substr($haystack, -\strlen($needle)) === $needle;
    }

    /**
     * Parse an argument expression.
     *
     * @param string $token
     * @return \Symfony\Component\Console\Input\InputArgument
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    protected function parseArgument($token): ?InputArgument
    {
        [$token, $description] = $this->extractDescription($token);

        switch (true) {
            case $this->endsWith($token, '?*'):
                return new InputArgument(\trim($token, '?*'), InputArgument::IS_ARRAY, $description);

            case $this->endsWith($token, '*'):
                return new InputArgument(\trim($token, '*'), InputArgument::IS_ARRAY | InputArgument::REQUIRED, $description);

            case $this->endsWith($token, '?'):
                return new InputArgument(\trim($token, '?'), InputArgument::OPTIONAL, $description);

            case \preg_match('/(.+)\=\*(.+)/', $token, $matches):
                return new InputArgument($matches[1], InputArgument::IS_ARRAY, $description, \preg_split('/,\s?/', $matches[2]));

            case \preg_match('/(.+)\=(.+)/', $token, $matches):
                return new InputArgument($matches[1], InputArgument::OPTIONAL, $description, $matches[2]);

            default:
                return new InputArgument($token, InputArgument::REQUIRED, $description);
        }
    }
}