Dazzle\Util\Factory\FactoryTrait

Complexity

Total Complexity

18

Size/Duplication

Total Lines	150
Duplicated Lines	6 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__destruct()	0	5	1
A	bindParam()	0	6	1
A	unbindParam()	0	6	1
A	getParam()	9	9	2
A	hasParam()	0	4	1
A	getParams()	0	4	1
A	define()	0	6	1
A	remove()	0	6	1
A	getDefinition()	0	9	2
A	hasDefinition()	0	4	1
A	getDefinitions()	0	4	1
A	create()	0	9	2
A	invoke()	0	4	2

<?php

namespace Dazzle\Util\Factory;

use Dazzle\Throwable\Exception\Logic\IllegalCallException;
use Dazzle\Throwable\Exception\Logic\IllegalFieldException;

trait FactoryTrait
{
    /**
     * @var mixed[]
     */
    protected $params;

    /**
     * @var callable[]
     */
    protected $definitions;

    /**
     *
     */
    public function __construct()
    {
        $this->params = [];
        $this->definitions = [];
    }

    /**
     *
     */
    public function __destruct()
    {
        unset($this->params);
        unset($this->definitions);
    }

    /**
     * @see FactoryInterface::bindParam
     */
    public function bindParam($name, $value)
    {
        $this->params[$name] = $value;

        return $this;
    }

    /**
     * @see FactoryInterface::unbindParam
     */
    public function unbindParam($name)
    {
        unset($this->params[$name]);

        return $this;
    }

    /**
     * @see FactoryInterface::getParam
     */
    public function getParam($name)

This method seems to be duplicated in your project.

    {
        if (!array_key_exists($name, $this->params))
        {
            throw new IllegalFieldException("Factory does not posses param [$name].");
        }

        return $this->invoke($this->params[$name]);
    }

    /**
     * @see FactoryInterface::hasParam
     */
    public function hasParam($param)
    {
        return array_key_exists($param, $this->params);
    }

    /**
     * @see FactoryInterface::getParams
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * @see FactoryInterface::define
     */
    public function define($name, callable $factoryMethod)
    {
        $this->definitions[$name] = $factoryMethod;

        return $this;
    }

    /**
     * @see FactoryInterface::remove
     */
    public function remove($name)
    {
        unset($this->definitions[$name]);

        return $this;
    }

    /**
     * @see FactoryInterface::getDefinition
     */
    public function getDefinition($name)
    {
        if (!isset($this->definitions[$name]))
        {
            throw new IllegalFieldException("Factory does not posses definition [$name].");
        }

        return $this->definitions[$name];
    }

    /**
     * @see FactoryInterface::hasDefinition
     */
    public function hasDefinition($name)
    {
        return array_key_exists($name, $this->definitions);
    }

    /**
     * @see FactoryInterface::getDefinitions
     */
    public function getDefinitions()
    {
        return $this->definitions;
    }

    /**
     * @see FactoryInterface::create
     */
    public function create($name, $args = [])
    {
        if (!isset($this->definitions[$name]))
        {
            throw new IllegalCallException("Factory does not posses definition for [$name].");
        }

        return call_user_func_array($this->definitions[$name], (array) $args);
    }

    /**
     * @param mixed $value
     * @return mixed
     */
    private function invoke($value)
    {
        return is_callable($value) ? $value() : $value;
    }
}