DynamicObjectsTrait::hasDynamicProperty() - Code Metrics - Inspection of "Small trick to have 100% tested." - drupol/dynamicobjects - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65a611...b28387 )

by Pol

created 2017-09-19 14:22 UTC

DynamicObjectsTrait::hasDynamicProperty() A

↳ Parent: DynamicObjectsTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?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 $name
     *   The property name.
     * @param mixed $value
     *   The property value.
     * @param bool $memoize
     *   Memoize parameter.
     */
    public static function addDynamicProperty($name, $value, $memoize = false)
    {
        static::$dynamicProperties[get_called_class()][$name] = [
          'name' => $name,
          'factory' => $value,
          'memoize' => $memoize,
        ];
    }

    /**
     * Add a dynamic method.
     *
     * @param $name
     *   The method name.
     * @param \Closure $func
     *   The method.
     * @param bool $memoize
     *   Memoize parameter.
     */
    public static function addDynamicMethod($name, \Closure $func, $memoize = false)
    {
        static::$dynamicMethods[get_called_class()][$name] = [
          'name' => $name,
          'factory' => $func,
          'memoize' => $memoize,
        ];
    }

    /**
     * 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 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]);
    }

    /**
     * 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, $parameters);
    }

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

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

    /**
     * {inheritdoc}
     */
    public function __get($property)
    {
        if (static::hasDynamicProperty($property)) {
            $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);
        }
    }
}


1		<?php
2
3		namespace drupol\DynamicObjects;
4
5		use drupol\Memoize\MemoizeTrait;
6
7		/**
8		* Trait DynamicObjectsTrait.
9		*
10		* @package drupol\DynamicObjects
11		*/
12		trait DynamicObjectsTrait
13		{
14		use MemoizeTrait;
15
16		/**
17		* @var array
18		*/
19		protected static $dynamicMethods = array();
20
21		/**
22		* @var array
23		*/
24		protected static $dynamicProperties = array();
25
26		/**
27		* Add a dynamic property.
28		*
29		* @param string $name
30		* The property name.
31		* @param mixed $value
32		* The property value.
33		* @param bool $memoize
34		* Memoize parameter.
35		*/
36	5	public static function addDynamicProperty($name, $value, $memoize = false)
37		{
38	5	static::$dynamicProperties[get_called_class()][$name] = [
39	5	'name' => $name,
40	5	'factory' => $value,
41	5	'memoize' => $memoize,
42		];
43	5	}
44
45		/**
46		* Add a dynamic method.
47		*
48		* @param $name
49		* The method name.
50		* @param \Closure $func
51		* The method.
52		* @param bool $memoize
53		* Memoize parameter.
54		*/
55	4	public static function addDynamicMethod($name, \Closure $func, $memoize = false)
56		{
57	4	static::$dynamicMethods[get_called_class()][$name] = [
58	4	'name' => $name,
59	4	'factory' => $func,
60	4	'memoize' => $memoize,
61		];
62	4	}
63
64		/**
65		* Check if a dynamic property exists.
66		*
67		* @param string $name
68		* The property name.
69		* @return bool
70		* True if the property exists, false otherwise.
71		*/
72	8	public static function hasDynamicProperty($name)
73		{
74	8	return isset(static::$dynamicProperties[get_called_class()][$name]);
75		}
76
77		/**
78		* Check if a dynamic method exists.
79		*
80		* @param string $name
81		* The property name.
82		* @return bool
83		* True if the property exists, false otherwise.
84		*/
85	6	public static function hasDynamicMethod($name)
86		{
87	6	return isset(static::$dynamicMethods[get_called_class()][$name]);
88		}
89
90		/**
91		* Get a dynamic property.
92		*
93		* @param $name
94		* The property name.
95		* @return mixed\|null
96		* The property value if it exists, null otherwise.
97		*/
98	4	public static function getDynamicProperty($name)
99		{
100	4	if (static::hasDynamicProperty($name)) {
101	3	return static::$dynamicProperties[get_called_class()][$name];
102		}
103
104	1	return null;
105		}
106
107		/**
108		* Get a dynamic method.
109		*
110		* @param $name
111		* The method name.
112		* @return mixed\|null
113		* The method if it exists, null otherwise.
114		*/
115	2	public static function getDynamicMethod($name)
116		{
117	2	return ( static::hasDynamicMethod($name) ) ?
118	2	static::$dynamicMethods[get_called_class()][$name] : null;
119		}
120
121		/**
122		* Clear dynamic properties.
123		*/
124	1	public static function clearDynamicProperties()
125		{
126	1	static::$dynamicProperties[get_called_class()] = array();
127	1	}
128
129		/**
130		* Clear dynamic methods.
131		*/
132	1	public static function clearDynamicMethods()
133		{
134	1	static::$dynamicMethods[get_called_class()] = array();
135	1	}
136
137		/**
138		* Remove a dynamic property.
139		*
140		* @param string $name
141		* The property name.
142		*/
143	1	public static function removeDynamicProperty($name)
144		{
145	1	unset(static::$dynamicProperties[get_called_class()][$name]);
146	1	}
147
148		/**
149		* Remove a dynamic method.
150		*
151		* @param string $name
152		* The method name.
153		*/
154	1	public static function removeDynamicMethod($name)
155		{
156	1	unset(static::$dynamicMethods[get_called_class()][$name]);
157	1	}
158
159		/**
160		* Execute a closure.
161		*
162		* @param \Closure $func
163		* The closure.
164		* @param array $parameters
165		* The closure's parameters.
166		* @param bool $memoize
167		* The memoize parameter.
168		*
169		* @return mixed\|null
170		* The return of the closure.
171		*
172		* @throws \Psr\SimpleCache\InvalidArgumentException
173		*/
174	4	public function doDynamicRequest(\Closure $func, array $parameters = [], $memoize = false)
175		{
176	4	if (!class_exists('\drupol\Memoize\Memoize') \|\| false === $memoize) {
177	4	$memoize = false;
178		}
179
180	4	if (true === $memoize) {
181	2	return $this->memoize($func, $parameters);
182		}
183
184	4	return call_user_func_array($func, $parameters);
185		}
186
187		/**
188		* @param $method
189		* @param array $parameters
190		*
191		* @return mixed
192		* @throws \Psr\SimpleCache\InvalidArgumentException
193		*/
194	3	public function __call($method, array $parameters = array())
195		{
196	3	if (static::hasDynamicMethod($method)) {
197	2	$data = static::getDynamicMethod($method);
198	2	return $this->doDynamicRequest($data['factory'], $parameters, $data['memoize']);
199		}
200
201	1	throw new \BadMethodCallException(sprintf('Undefined method: %s().', $method));
202		}
203
204		/**
205		* {inheritdoc}
206		*/
207	4	public function __get($property)
208		{
209	4	if (static::hasDynamicProperty($property)) {
210	3	$data = static::getDynamicProperty($property);
211
212	3	$return = $data['factory'];
213	3	if (is_callable($data['factory'])) {
214	2	$return = $this->doDynamicRequest($data['factory'], [], $data['memoize']);
215		}
216
217	3	return $return;
218		}
219
220	1	throw new \DomainException(sprintf('Undefined property: %s().', $property));
221		}
222
223		/**
224		* {inheritdoc}
225		*/
226	3	public function __set($property, $value)
227		{
228	3	if (static::hasDynamicProperty($property)) {
229	1	static::addDynamicProperty($property, $value);
230		}
231	3	}
232		}
233

drupol / dynamicobjects

Push — master ( 65a611...b28387 )

DynamicObjectsTrait::hasDynamicProperty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like