MagicAccessors::__call() - Code Metrics - Inspection of "MagicAccessors: empty ::__construct removed [Close..." - Kdyby/Doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#255)

unknown

created 2016-03-13 17:24 UTC

MagicAccessors::__call() D

↳ Parent: MagicAccessors

Complexity

Conditions	40
Paths	59

Size

Total Lines	126
Code Lines	70

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	126
rs	4.1818
cc	40
eloc	70
nc	59
nop	2

How to fix Long Method Complexity

<?php

/**
 * This file is part of the Kdyby (http://www.kdyby.org)
 * Copyright (c) 2008 Filip Procházka ([email protected])
 * For the full copyright and license information, please view the file license.txt that was distributed with this source code.
 */

namespace Kdyby\Doctrine\Entities;

use Doctrine;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Kdyby;
use Kdyby\Doctrine\Collections\ReadOnlyCollectionWrapper;
use Kdyby\Doctrine\MemberAccessException;
use Kdyby\Doctrine\UnexpectedValueException;
use Nette;
use Nette\Utils\Callback;
use Nette\Utils\ObjectMixin;



/**
 * @author Filip Procházka <[email protected]>
 */
trait MagicAccessors
{

	/**
	 * @var array
	 */
	private static $__properties = [];

	/**
	 * @var array
	 */
	private static $__methods = [];



	/**
	 * @param string $property property name
	 * @param array $args
	 * @return Collection|array
	 */
	protected function convertCollection($property, array $args = NULL)

	{
		return new ReadOnlyCollectionWrapper($this->$property);
	}



	/**
	 * Utility method, that can be replaced with `::class` since php 5.5
	 * @return string
	 */
	public static function getClassName()
	{
		return get_called_class();
	}



	/**
	 * Access to reflection.
	 *
	 * @return Nette\Reflection\ClassType|\ReflectionClass
	 */
	public static function getReflection()
	{
		$class = class_exists('Nette\Reflection\ClassType') ? 'Nette\Reflection\ClassType' : 'ReflectionClass';
		return new $class(get_called_class());
	}



