TYPO3Fluid\Fluid\Component\Argument\ArgumentCollection

Complexity

Total Complexity

20

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setRenderingContext()	0	5	1
A	getRenderingContext()	0	4	1
A	getDefinitions()	0	4	1
A	assignAll()	0	7	2
A	getAllRaw()	0	4	1
A	getRaw()	0	5	1
A	addDefinition()	0	6	1
A	setDefinitions()	0	5	1
A	offsetGet()	0	11	4
A	getArrayCopy()	0	8	2
A	validate()	0	14	5

<?php
declare(strict_types=1);
namespace TYPO3Fluid\Fluid\Component\Argument;

/*
 * This file belongs to the package "TYPO3 Fluid".
 * See LICENSE.txt that was shipped with this package.
 */

use TYPO3Fluid\Fluid\Component\ComponentInterface;
use TYPO3Fluid\Fluid\Core\Parser\Exception;
use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;

/**
 * Argument Collection
 *
 * Acts as container around a set of arguments and associated
 * ArgumentDefinition and their values.
 *
 * Contains the API used for validating and converting arguments.
 */
class ArgumentCollection extends \ArrayObject
{
    /**
     * @var ArgumentDefinition[]
     */
    protected $definitions = [];

    /**
     * @var RenderingContextInterface
     */
    protected $renderingContext;

    public function setRenderingContext(RenderingContextInterface $renderingContext): self
    {
        $this->renderingContext = $renderingContext;
        return $this;
    }

    public function getRenderingContext(): RenderingContextInterface
    {
        return $this->renderingContext;
    }

    public function getDefinitions(): iterable
    {
        return $this->definitions;
    }

    public function assignAll(iterable $values): ArgumentCollection
    {
        foreach ($values as $name => $value) {
            $this[$name] = $value;
        }
        return $this;
    }

    public function getAllRaw(): iterable
    {
        return parent::getArrayCopy();

It seems like you call parent on a different method (getArrayCopy() instead of getAllRaw()). Are you sure this is correct? If so, you might want to change this to $this->getArrayCopy().

    }

    public function getRaw(string $argumentName)
    {
        $value = $this[$argumentName] ?? null;
        return $value;
    }

    public function addDefinition(ArgumentDefinition $definition): ArgumentCollection
    {
        $argumentName = $definition->getName();
        $this->definitions[$argumentName] = $definition;
        return $this;
    }

    /**
     * @param iterable|ArgumentDefinition[] $definitions
     * @return ArgumentCollection
     */
    public function setDefinitions(iterable $definitions): ArgumentCollection
    {
        $this->definitions = $definitions;

It seems like $definitions can also be of type object<TYPO3Fluid\Fluid\Component\Argument\iterable>. However, the property $definitions is declared as type array<integer,object<TYPO3Fluid\Fluid\Component\Argument\ArgumentDefinition>>. Maybe add an additional type check?

        return $this;
    }

    public function offsetGet($offset)
    {
        if (isset($this->definitions[$offset]) && !parent::offsetExists($offset)) {

It seems like you call parent on a different method (offsetExists() instead of offsetGet()). Are you sure this is correct? If so, you might want to change this to $this->offsetExists().

            return $this->definitions[$offset]->getDefaultValue();
        }
        $value = parent::offsetGet($offset);
        if ($value instanceof ComponentInterface) {
            $value = $value->evaluate($this->renderingContext);
        }
        return $value;
    }

    public function getArrayCopy(): array
    {
        $data = [];
        foreach (parent::getArrayCopy() + $this->definitions as $name => $_) {
            $data[$name] = $this[$name];
        }
        return $data;
    }

    /**
     * Creates arguments by padding with missing+optional arguments
     * and casting or creating BooleanNode where appropriate. Input
     * array may not contain all arguments - output array will.
     */
    public function validate(): self
    {
        $missingArguments = [];
        foreach ($this->definitions as $name => $definition) {
            if ($definition->isRequired() && !parent::offsetExists($name)) {

It seems like you call parent on a different method (offsetExists() instead of validate()). Are you sure this is correct? If so, you might want to change this to $this->offsetExists().

                // Required but missing argument, causes failure (delayed, to report all missing arguments at once)
                $missingArguments[] = $name;
            }
        }
        if (!empty($missingArguments)) {
            throw new Exception('Required argument(s) not provided: ' . implode(', ', $missingArguments), 1558533510);
        }
        return $this;
    }
}