Pinepain\JsSandbox\Extractors\ExtractorDefinitionBuilder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

88.89%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	14	3
B	buildExtractor()	0	25	6
A	buildVariableDefinition()	0	19	4

<?php declare(strict_types=1);

/*
 * This file is part of the pinepain/js-sandbox PHP library.
 *
 * Copyright (c) 2016-2017 Bogdan Padalko <pinepain@gmail.com>
 *
 * Licensed under the MIT license: http://opensource.org/licenses/MIT
 *
 * For the full copyright and license information, please view the
 * LICENSE file that was distributed with this source or visit
 * http://opensource.org/licenses/MIT
 */


namespace Pinepain\JsSandbox\Extractors;


use Pinepain\JsSandbox\Extractors\Definition\ExtractorDefinitionInterface;
use Pinepain\JsSandbox\Extractors\Definition\PlainExtractorDefinition;
use Pinepain\JsSandbox\Extractors\Definition\PlainExtractorDefinitionInterface;
use Pinepain\JsSandbox\Extractors\Definition\VariableExtractorDefinition;


class ExtractorDefinitionBuilder implements ExtractorDefinitionBuilderInterface
{
    /**
     * @var string
     */
    protected $type_regexp = '/
    ^(
        (?<name>
            [-_\w]*
        )
        (?:
            \s*
            \(
            \s*
            (?<param>
                (?-3)*
                |
                [\w\\\\]+
            )
            \s*
            \)
        )?
        (?:
            \s*
            \|
            \s*
            (?<alt>(?-4))
        )?
        (?:
            \s*
            (?<arr>\[\s*\])
            \s*
        )?
    )
    $
    /xi';

    protected $type_regexp2 = '/
    ^
        (?:((\w+\b(?:\(.*\))?(?:\s*\[\s*\])?)(?:\s*\|\s*(?-1))*))
        |
        (?:\(\s*(?-2)\s*\)(?:\s*\[\s*\])?)
        |
        (\[\s*\])
    $
    /xi';

    /**
     * {@inheritdoc}
     */
    public function build(string $definition): ExtractorDefinitionInterface
    {
        $definition = trim($definition);

        if (!$definition) {
            throw new ExtractorDefinitionBuilderException('Definition must be non-empty string');
        }

        if (preg_match($this->type_regexp, $definition, $matches)) {
            return $this->buildExtractor($matches['name'], $matches['param'] ?? null, $matches['alt'] ?? null, isset($matches['arr']));
        }

        throw new ExtractorDefinitionBuilderException("Unable to parse definition: '{$definition}'");
    }

    /**
     * @param string      $name
     * @param null|string $param
     * @param null|string $alt_definitions
     *
     * @return ExtractorDefinitionInterface
     * @throws ExtractorDefinitionBuilderException
     */
    protected function buildExtractor(string $name, ?string $param, ?string $alt_definitions, bool $is_arr): ExtractorDefinitionInterface
    {
        $next = null;

        if ($param && preg_match($this->type_regexp, $param, $matches)) {

The expression $param of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $next = $this->buildExtractor($matches['name'], $matches['param'] ?? null, $matches['alt'] ?? null, isset($matches['arr']));
        }

        if ($name) {
            $definition = new PlainExtractorDefinition($name, $next);
        } else {
            $definition = $next;
        }

        if ($is_arr) {
            // arrayed definition
            $definition = new PlainExtractorDefinition('[]', $definition);
        }

        if ($alt_definitions) {

The expression $alt_definitions of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $definition = $this->buildVariableDefinition($definition, $alt_definitions);

$definition is of type object<Pinepain\JsSandbox\Extractors\Definition\ExtractorDefinitionInterface>|null, but the function expects a object<Pinepain\JsSandbox\Extractors\Definition\PlainExtractorDefinitionInterface>.

        }

        return $definition;
    }

    /**
     * @param PlainExtractorDefinitionInterface $definition
     * @param string                            $alt_definitions
     *
     * @return VariableExtractorDefinition
     * @throws ExtractorDefinitionBuilderException
     */
    protected function buildVariableDefinition(PlainExtractorDefinitionInterface $definition, string $alt_definitions): VariableExtractorDefinition
    {
        $alt = [$definition];

        while ($alt_definitions && preg_match($this->type_regexp, $alt_definitions, $matches)) {

The expression $alt_definitions of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            // build alt
            $alt[] = $this->buildExtractor($matches['name'], $matches['param'] ?? null, null, false);

            $alt_definitions = $matches['alt'] ?? null;
        }

        if ($alt_definitions) {

The expression $alt_definitions of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            // UNEXPECTED
            // this should not be possible, but just in case we will ever get here
            throw new ExtractorDefinitionBuilderException('Invalid varying definition');
        }

        return new VariableExtractorDefinition(...$alt);
    }

}