	/**
	 * Allows the user to access through magic methods to protected and public properties.
	 * There are get<name>() and set<name>($value) methods for every protected or public property,
	 * and for protected or public collections there are add<name>($entity), remove<name>($entity) and has<name>($entity).
	 * When you'll try to call setter on collection, or collection manipulator on generic value, it will throw.
	 * Getters on collections will return all it's items.
	 *
	 * @param string $name method name
	 * @param array $args arguments
	 *
	 * @throws \Kdyby\Doctrine\UnexpectedValueException
	 * @throws \Kdyby\Doctrine\MemberAccessException
	 * @return mixed
	 */
	public function __call($name, $args)
	{
		if (strlen($name) > 3) {
			$properties = $this->listObjectProperties();

			$op = substr($name, 0, 3);
			$prop = strtolower($name[3]) . substr($name, 4);
			if ($op === 'set' && isset($properties[$prop])) {
				if ($this->$prop instanceof Collection) {
					throw UnexpectedValueException::collectionCannotBeReplaced($this, $prop);
				}

				$this->$prop = $args[0];

				return $this;

			} elseif ($op === 'get' && isset($properties[$prop])) {
				if ($this->$prop instanceof Collection) {
					return $this->convertCollection($prop, $args);

				} else {
					return $this->$prop;
				}

			} else { // collections
				if ($op === 'add') {
					if (isset($properties[$prop . 's'])) {
						if (!$this->{$prop . 's'} instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop . 's');
						}

						$this->{$prop . 's'}->add($args[0]);

						return $this;

					} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
						if (!$this->$prop instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop);
						}

						$this->$prop->add($args[0]);

						return $this;

					} elseif (isset($properties[$prop])) {
						throw UnexpectedValueException::notACollection($this, $prop);
					}

				} elseif ($op === 'has') {
					if (isset($properties[$prop . 's'])) {
						if (!$this->{$prop . 's'} instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop . 's');
						}

						return $this->{$prop . 's'}->contains($args[0]);

					} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
						if (!$this->$prop instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop);
						}

						return $this->$prop->contains($args[0]);

					} elseif (isset($properties[$prop])) {
						throw UnexpectedValueException::notACollection($this, $prop);
					}

				} elseif (strlen($name) > 6 && ($op = substr($name, 0, 6)) === 'remove') {
					$prop = strtolower($name[6]) . substr($name, 7);

					if (isset($properties[$prop . 's'])) {
						if (!$this->{$prop . 's'} instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop . 's');
						}

						$this->{$prop . 's'}->removeElement($args[0]);

						return $this;

					} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
						if (!$this->$prop instanceof Collection) {
							throw UnexpectedValueException::notACollection($this, $prop);
						}

						$this->$prop->removeElement($args[0]);

						return $this;

					} elseif (isset($properties[$prop])) {
						throw UnexpectedValueException::notACollection($this, $prop);
					}
				}
			}
		}

		if ($name === '') {
			throw MemberAccessException::callWithoutName($this);
		}
		$class = get_class($this);

		// event functionality
		if (preg_match('#^on[A-Z]#', $name) && property_exists($class, $name)) {
			$rp = new \ReflectionProperty($this, $name);
			if ($rp->isPublic() && !$rp->isStatic()) {
				if (is_array($list = $this->$name) || $list instanceof \Traversable) {
					foreach ($list as $handler) {
						Callback::invokeArgs($handler, $args);
					}
				} elseif ($list !== NULL) {
					throw UnexpectedValueException::invalidEventValue($list, $this, $name);
				}

				return NULL;
			}
		}

		// extension methods
		if ($cb = static::extensionMethod($name)) {
			/** @var \Nette\Callback $cb */
			array_unshift($args, $this);

			return call_user_func_array($cb, $args);
		}

		throw MemberAccessException::undefinedMethodCall($this, $name);
	}



	/**
	 * Call to undefined static method.
	 *
	 * @param  string  method name (in lower case!)
	 * @param  array   arguments
	 * @return mixed
	 * @throws MemberAccessException
	 */
	public static function __callStatic($name, $args)
	{
		return ObjectMixin::callStatic(get_called_class(), $name, $args);
	}



	/**
	 * Adding method to class.
	 *
	 * @param  string  method name
	 * @param  callable
	 * @return mixed
	 */
	public static function extensionMethod($name, $callback = NULL)
	{
		if (strpos($name, '::') === FALSE) {
			$class = get_called_class();
		} else {
			list($class, $name) = explode('::', $name);
			$class = (new \ReflectionClass($class))->getName();
		}
		if ($callback === NULL) {
			return ObjectMixin::getExtensionMethod($class, $name);
		} else {
			ObjectMixin::setExtensionMethod($class, $name, $callback);
		}
	}



	/**
	 * Returns property value. Do not call directly.
	 *
	 * @param string $name property name
	 *
	 * @throws MemberAccessException if the property is not defined.
	 * @return mixed property value
	 */
	public function &__get($name)
	{
		if ($name === '') {
			throw MemberAccessException::propertyReadWithoutName($this);
		}

		// property getter support
		$originalName = $name;
		$name[0] = $name[0] & "\xDF"; // case-sensitive checking, capitalize first character
		$m = 'get' . $name;

		$methods = $this->listObjectMethods();
		if (isset($methods[$m])) {
			// ampersands:
			// - uses &__get() because declaration should be forward compatible (e.g. with Nette\Utils\Html)
			// - doesn't call &$_this->$m because user could bypass property setter by: $x = & $obj->property; $x = 'new value';
			$val = $this->$m();

			return $val;
		}

		$m = 'is' . $name;
		if (isset($methods[$m])) {
			$val = $this->$m();

			return $val;
		}

		// protected attribute support
		$properties = $this->listObjectProperties();
		if (isset($properties[$name = $originalName])) {
			if ($this->$name instanceof Collection) {
				$coll = $this->convertCollection($name);

				return $coll;

			} else {
				$val = $this->$name;

				return $val;
			}
		}

		$type = isset($methods['set' . $name]) ? 'a write-only' : 'an undeclared';
		throw MemberAccessException::propertyNotReadable($type, $this, $originalName);
	}



	/**
	 * Sets value of a property. Do not call directly.
	 *
	 * @param string $name property name
	 * @param mixed $value property value
	 *
	 * @throws UnexpectedValueException
	 * @throws MemberAccessException if the property is not defined or is read-only
	 */
	public function __set($name, $value)
	{
		if ($name === '') {
			throw MemberAccessException::propertyWriteWithoutName($this);
		}

		// property setter support
		$originalName = $name;
		$name[0] = $name[0] & "\xDF"; // case-sensitive checking, capitalize first character

		$methods = $this->listObjectMethods();
		$m = 'set' . $name;
		if (isset($methods[$m])) {
			$this->$m($value);

			return;
		}

		// protected attribute support
		$properties = $this->listObjectProperties();
		if (isset($properties[$name = $originalName])) {
			if ($this->$name instanceof Collection) {
				throw UnexpectedValueException::collectionCannotBeReplaced($this, $name);
			}

			$this->$name = $value;

			return;
		}

		$type = isset($methods['get' . $name]) || isset($methods['is' . $name]) ? 'a read-only' : 'an undeclared';
		throw MemberAccessException::propertyNotWritable($type, $this, $originalName);
	}



	/**
	 * Is property defined?
	 *
	 * @param string $name property name
	 *
	 * @return bool
	 */
	public function __isset($name)
	{
		$properties = $this->listObjectProperties();
		if (isset($properties[$name])) {
			return TRUE;
		}

		if ($name === '') {
			return FALSE;
		}

		$methods = $this->listObjectMethods();
		$name[0] = $name[0] & "\xDF";

		return isset($methods['get' . $name]) || isset($methods['is' . $name]);
	}



	/**
	 * Access to undeclared property.
	 *
	 * @param  string  property name
	 * @return void
	 * @throws MemberAccessException
	 */
	public function __unset($name)
	{
		ObjectMixin::remove($this, $name);
	}



	/**
	 * Should return only public or protected properties of class
	 *
	 * @return array
	 */
	private function listObjectProperties()
	{
		$class = get_class($this);
		if (!isset(self::$__properties[$class])) {
			$refl = new \ReflectionClass($class);
			$properties = array_map(function (\ReflectionProperty $property) {
				return $property->getName();
			}, $refl->getProperties(\ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED));

			self::$__properties[$class] = array_flip($properties);
		}

		return self::$__properties[$class];
	}



	/**
	 * Should return all public methods of class
	 *
	 * @return array
	 */
	private function listObjectMethods()
	{
		$class = get_class($this);
		if (!isset(self::$__methods[$class])) {
			$refl = new \ReflectionClass($class);
			$methods = array_map(function (\ReflectionMethod $method) {
				return $method->getName();
			}, $refl->getMethods(\ReflectionMethod::IS_PUBLIC));

			self::$__methods[$class] = array_flip($methods);
		}

		return self::$__methods[$class];
	}

}


