Amarkal\UI\ComponentList

Complexity

Total Complexity

18

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get_by_name()	0	11	3
A	get_by_type()	0	6	1
A	get_all()	0	4	1
A	get_value_components()	0	6	1
A	get_filterable_components()	0	6	1
A	get_validatable_components()	0	6	1
A	add_components()	0	7	2
A	add_component()	0	12	2
A	verify_name_uniqueness()	0	15	4
A	filter()	0	4	1

<?php

namespace Amarkal\UI;

/**
 * Implements a data structure consisting of a list of UI components
 */
class ComponentList
{
    /**
     * The list of component argument arrays
     *
     * @var array
     */
    private $components = array();

    /**
     * Set the components
     *
     * @param array $components
     */
    public function __construct( array $components = array() )
    {
        $this->add_components($components);
    }

    /**
     * Get a component by name. Only applicable to value components.
     *
     * @param string $name
     * @return AbstractComponent
     */
    public function get_by_name( $name )
    {
        $filtered = $this->filter(function($c) use ($name) {

function ($c) use($name) { return $c instanceof \Amarkal\UI\ValueComponentInterface && $c->name === $name; } is of type object<Closure>, but the function expects a object<Amarkal\UI\function>.

            return $c instanceof ValueComponentInterface && $c->name === $name;

Accessing name on the interface Amarkal\UI\ValueComponentInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        });
        if(count($filtered) < 1)
        {
            throw new \RuntimeException("No component with the name <b>$name</b> could be found.");
        }
        return $filtered[0];
    }

    /**
     * Get components by type
     *
     * @param string $type
     * @return AbstractComponent[]
     */
    public function get_by_type( $type )
    {
        return $this->filter(function($c) use ($type) {

function ($c) use($type) { return $c->component_type === $type; } is of type object<Closure>, but the function expects a object<Amarkal\UI\function>.

            return $c->component_type === $type;
        });
    }

    /**
     * Get all components.
     *
     * @return AbstractComponent[]
     */
    public function get_all()
    {
        return $this->components;
    }

    /**
     * Get all the components that implement the ValueComponentInterface
     *
     * @return AbstractComponent[]
     */
    public function get_value_components()
    {
        return $this->filter(function($c) {

function ($c) { return $c instanceof \Amarkal\UI\ValueComponentInterface; } is of type object<Closure>, but the function expects a object<Amarkal\UI\function>.

            return $c instanceof ValueComponentInterface;
        });
    }

    /**
     * Get all the components that implement the FilterableComponentInterface
     *
     * @return AbstractComponent[]
     */
    public function get_filterable_components()
    {
        return $this->filter(function($c) {

function ($c) { return $c instanceof \Amarkal\UI\FilterableComponentInterface; } is of type object<Closure>, but the function expects a object<Amarkal\UI\function>.

            return $c instanceof FilterableComponentInterface;
        });
    }

    /**
     * Get all the components that implement the ValidatableComponentInterface
     *
     * @return AbstractComponent[]
     */
    public function get_validatable_components()
    {
        return $this->filter(function($c) {

function ($c) { return $c instanceof \Amarkal\UI\ValidatableComponentInterface; } is of type object<Closure>, but the function expects a object<Amarkal\UI\function>.

            return $c instanceof ValidatableComponentInterface;
        });
    }

    /**
     * Add an array of components to the list
     *
     * @param AbstractComponent[] $components
     * @return void
     */
    public function add_components( array $components )
    {
        foreach( $components as $component )
        {
            $this->add_component($component);

$component is of type object<Amarkal\UI\AbstractComponent>, but the function expects a array<integer,object<Amarkal\UI\AbstractComponent>>.

        }
    }

    /**
     * Add a single component to the list
     *
     * @param AbstractComponent[] $args
     * @return void
     */
    public function add_component( array $args )
    {
        if(!array_key_exists('type', $args))
        {
            throw new \RuntimeException("Component configuration arrays must have a <b>type</b> argument");
        }

        $comp = ComponentFactory::create($args['type'], $args);

$args['type'] is of type object<Amarkal\UI\AbstractComponent>, but the function expects a string.

        $this->verify_name_uniqueness($comp);
        $this->components[] = $comp;
    }

    /**
     * Verify that the given component name is unique among the list of value components
     *
     * @param AbstractComponent $comp
     * @return void
     */
    private function verify_name_uniqueness( AbstractComponent $comp )
    {
        if(!($comp instanceof ValueComponentInterface))
        {
            return;
        }

        foreach ($this->components as $c) 
        {
            if($c->name === $comp->name)
            {
                throw new \RuntimeException("Duplicate component name detected for the name <b>{$c->name}</b>.");
            }
        }
    }

    /**
     * Filter the list of components
     *
     * @param function $callable
     * @return array
     */
    private function filter( $callable )
    {
        return array_filter($this->components, $callable);
    }
}