drupol\DynamicObjects\DynamicObjectsTrait

Complexity

Total Complexity

21

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

83.33%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	addDynamicProperty()	0	4	1
A	addDynamicMethod()	0	4	1
A	hasDynamicProperty()	0	4	1
A	hasDynamicMethod()	0	4	1
A	getDynamicProperty()	0	5	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	__call()	0	11	3
A	__set()	0	10	3
A	__get()	0	10	3

<?php

namespace drupol\DynamicObjects;

/**
 * Trait DynamicObjectsTrait.
 *
 * @package drupol\DynamicObjects
 */
trait DynamicObjectsTrait
{
    /**
     * @var array
     */
    protected static $dynamicMethods = array();

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

    /**
     * Add a dynamic property.
     *
     * @param string $name
     *   The property name.
     * @param mixed $value
     *   The property value.
     *
     */
    public static function addDynamicProperty($name, $value)
    {
        static::$dynamicProperties[get_called_class()][$name] = $value;
    }

    /**
     * Add a dynamic method.
     *
     * @param $name
     *   The method name.
     * @param \Closure $func
     *   The method.
     */
    public static function addDynamicMethod($name, \Closure $func)
    {
        static::$dynamicMethods[get_called_class()][$name] = $func;
    }

    /**
     * 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)
    {
        return ( static::hasDynamicProperty($name) ) ?
            static::$dynamicProperties[get_called_class()][$name] : null;
    }

    /**
     * Get a dynamic method.
     *
     * @param $name
     *   The method name.
     * @return mixed|null
     *   The method 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]);
    }

    /**
     * {inheritdoc}
     */
    public function __call($method, $parameters)
    {
        if (static::hasDynamicMethod($method)) {
            array_unshift($parameters, $this);
            return call_user_func_array(static::getDynamicMethod($method), $parameters);
        }

        if ((bool)class_parents($this) !== false) {
            return parent::__call($method, $parameters);
        }
    }

    /**
     * {inheritdoc}
     */
    public function __set($property, $value)

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

    {
        if (static::hasDynamicProperty($property)) {
            static::addDynamicProperty($property, $value);
        } elseif ((bool)class_parents($this) !== false) {
            return parent::__set($property, $value);
        } else {
            $this->{$property} = $value;
        }
    }

    /**
     * {inheritdoc}
     */
    public function __get($property)
    {
        if (static::hasDynamicProperty($property)) {
            return static::getDynamicProperty($property);
        } elseif ((bool)class_parents($this) !== false) {
            return parent::__get($property);
        } else {
            return $this->{$property};
        }
    }
}