drupol\DynamicObjects\DynamicObjectsTrait

Complexity

Total Complexity

35

Size/Duplication

Total Lines	285
Duplicated Lines	10.18 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

98.73%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	addDynamicProperty()	14	14	3
A	addDynamicMethod()	15	15	3
A	hasDynamicProperty()	0	4	1
A	hasDynamicMethod()	0	4	1
A	getDynamicProperty()	0	8	2
A	getDynamicMethod()	0	5	2
A	clearDynamicProperties()	0	4	1
A	clearDynamicMethods()	0	4	1
A	removeDynamicProperty()	0	4	1
A	removeDynamicMethod()	0	4	1
A	doDynamicRequest()	0	12	4
B	extend()	0	20	5
A	__call()	0	8	2
A	__callStatic()	0	12	3
A	__get()	0	14	3
A	__set()	0	6	2

<?php

namespace drupol\DynamicObjects;

use drupol\Memoize\MemoizeTrait;

/**
 * Trait DynamicObjectsTrait.
 *
 * @package drupol\DynamicObjects
 */
trait DynamicObjectsTrait
{
    use MemoizeTrait;

    /**
     * @var array
     */
    protected static $dynamicMethods = array();

    /**
     * @var array
     */
    protected static $dynamicProperties = array();

    /**
     * Add a dynamic property.
     *
     * @param string|array $names
     *   The property name or an array of property names.
     * @param mixed $value
     *   The property value.
     * @param bool $memoize
     *   Memoize parameter.
     */
    public static function addDynamicProperty($names, $value, $memoize = false)

This method seems to be duplicated in your project.

    {
        if (!is_array($names)) {
            $names = array($names);
        }

        foreach ($names as $property) {
            static::$dynamicProperties[get_called_class()][$property] = [
                'name' => $property,
                'factory' => $value,
                'memoize' => $memoize,
            ];
        }
    }

    /**
     * Add a dynamic method.
     *
     * @param string|array $names
     *   The method name or an array of method names.
     * @param \Closure $func
     *   The method.
     * @param bool $memoize
     *   Memoize parameter.
     * @param bool $static
     *   Static flag parameter.
     */
    public static function addDynamicMethod($names, \Closure $func, $memoize = false, $static = false)

This method seems to be duplicated in your project.

    {
        if (!is_array($names)) {
            $names = array($names);
        }

        foreach ($names as $method) {
            static::$dynamicMethods[get_called_class()][$method] = [
                'name' => $method,
                'factory' => $func,
                'memoize' => $memoize,
                'static' => $static,
            ];
        }
    }

    /**
     * Check if a dynamic property exists.
     *
     * @param string $name
     *   The property name.
     * @return bool
     *   True if the property exists, false otherwise.
     */
    public static function hasDynamicProperty($name)
    {
        return isset(static::$dynamicProperties[get_called_class()][$name]);
    }

    /**
     * Check if a dynamic method exists.
     *
     * @param string $name
     *   The property name.
     * @return bool
     *   True if the property exists, false otherwise.
     */
    public static function hasDynamicMethod($name)
    {
        return isset(static::$dynamicMethods[get_called_class()][$name]);
    }

    /**
     * Get a dynamic property.
     *
     * @param $name
     *   The property name.
     * @return mixed|null
     *   The property value if it exists, null otherwise.
     */
    public static function getDynamicProperty($name)
    {
        if (static::hasDynamicProperty($name)) {
            return static::$dynamicProperties[get_called_class()][$name];
        }

        return null;
    }

    /**
     * Get a dynamic method.
     *
     * @param $name
     *   The method name.
     * @return array|null
     *   The method data if it exists, null otherwise.
     */
    public static function getDynamicMethod($name)
    {
        return (static::hasDynamicMethod($name)) ?
            static::$dynamicMethods[get_called_class()][$name] : null;
    }

    /**
     * Clear dynamic properties.
     */
    public static function clearDynamicProperties()
    {
        static::$dynamicProperties[get_called_class()] = array();
    }

    /**
     * Clear dynamic methods.
     */
    public static function clearDynamicMethods()
    {
        static::$dynamicMethods[get_called_class()] = array();
    }

    /**
     * Remove a dynamic property.
     *
     * @param string $name
     *   The property name.
     */
    public static function removeDynamicProperty($name)
    {
        unset(static::$dynamicProperties[get_called_class()][$name]);
    }

    /**
     * Remove a dynamic method.
     *
     * @param string $name
     *   The method name.
     */
    public static function removeDynamicMethod($name)
    {
        unset(static::$dynamicMethods[get_called_class()][$name]);
    }

    /**
     * Execute a closure.
     *
     * @param \Closure $func
     *   The closure.
     * @param array $parameters
     *   The closure's parameters.
     * @param bool $memoize
     *   The memoize parameter.
     *
     * @return mixed|null
     *   The return of the closure.
     *
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function doDynamicRequest(\Closure $func, array $parameters = [], $memoize = false)
    {
        if (!class_exists('\drupol\Memoize\Memoize') || false === $memoize) {
            $memoize = false;
        }

        if (true === $memoize) {
            return $this->memoize($func, $parameters);
        }

        return call_user_func_array($func->bindTo($this, get_called_class()), $parameters);
    }

    /**
     * Extend the dynamic object.
     *
     * @param mixed $extensions
     *   A file that returns a callable or a callable.
     *
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function extend($extensions = null)
    {
        if (is_string($extensions) && file_exists($extensions)) {
            $extensions = include $extensions;
        }

        if (is_callable($extensions)) {
            call_user_func($extensions, $this);

            return $this;
        }

        if (is_null($extensions)) {
            return $this;
        }

        throw new \InvalidArgumentException(
            'DynamicObjectsTrait::extend() requires a callable or a file that returns one.'
        );
    }

    /**
     * @param $method
     * @param array $parameters
     *
     * @return mixed
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function __call($method, array $parameters = array())
    {
        if ($data = static::getDynamicMethod($method)) {
            return $this->doDynamicRequest($data['factory'], $parameters, $data['memoize']);
        }

        throw new \BadMethodCallException(sprintf('Undefined method: %s().', $method));
    }

    /**
     * @param $method
     * @param array $parameters
     *
     * @return mixed
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public static function __callStatic($method, array $parameters = array())
    {
        $instance = new static();

        if ($data = static::getDynamicMethod($method)) {
            if (true == $data['static']) {
                return $instance->doDynamicRequest($data['factory'], $parameters, $data['memoize']);
            }
        }

        throw new \BadMethodCallException(sprintf('Undefined static method: %s().', $method));
    }

    /**
     * {inheritdoc}
     */
    public function __get($property)
    {
        if ($data = static::getDynamicProperty($property)) {
            $return = $data['factory'];

            if (is_callable($data['factory'])) {
                $return = $this->doDynamicRequest($data['factory'], [], $data['memoize']);
            }

            return $return;
        }

        throw new \DomainException(sprintf('Undefined property: %s.', $property));
    }

    /**
     * {inheritdoc}
     */
    public function __set($property, $value)
    {
        if (static::hasDynamicProperty($property)) {
            static::addDynamicProperty($property, $value);
        }
    }
}