MagicMethodsTrait::handlePropertyMagicMethod() - Code Metrics - Inspection of "[FEATURE] Allow UpperCamelCase properties in `Magi..." - romm/configuration_object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ac3e84...79ab0f )

unknown

created 2016-09-07 16:04 UTC

MagicMethodsTrait::handlePropertyMagicMethod() A

↳ Parent: Project

Complexity

Conditions	4
Paths	4

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	19
rs	9.2
cc	4
eloc	13
nc	4
nop	3

<?php
/*
 * 2016 Romain CANON <[email protected]>
 *
 * This file is part of the TYPO3 Configuration Object project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\ConfigurationObject\Traits\ConfigurationObject;

use Romm\ConfigurationObject\Exceptions\MethodNotFoundException;
use Romm\ConfigurationObject\Exceptions\PropertyNotAccessibleException;

/**
 * This trait will implement magic setters and getters for accessible properties
 * of the class.
 *
 * /!\ This class uses the method `__call()`, if you need to override this
 * function in your own class, you must call the function `handleMagicMethods()`
 * and handle the result correctly. This is the only way to keep this trait
 * features running correctly.
 */
trait MagicMethodsTrait
{

    /**
     * Contains the list of the accessible properties for the instances of this
     * class.
     *
     * @var array
     */
    private static $_accessibleProperties = [];

    /**
     * See class description.
     *
     * @param string $name      Name of the called function.
     * @param array  $arguments Arguments passed to the function
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        return $this->handleMagicMethods($name, $arguments);
    }

    /**
     * See class description.
     *
     * @param string $name      Name of the called function.
     * @param array  $arguments Arguments passed to the function.
     * @return mixed
     * @throws MethodNotFoundException
     */
    public function handleMagicMethods($name, array $arguments)
    {
        $flag = false;
        $result = null;

        if (in_array($type = substr($name, 0, 3), ['set', 'get'])) {
            /*
             * We will first try to access the property written with
             * lowerCamelCase, which is the convention for many people. If this
             * property is not found, we try the real name of the property given
             * in the magic method.
             */
            $propertyLowerCase = lcfirst(substr($name, 3));
            $property = substr($name, 3);

            foreach ([$propertyLowerCase, $property] as $prop) {
                try {
                    $result = $this->handlePropertyMagicMethod($prop, $type, $arguments);
                    $flag = true;
                    break;
                } catch (PropertyNotAccessibleException $e) {
                    continue;
                }
            }
        }

        if (false === $flag) {
            throw new MethodNotFoundException(
                'The method "' . $name . '" does not exist in the class "' . get_class($this) . '".',
                1471043854
            );
        }

        return $result;
    }

    /**
     * Will try to set/get the wanted property.
     *
     * @param string $property Name of the property to be set/get.
     * @param string $type     Must be `set` or `get`.
     * @param array  $arguments
     * @return mixed
     * @throws PropertyNotAccessibleException
     */
    protected function handlePropertyMagicMethod($property, $type, array $arguments)
    {
        if ($this->isPropertyAccessible($property)) {
            switch ($type) {
                case 'set':
                    $this->{$property} = current($arguments);
                    return null;
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                case 'get':
                    return $this->{$property};
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            }
        }

        throw new PropertyNotAccessibleException(
            'The property "' . $property . '" is not accessible in the class "' . get_class($this) . '".',
            1473260999
        );
    }

    /**
     * Returns true if the given property name is accessible for the current
     * instance of this class.
     *
     * Note that the list of accessible properties for this class is stored in
     * cache to improve performances.
     *
     * @param string $propertyName
     * @return bool
     */
    private function isPropertyAccessible($propertyName)
    {
        if (false === isset(self::$_accessibleProperties[get_class($this)])) {
            self::$_accessibleProperties[get_class($this)] = [];

            $reflect = new \ReflectionObject($this);
            $properties = $reflect->getProperties(\ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED);

            foreach ($properties as $property) {
                self::$_accessibleProperties[get_class($this)][$property->getName()] = true;
            }
        }

        return (isset(self::$_accessibleProperties[get_class($this)][$propertyName]));
    }
}