1			<?php
2
3			/**
4			* This file is part of the Kdyby (http://www.kdyby.org)
5			* Copyright (c) 2008 Filip Procházka ([email protected])
6			* For the full copyright and license information, please view the file license.txt that was distributed with this source code.
7			*/
8
9			namespace Kdyby\Doctrine\Entities;
10
11			use Doctrine;
12			use Doctrine\Common\Collections\Collection;
13			use Doctrine\ORM\Mapping as ORM;
14			use Kdyby;
15			use Kdyby\Doctrine\Collections\ReadOnlyCollectionWrapper;
16			use Kdyby\Doctrine\MemberAccessException;
17			use Kdyby\Doctrine\UnexpectedValueException;
18			use Nette;
19			use Nette\Utils\Callback;
20			use Nette\Utils\ObjectMixin;
21
22
23
24			/**
25			* @author Filip Procházka <[email protected]>
26			*/
27			trait MagicAccessors
28			{
29
30			/**
31			* @var array
32			*/
33			private static $__properties = [];
34
35			/**
36			* @var array
37			*/
38			private static $__methods = [];
39
40
41
42			/**
43			* @param string $property property name
44			* @param array $args
45			* @return Collection\|array
46			*/
47			protected function convertCollection($property, array $args = NULL)
			0 ignored issues – show Unused Code introduced 2015-11-23 18:47 UTC by Report Bug Copy Issue Report The parameter `$args` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
48			{
49			return new ReadOnlyCollectionWrapper($this->$property);
50			}
51
52
53
54			/**
55			* Utility method, that can be replaced with `::class` since php 5.5
56			* @return string
57			*/
58			public static function getClassName()
59			{
60			return get_called_class();
61			}
62
63
64
65			/**
66			* Access to reflection.
67			*
68			* @return Nette\Reflection\ClassType\|\ReflectionClass
69			*/
70			public static function getReflection()
71			{
72			$class = class_exists('Nette\Reflection\ClassType') ? 'Nette\Reflection\ClassType' : 'ReflectionClass';
73			return new $class(get_called_class());
74			}
75
76
77
78			/**
79			* Allows the user to access through magic methods to protected and public properties.
80			* There are get<name>() and set<name>($value) methods for every protected or public property,
81			* and for protected or public collections there are add<name>($entity), remove<name>($entity) and has<name>($entity).
82			* When you'll try to call setter on collection, or collection manipulator on generic value, it will throw.
83			* Getters on collections will return all it's items.
84			*
85			* @param string $name method name
86			* @param array $args arguments
87			*
88			* @throws \Kdyby\Doctrine\UnexpectedValueException
89			* @throws \Kdyby\Doctrine\MemberAccessException
90			* @return mixed
91			*/
92			public function __call($name, $args)
93			{
94			if (strlen($name) > 3) {
95			$properties = $this->listObjectProperties();
96
97			$op = substr($name, 0, 3);
98			$prop = strtolower($name[3]) . substr($name, 4);
99			if ($op === 'set' && isset($properties[$prop])) {
100			if ($this->$prop instanceof Collection) {
101			throw UnexpectedValueException::collectionCannotBeReplaced($this, $prop);
102			}
103
104			$this->$prop = $args[0];
105
106			return $this;
107
108			} elseif ($op === 'get' && isset($properties[$prop])) {
109			if ($this->$prop instanceof Collection) {
110			return $this->convertCollection($prop, $args);
111
112			} else {
113			return $this->$prop;
114			}
115
116			} else { // collections
117			if ($op === 'add') {
118			if (isset($properties[$prop . 's'])) {
119			if (!$this->{$prop . 's'} instanceof Collection) {
120			throw UnexpectedValueException::notACollection($this, $prop . 's');
121			}
122
123			$this->{$prop . 's'}->add($args[0]);
124
125			return $this;
126
127			} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
128			if (!$this->$prop instanceof Collection) {
129			throw UnexpectedValueException::notACollection($this, $prop);
130			}
131
132			$this->$prop->add($args[0]);
133
134			return $this;
135
136			} elseif (isset($properties[$prop])) {
137			throw UnexpectedValueException::notACollection($this, $prop);
138			}
139
140			} elseif ($op === 'has') {
141			if (isset($properties[$prop . 's'])) {
142			if (!$this->{$prop . 's'} instanceof Collection) {
143			throw UnexpectedValueException::notACollection($this, $prop . 's');
144			}
145
146			return $this->{$prop . 's'}->contains($args[0]);
147
148			} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
149			if (!$this->$prop instanceof Collection) {
150			throw UnexpectedValueException::notACollection($this, $prop);
151			}
152
153			return $this->$prop->contains($args[0]);
154
155			} elseif (isset($properties[$prop])) {
156			throw UnexpectedValueException::notACollection($this, $prop);
157			}
158
159			} elseif (strlen($name) > 6 && ($op = substr($name, 0, 6)) === 'remove') {
160			$prop = strtolower($name[6]) . substr($name, 7);
161
162			if (isset($properties[$prop . 's'])) {
163			if (!$this->{$prop . 's'} instanceof Collection) {
164			throw UnexpectedValueException::notACollection($this, $prop . 's');
165			}
166
167			$this->{$prop . 's'}->removeElement($args[0]);
168
169			return $this;
170
171			} elseif (substr($prop, -1) === 'y' && isset($properties[$prop = substr($prop, 0, -1) . 'ies'])) {
172			if (!$this->$prop instanceof Collection) {
173			throw UnexpectedValueException::notACollection($this, $prop);
174			}
175
176			$this->$prop->removeElement($args[0]);
177
178			return $this;
179
180			} elseif (isset($properties[$prop])) {
181			throw UnexpectedValueException::notACollection($this, $prop);
182			}
183			}
184			}
185			}
186
187			if ($name === '') {
188			throw MemberAccessException::callWithoutName($this);
189			}
190			$class = get_class($this);
191
192			// event functionality
193			if (preg_match('#^on[A-Z]#', $name) && property_exists($class, $name)) {
194			$rp = new \ReflectionProperty($this, $name);
195			if ($rp->isPublic() && !$rp->isStatic()) {
196			if (is_array($list = $this->$name) \|\| $list instanceof \Traversable) {
197			foreach ($list as $handler) {
198			Callback::invokeArgs($handler, $args);
199			}
200			} elseif ($list !== NULL) {
201			throw UnexpectedValueException::invalidEventValue($list, $this, $name);
202			}
203
204			return NULL;
205			}
206			}
207
208			// extension methods
209			if ($cb = static::extensionMethod($name)) {
210			/** @var \Nette\Callback $cb */
211			array_unshift($args, $this);
212
213			return call_user_func_array($cb, $args);
214			}
215
216			throw MemberAccessException::undefinedMethodCall($this, $name);
217			}
218
219
220
221			/**
222			* Call to undefined static method.
223			*
224			* @param string method name (in lower case!)
225			* @param array arguments
226			* @return mixed
227			* @throws MemberAccessException
228			*/
229			public static function __callStatic($name, $args)
230			{
231			return ObjectMixin::callStatic(get_called_class(), $name, $args);
232			}
233
234
235
236			/**
237			* Adding method to class.
238			*
239			* @param string method name
240			* @param callable
241			* @return mixed
242			*/
243			public static function extensionMethod($name, $callback = NULL)
244			{
245			if (strpos($name, '::') === FALSE) {
246			$class = get_called_class();
247			} else {
248			list($class, $name) = explode('::', $name);
249			$class = (new \ReflectionClass($class))->getName();
250			}
251			if ($callback === NULL) {
252			return ObjectMixin::getExtensionMethod($class, $name);
253			} else {
254			ObjectMixin::setExtensionMethod($class, $name, $callback);
255			}
256			}
257
258
259
260			/**
261			* Returns property value. Do not call directly.
262			*
263			* @param string $name property name
264			*
265			* @throws MemberAccessException if the property is not defined.
266			* @return mixed property value
267			*/
268			public function &__get($name)
269			{
270			if ($name === '') {
271			throw MemberAccessException::propertyReadWithoutName($this);
272			}
273
274			// property getter support
275			$originalName = $name;
276			$name[0] = $name[0] & "\xDF"; // case-sensitive checking, capitalize first character
277			$m = 'get' . $name;
278
279			$methods = $this->listObjectMethods();
280			if (isset($methods[$m])) {
281			// ampersands:
282			// - uses &__get() because declaration should be forward compatible (e.g. with Nette\Utils\Html)
283			// - doesn't call &$_this->$m because user could bypass property setter by: $x = & $obj->property; $x = 'new value';
284			$val = $this->$m();
285
286			return $val;
287			}
288
289			$m = 'is' . $name;
290			if (isset($methods[$m])) {
291			$val = $this->$m();
292
293			return $val;
294			}
295
296			// protected attribute support
297			$properties = $this->listObjectProperties();
298			if (isset($properties[$name = $originalName])) {
299			if ($this->$name instanceof Collection) {
300			$coll = $this->convertCollection($name);
301
302			return $coll;
303
304			} else {
305			$val = $this->$name;
306
307			return $val;
308			}
309			}
310
311			$type = isset($methods['set' . $name]) ? 'a write-only' : 'an undeclared';
312			throw MemberAccessException::propertyNotReadable($type, $this, $originalName);
313			}
314
315
316
317			/**
318			* Sets value of a property. Do not call directly.
319			*
320			* @param string $name property name
321			* @param mixed $value property value
322			*
323			* @throws UnexpectedValueException
324			* @throws MemberAccessException if the property is not defined or is read-only
325			*/
326			public function __set($name, $value)
327			{
328			if ($name === '') {
329			throw MemberAccessException::propertyWriteWithoutName($this);
330			}
331
332			// property setter support
333			$originalName = $name;
334			$name[0] = $name[0] & "\xDF"; // case-sensitive checking, capitalize first character
335
336			$methods = $this->listObjectMethods();
337			$m = 'set' . $name;
338			if (isset($methods[$m])) {
339			$this->$m($value);
340
341			return;
342			}
343
344			// protected attribute support
345			$properties = $this->listObjectProperties();
346			if (isset($properties[$name = $originalName])) {
347			if ($this->$name instanceof Collection) {
348			throw UnexpectedValueException::collectionCannotBeReplaced($this, $name);
349			}
350
351			$this->$name = $value;
352
353			return;
354			}
355
356			$type = isset($methods['get' . $name]) \|\| isset($methods['is' . $name]) ? 'a read-only' : 'an undeclared';
357			throw MemberAccessException::propertyNotWritable($type, $this, $originalName);
358			}
359
360
361
362			/**
363			* Is property defined?
364			*
365			* @param string $name property name
366			*
367			* @return bool
368			*/
369			public function __isset($name)
370			{
371			$properties = $this->listObjectProperties();
372			if (isset($properties[$name])) {
373			return TRUE;
374			}
375
376			if ($name === '') {
377			return FALSE;
378			}
379
380			$methods = $this->listObjectMethods();
381			$name[0] = $name[0] & "\xDF";
382
383			return isset($methods['get' . $name]) \|\| isset($methods['is' . $name]);
384			}
385
386
387
388			/**
389			* Access to undeclared property.
390			*
391			* @param string property name
392			* @return void
393			* @throws MemberAccessException
394			*/
395			public function __unset($name)
396			{
397			ObjectMixin::remove($this, $name);
398			}
399
400
401
402			/**
403			* Should return only public or protected properties of class
404			*
405			* @return array
406			*/
407			private function listObjectProperties()
408			{
409			$class = get_class($this);
410			if (!isset(self::$__properties[$class])) {
411			$refl = new \ReflectionClass($class);
412			$properties = array_map(function (\ReflectionProperty $property) {
413			return $property->getName();
414			}, $refl->getProperties(\ReflectionProperty::IS_PUBLIC \| \ReflectionProperty::IS_PROTECTED));
415
416			self::$__properties[$class] = array_flip($properties);
417			}
418
419			return self::$__properties[$class];
420			}
421
422
423
424			/**
425			* Should return all public methods of class
426			*
427			* @return array
428			*/
429			private function listObjectMethods()
430			{
431			$class = get_class($this);
432			if (!isset(self::$__methods[$class])) {
433			$refl = new \ReflectionClass($class);
434			$methods = array_map(function (\ReflectionMethod $method) {
435			return $method->getName();
436			}, $refl->getMethods(\ReflectionMethod::IS_PUBLIC));
437
438			self::$__methods[$class] = array_flip($methods);
439			}
440
441			return self::$__methods[$class];
442			}
443
444			}
445

Kdyby / Doctrine

Pull Request — master (#255)

MagicAccessors::__call() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like