Linio\Component\Input\InputHandler

Complexity

Total Complexity

12

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	add()	0	4	1
A	remove()	0	4	1
A	bind()	0	12	3
A	getData()	0	12	3
A	isValid()	0	4	1
A	getErrors()	0	4	1
A	getErrorsAsString()	0	4	1
	define()	0	1	?

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 9 and the first side effect is on line 2.

declare(strict_types=1);

namespace Linio\Component\Input;

use Linio\Component\Input\Exception\RequiredFieldException;
use Linio\Component\Input\Node\BaseNode;

abstract class InputHandler

InputHandler does not seem to conform to the naming convention (^Abstract|Factory$).

{
    /**
     * @var BaseNode
     */
    protected $root;

    /**
     * @var TypeHandler
     */
    protected $typeHandler;

    /**
     * @var array
     */
    protected $output = [];

    /**
     * @var array
     */
    protected $errors = [];

    public function __construct(TypeHandler $typeHandler = null)
    {
        $this->root = new BaseNode();
        $this->typeHandler = $typeHandler ?? new TypeHandler();
        $this->root->setTypeHandler($this->typeHandler);
    }

    public function add(string $key, string $type, array $options = []): BaseNode
    {
        return $this->root->add($key, $type, $options);
    }

    public function remove(string $key)
    {
        $this->root->remove($key);
    }

    public function bind(array $input)
    {
        $this->define();

        try {
            $this->output = $this->root->walk($input);
        } catch (RequiredFieldException $exception) {
            $this->errors[] = 'Missing required field: ' . $exception->getField();
        } catch (\RuntimeException $exception) {
            $this->errors[] = $exception->getMessage();
        }
    }

    public function getData($index = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (!$this->isValid()) {
            throw new \RuntimeException($this->getErrorsAsString());
        }

        if ($index) {
            return $this->output[$index];
        }

        return $this->output;
    }

    public function isValid(): bool
    {
        return empty($this->errors);
    }

    public function getErrors(): array
    {
        return $this->errors;
    }

    public function getErrorsAsString(): string
    {
        return implode(', ', $this->errors);
    }

    abstract public function define();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

}