Vanderlee\Comprehend\Builder\RuleToParserTrait

Complexity

Total Complexity

17

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	1	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	argumentRuleToParser()	0	9	4
A	ruleToParser()	0	10	3
A	definitionRuleToParser()	0	7	2
A	parserRuleToParser()	0	7	2
A	classnameRuleToParser()	0	9	4
A	callableRuleToParser()	0	7	2

<?php

namespace Vanderlee\Comprehend\Builder;

use Vanderlee\Comprehend\Parser\Parser;

trait RuleToParserTrait
{
    /**
     * List of static methods (in order) to attempt instantiating a rule.
     *
     * @var string[]
     */
    private static $ruleToParserMethods = [
        'definitionRuleToParser',
        'parserRuleToParser',
        'callableRuleToParser',
        'classnameRuleToParser',
        'argumentRuleToParser',
    ];

    /**
     * @param mixed $rule
     * @param array $arguments
     *
     * @return Implementation|null
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
     */
    private static function definitionRuleToParser($rule, $arguments)
    {
        if ($rule instanceof Definition) {
            return new Implementation($rule, $arguments);
        }

        return null;
    }

    /**
     * @param mixed $rule
     *
     * @return Parser|null
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
     */
    private static function parserRuleToParser($rule)
    {
        if ($rule instanceof Parser) {
            return clone $rule;
        }

        return null;
    }

    /**
     * @param mixed $rule
     * @param array $arguments
     *
     * @return Parser|null
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
     */
    private static function callableRuleToParser($rule, $arguments)
    {
        if (is_callable($rule)) {
            return $rule(...$arguments);
        }

        return null;
    }

    /**
     * @param mixed $rule
     * @param array $arguments
     *
     * @return Parser|null
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
     */
    private static function classnameRuleToParser($rule, $arguments)
    {
        if (is_string($rule)
            && class_exists($rule)
            && is_subclass_of($rule, Parser::class)) {
            return new $rule(...$arguments);
        }

        return null;
    }

    /**
     * @param mixed $rule
     *
     * @return Parser|null
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
     */
    private static function argumentRuleToParser($rule)
    {
        if (is_array($rule)
            || is_string($rule)
            || is_int($rule)) {
            return self::getArgument($rule);
        }

        return null;
    }

    /**
     * @param mixed $rule
     * @param       $arguments
     *
     * @return Parser|null
     */
    private static function ruleToParser(&$rule, $arguments)
    {
        foreach (self::$ruleToParserMethods as $ruleToParserMethod) {
            $instance = self::$ruleToParserMethod($rule, $arguments);
            if ($instance) {
                return $instance;
            }
        }

        return null;
    }
}