Vanderlee\Comprehend\Core\ArgumentsTrait

Complexity

Total Complexity

14

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getArrayArgument()	0	13	4
A	getStringArgument()	0	11	3
A	getArguments()	0	5	1
A	getArgument()	0	22	6

<?php

namespace Vanderlee\Comprehend\Core;

use Vanderlee\Comprehend\Parser\Parser;
use Vanderlee\Comprehend\Parser\Structure\Choice;
use Vanderlee\Comprehend\Parser\Structure\Sequence;
use Vanderlee\Comprehend\Parser\Terminal\Char;
use Vanderlee\Comprehend\Parser\Terminal\Text;

/**
 * Process arguments
 *
 * @author Martijn
 */
trait ArgumentsTrait
{

    /**
     * Parser array argument
     *
     * @param mixed $argument
     * @param bool $arrayToSequence
     * @return Parser|Choice|Sequence
     */
    private static function getArrayArgument($argument, $arrayToSequence)
    {
        if (empty($argument)) {
            throw new \InvalidArgumentException('Empty array argument');
        }

        if (count($argument) === 1) {
            return self::getArgument(reset($argument));
        }

        return $arrayToSequence
            ? new Sequence(...$argument)
            : new Choice(...$argument);
    }

    /**
     * Parse string argument
     *
     * @param mixed $argument
     * @return Char|Text
     */
    private static function getStringArgument($argument)
    {
        if (strlen($argument) === 0) {
            throw new \InvalidArgumentException('Empty argument');
        }

        if (strlen($argument) === 1) {
            return new Char($argument);
        }

        return new Text($argument);
    }

    /**
     * Convert the argument to a parser
     *
     * @param mixed $argument
     * @param bool $arrayToSequence if argument is an array, convert to Sequence (`true`) or Choice (`false`)
     * @return Parser
     */
    protected static function getArgument($argument, $arrayToSequence = true)
    {
        if (is_array($argument)) {
            return self::getArrayArgument($argument, $arrayToSequence);
        }

        if (is_string($argument)) {
            return self::getStringArgument($argument);
        }

        if (is_int($argument)) {
            return new Char($argument);
        }

        if ($argument instanceof Parser) {
            return $argument;
        }

        throw new \InvalidArgumentException(sprintf('Invalid argument type `%1$s`',
            is_object($argument)
                ? get_class($argument)
                : gettype($argument)));
    }

    /**
     * Parse an array of arguments
     *
     * @param array $arguments
     * @param bool $arrayToSequence
     * @return array
     */
    protected static function getArguments($arguments, $arrayToSequence = true)
    {
        return array_map(function ($argument) use ($arrayToSequence) {
            return self::getArgument($argument, $arrayToSequence);
        }, $arguments);
    }
}