Railt\Compiler\Parser\Ast\Rule

Complexity

Total Complexity

20

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

18.92%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getChildren()	0	8	2
A	getChild()	0	4	1
A	hasChildren()	0	4	1
A	append()	0	6	1
A	pop()	0	4	2
A	count()	0	4	1
A	getIterator()	0	4	1
B	find()	0	14	6
A	getValue()	0	12	4

<?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\Compiler\Parser\Ast;

/**
 * Class Rule
 */
class Rule extends Node implements RuleInterface
{
    /**
     * @var array|iterable|\Traversable
     */
    protected $children;

    /**
     * Rule constructor.
     * @param string $name
     * @param iterable $children
     */
    public function __construct(string $name, iterable $children = [], int $offset = 0)
    {
        parent::__construct($name, $offset);
        $this->children = $children;
    }

    /**
     * @return array
     */
    public function getChildren(): array
    {
        if ($this->children instanceof \Traversable) {
            $this->children = \iterator_to_array($this->children);
        }

        return $this->children;
    }

    /**
     * @param int $index
     * @return null|NodeInterface
     */
    public function getChild(int $index): ?NodeInterface
    {
        return $this->getChildren()[$index] ?? null;
    }

    /**
     * @return bool
     */
    public function hasChildren(): bool
    {
        return \count($this->getChildren()) > 0;
    }

    /**
     * @param NodeInterface $node
     */
    public function append(NodeInterface $node): void
    {
        $this->getChildren();

        $this->children[] = $node;
    }

    /**
     * @return null|NodeInterface
     */
    public function pop(): ?NodeInterface
    {
        return \count($this->children) ? \array_pop($this->children) : null;

The expression \count($this->children) ? \array_pop($this->children) : null; of type array|null adds the type array to the return on line 77 which is incompatible with the return type declared by the interface Railt\Compiler\Parser\Ast\RuleInterface::pop of type null|Railt\Compiler\Parser\Ast\NodeInterface.

    }

    /**
     * @return int
     */
    public function count(): int
    {
        return \count($this->getChildren());
    }

    /**
     * @return \Traversable
     */
    public function getIterator(): \Traversable
    {
        yield from $this->getChildren();
    }

    /**
     * @param string $name
     * @param int|null $depth
     * @return null|NodeInterface
     */
    public function find(string $name, int $depth = null): ?NodeInterface
    {
        foreach ($this->getChildren() as $child) {
            if ($child->is($name)) {
                return $child;
            }

            if (\is_int($depth) && $depth > 0 && $child instanceof RuleInterface) {
                return $child->find($name, $depth - 1);
            }
        }

        return null;
    }

    /**
     * @return string[]|\Traversable
     */
    public function getValue()
    {
        foreach ($this->children as $child) {
            if ($child instanceof RuleInterface) {
                yield from $child->getValue();
            }

            if ($child instanceof LeafInterface) {
                yield $child => $child->getValue();
            }
        }
    }
}