1			<?php
2			/*
3			* 2016 Romain CANON <[email protected]>
4			*
5			* This file is part of the TYPO3 Configuration Object project.
6			* It is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU General Public License, either
8			* version 3 of the License, or any later version.
9			*
10			* For the full copyright and license information, see:
11			* http://www.gnu.org/licenses/gpl-3.0.html
12			*/
13
14			namespace Romm\ConfigurationObject\Traits\ConfigurationObject;
15
16			use Romm\ConfigurationObject\Exceptions\MethodNotFoundException;
17			use Romm\ConfigurationObject\Exceptions\PropertyNotAccessibleException;
18
19			/**
20			* This trait will implement magic setters and getters for accessible properties
21			* of the class.
22			*
23			* /!\ This class uses the method `__call()`, if you need to override this
24			* function in your own class, you must call the function `handleMagicMethods()`
25			* and handle the result correctly. This is the only way to keep this trait
26			* features running correctly.
27			*/
28			trait MagicMethodsTrait
29			{
30
31			/**
32			* Contains the list of the accessible properties for the instances of this
33			* class.
34			*
35			* @var array
36			*/
37			private static $_accessibleProperties = [];
38
39			/**
40			* See class description.
41			*
42			* @param string $name Name of the called function.
43			* @param array $arguments Arguments passed to the function
44			* @return mixed
45			*/
46			public function __call($name, $arguments)
47			{
48			return $this->handleMagicMethods($name, $arguments);
49			}
50
51			/**
52			* See class description.
53			*
54			* @param string $name Name of the called function.
55			* @param array $arguments Arguments passed to the function.
56			* @return mixed
57			* @throws MethodNotFoundException
58			*/
59			public function handleMagicMethods($name, array $arguments)
60			{
61			$flag = false;
62			$result = null;
63
64			if (in_array($type = substr($name, 0, 3), ['set', 'get'])) {
65			/*
66			* We will first try to access the property written with
67			* lowerCamelCase, which is the convention for many people. If this
68			* property is not found, we try the real name of the property given
69			* in the magic method.
70			*/
71			$propertyLowerCase = lcfirst(substr($name, 3));
72			$property = substr($name, 3);
73
74			foreach ([$propertyLowerCase, $property] as $prop) {
75			try {
76			$result = $this->handlePropertyMagicMethod($prop, $type, $arguments);
77			$flag = true;
78			break;
79			} catch (PropertyNotAccessibleException $e) {
80			continue;
81			}
82			}
83			}
84
85			if (false === $flag) {
86			throw new MethodNotFoundException(
87			'The method "' . $name . '" does not exist in the class "' . get_class($this) . '".',
88			1471043854
89			);
90			}
91
92			return $result;
93			}
94
95			/**
96			* Will try to set/get the wanted property.
97			*
98			* @param string $property Name of the property to be set/get.
99			* @param string $type Must be `set` or `get`.
100			* @param array $arguments
101			* @return mixed
102			* @throws PropertyNotAccessibleException
103			*/
104			protected function handlePropertyMagicMethod($property, $type, array $arguments)
105			{
106			if ($this->isPropertyAccessible($property)) {
107			switch ($type) {
108			case 'set':
109			$this->{$property} = current($arguments);
110			return null;
111			break;
			0 ignored issues – show Unused Code introduced 2016-09-07 16:06 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
112			case 'get':
113			return $this->{$property};
114			break;
			0 ignored issues – show Unused Code introduced 2016-09-07 16:06 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
115			}
116			}
117
118			throw new PropertyNotAccessibleException(
119			'The property "' . $property . '" is not accessible in the class "' . get_class($this) . '".',
120			1473260999
121			);
122			}
123
124			/**
125			* Returns true if the given property name is accessible for the current
126			* instance of this class.
127			*
128			* Note that the list of accessible properties for this class is stored in
129			* cache to improve performances.
130			*
131			* @param string $propertyName
132			* @return bool
133			*/
134			private function isPropertyAccessible($propertyName)
135			{
136			if (false === isset(self::$_accessibleProperties[get_class($this)])) {
137			self::$_accessibleProperties[get_class($this)] = [];
138
139			$reflect = new \ReflectionObject($this);
140			$properties = $reflect->getProperties(\ReflectionProperty::IS_PUBLIC \| \ReflectionProperty::IS_PROTECTED);
141
142			foreach ($properties as $property) {
143			self::$_accessibleProperties[get_class($this)][$property->getName()] = true;
144			}
145			}
146
147			return (isset(self::$_accessibleProperties[get_class($this)][$propertyName]));
148			}
149			}
150

romm / configuration_object

Push — master ( ac3e84...79ab0f )

MagicMethodsTrait::handlePropertyMagicMethod() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like