ReflectionProperty::toPhpReflectionProperty() - Code Metrics - Inspection of "Typos fixes" - appserver-io/lang - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#25)

by ilyes

created 2017-11-27 20:28 UTC

ReflectionProperty::toPhpReflectionProperty() A

↳ Parent: ReflectionProperty

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
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

/**
 * AppserverIo\Lang\Reflection\ReflectionProperty
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Tim Wagner <[email protected]>
 * @copyright 2015 TechDivision GmbH <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/lang
 * @link      http://www.appserver.io
 */

namespace AppserverIo\Lang\Reflection;

use AppserverIo\Lang\Object;

/**
 * A wrapper instance for a reflection property.
 *
 * @author    Tim Wagner <[email protected]>
 * @copyright 2015 TechDivision GmbH <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/lang
 * @link      http://www.appserver.io
 */
class ReflectionProperty extends Object implements PropertyInterface, \Serializable
{

    /**
     * Default filter for loading reflection properties from a reflection class.
     *
     * @var integer
     */
    const ALL_MODIFIERS = -1;

    /**
     * The properties class name.
     *
     * @var string
     */
    protected $className;

    /**
     * The property name.
     *
     * @var string
     */
    protected $propertyName;

    /**
     * The method annotations.
     *
     * @var array
     */
    protected $annotations;

    /**
     * Array with annotations names we want to ignore when loaded.
     *
     * @var array
     */
    protected $annotationsToIgnore;

    /**
     * Array with annotation aliases used when create annotation instances.
     *
     * @var array
     */
    protected $annotationAliases;

    /**
     * Initializes the reflection property with the passed data.
     *
     * @param string $className           The properties class name
     * @param string $propertyName        The property name
     * @param array  $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array  $annotationAliases   An array with annotation aliases used when create annotation instances
     */
    public function __construct($className, $propertyName, array $annotationsToIgnore = array(), array $annotationAliases = array())

    {
        // initialize property default values here, as declarative default values may break thread safety,
        // when utilizing static and non-static access on class methods within same thread context!
        $this->className = '';
        $this->propertyName = '';
        $this->annotations = null;

        $this->annotationsToIgnore = array();
        $this->annotationAliases = array();

        $this->className = $className;
        $this->propertyName = $propertyName;
        $this->annotationsToIgnore = $annotationsToIgnore;
        $this->annotationAliases = $annotationAliases;
    }

    /**
     * This method returns the class name as
     * a string.
     *
     * @return string
     */
    public static function __getClass()
    {
        return __CLASS__;
    }

    /**
     * Returns the properties class name.
     *
     * @return string The class name
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getClassName()
     */
    public function getClassName()
    {
        return $this->className;
    }

    /**
     * Returns the property name.
     *
     * @return string The property name
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getPropertyName()
     */
    public function getPropertyName()
    {
        return $this->propertyName;
    }

    /**
     * Returns an array with annotation names we want to ignore when loaded.
     *
     * @return array The annotation names we want to ignore
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationsToIgnore()
     */
    public function getAnnotationsToIgnore()
    {
        return $this->annotationsToIgnore;
    }

    /**
     * Returns an array with annotation aliases used when create annotation instances.
     *
     * @return array The annotation aliases used when create annotation instances
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationAliases()
     */
    public function getAnnotationAliases()
    {
        return $this->annotationAliases;
    }

    /**
     * Registers the annotation alias for the passed class name.
     *
     * @param string $annotationName      The alias
     * @param string $annotationClassName The resolving class name
     *
     * @return void
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::addAnnotationAlias()
     */
    public function addAnnotationAlias($annotationName, $annotationClassName)
    {
        $this->annotationAliases[$annotationName] = $annotationClassName;
    }

    /**
     * Returns the method annotations.
     *
     * @return array The method annotations
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotations()
     */
    public function getAnnotations()
    {

        // check if the annotations has been loaded
        if (isset($this->annotations) === false) {
            $this->annotations = ReflectionAnnotation::fromReflectionProperty($this);
        }

        // return the annotations
        return $this->annotations;
    }

    /**
     * Queries whether the reflection method has an annotation with the passed name or not.
     *
     * @param string $annotationName The annotation we want to query
     *
     * @return boolean TRUE if the reflection method has the annotation, else FALSE
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
     */
    public function hasAnnotation($annotationName)
    {
        $annotations = $this->getAnnotations();
        return isset($annotations[$annotationName]);
    }

    /**
     * Returns the annotation instance with the passed name.
     *
     * @param string $annotationName The name of the requested annotation instance
     *
     * @return \AppserverIo\Lang\Reflection\AnnotationInterface|null The requested annotation instance
     * @throws \AppserverIo\Lang\Reflection\ReflectionException Is thrown if the requested annotation is not available
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
     */
    public function getAnnotation($annotationName)

    {

        // first check if the method is available
        $annotations = $this->getAnnotations();
        if (isset($annotations[$annotationName])) {
            // if yes, return it
            return $annotations[$annotationName];
        }

        // if not, throw an exception
        throw new ReflectionException(sprintf('The requested reflection annotation %s is not available', $annotationName));
    }

    /**
     * Serializes the timeout method and returns a string representation.
     *
     * @return string The serialized string representation of the instance
     * @see \Serializable::serialize()
     */
    public function serialize()
    {
        return serialize(get_object_vars($this));
    }

    /**
     * Restores the instance with the serialized data of the passed string.
     *
     * @param string $data The serialized property representation
     *
     * @return void
     * @see \Serializable::unserialize()
     */
    public function unserialize($data)
    {
        foreach (unserialize($data) as $propertyName => $propertyValue) {
            $this->$propertyName = $propertyValue;
        }
    }

    /**
     * Returns a PHP reflection property representation of this instance.
     *
     * @return \ReflectionProperty The PHP reflection property instance
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::toPhpReflectionProperty()
     */
    public function toPhpReflectionProperty()
    {
        return new \ReflectionProperty($this->getClassName(), $this->getPropertyName());
    }

    /**
     * Returns an array of reflection property instances from the passed reflection class.
     *
     * @param \AppserverIo\Lang\Reflection\ReflectionClass $reflectionClass     The reflection class to return the properties for
     * @param integer                                      $filter              The filter used for loading the properties
     * @param array                                        $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array                                        $annotationAliases   An array with annotation aliases used when create annotation instances
     *
     * @return array An array with ReflectionProperty instances
     */
    public static function fromReflectionClass(ReflectionClass $reflectionClass, $filter = 0, array $annotationsToIgnore = array(), array $annotationAliases = array())
    {

        // initialize the array for the reflection properties
        $reflectionProperties = array();

        // load the reflection properties and initialize the array with the reflection properties
        $phpReflectionClass = $reflectionClass->toPhpReflectionClass();
        foreach ($phpReflectionClass->getProperties($filter) as $phpReflectionProperty) {
            $reflectionProperties[$phpReflectionProperty->getName()] = ReflectionProperty::fromPhpReflectionProperty($phpReflectionProperty, $annotationsToIgnore, $annotationAliases);
        }

        // return the array with the initialized reflection properties
        return $reflectionProperties;
    }

    /**
     * Creates a new reflection property instance from the passed PHP reflection property.
     *
     * @param \ReflectionProperty $reflectionProperty  The reflection property to load the data from
     * @param array               $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array               $annotationAliases   An array with annotation aliases used when create annotation instances
     *
     * @return \AppserverIo\Lang\Reflection\ReflectionProperty The instance
     */
    public static function fromPhpReflectionProperty(\ReflectionProperty $reflectionProperty, array $annotationsToIgnore = array(), array $annotationAliases = array())
    {

        // load class and method name from the reflection class
        $className = $reflectionProperty->getDeclaringClass()->getName();
        $propertyName = $reflectionProperty->getName();

        // initialize and return the timeout method instance
        return new ReflectionProperty($className, $propertyName, $annotationsToIgnore, $annotationAliases);
    }
}


1			<?php
2
3			/**
4			* AppserverIo\Lang\Reflection\ReflectionProperty
5			*
6			* NOTICE OF LICENSE
7			*
8			* This source file is subject to the Open Software License (OSL 3.0)
9			* that is available through the world-wide-web at this URL:
10			* http://opensource.org/licenses/osl-3.0.php
11			*
12			* PHP version 5
13			*
14			* @author Tim Wagner <[email protected]>
15			* @copyright 2015 TechDivision GmbH <[email protected]>
16			* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
17			* @link https://github.com/appserver-io/lang
18			* @link http://www.appserver.io
19			*/
20
21			namespace AppserverIo\Lang\Reflection;
22
23			use AppserverIo\Lang\Object;
24
25			/**
26			* A wrapper instance for a reflection property.
27			*
28			* @author Tim Wagner <[email protected]>
29			* @copyright 2015 TechDivision GmbH <[email protected]>
30			* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
31			* @link https://github.com/appserver-io/lang
32			* @link http://www.appserver.io
33			*/
34			class ReflectionProperty extends Object implements PropertyInterface, \Serializable
35			{
36
37			/**
38			* Default filter for loading reflection properties from a reflection class.
39			*
40			* @var integer
41			*/
42			const ALL_MODIFIERS = -1;
43
44			/**
45			* The properties class name.
46			*
47			* @var string
48			*/
49			protected $className;
50
51			/**
52			* The property name.
53			*
54			* @var string
55			*/
56			protected $propertyName;
57
58			/**
59			* The method annotations.
60			*
61			* @var array
62			*/
63			protected $annotations;
64
65			/**
66			* Array with annotations names we want to ignore when loaded.
67			*
68			* @var array
69			*/
70			protected $annotationsToIgnore;
71
72			/**
73			* Array with annotation aliases used when create annotation instances.
74			*
75			* @var array
76			*/
77			protected $annotationAliases;
78
79			/**
80			* Initializes the reflection property with the passed data.
81			*
82			* @param string $className The properties class name
83			* @param string $propertyName The property name
84			* @param array $annotationsToIgnore An array with annotations names we want to ignore when loaded
85			* @param array $annotationAliases An array with annotation aliases used when create annotation instances
86			*/
87	6	View Code Duplication	public function __construct($className, $propertyName, array $annotationsToIgnore = array(), array $annotationAliases = array())
			0 ignored issues – show Duplication introduced 2016-04-02 20:20 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
88			{
89			// initialize property default values here, as declarative default values may break thread safety,
90			// when utilizing static and non-static access on class methods within same thread context!
91	6		$this->className = '';
92	6		$this->propertyName = '';
93	6		$this->annotations = null;
			0 ignored issues – show Documentation Bug introduced 2016-04-02 20:20 UTC by Report Bug Copy Issue Report It seems like `null` of type `null` is incompatible with the declared type `array` of property `$annotations`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
94	6		$this->annotationsToIgnore = array();
95	6		$this->annotationAliases = array();
96
97	6		$this->className = $className;
98	6		$this->propertyName = $propertyName;
99	6		$this->annotationsToIgnore = $annotationsToIgnore;
100	6		$this->annotationAliases = $annotationAliases;
101	6		}
102
103			/**
104			* This method returns the class name as
105			* a string.
106			*
107			* @return string
108			*/
109	1		public static function __getClass()
110			{
111	1		return __CLASS__;
112			}
113
114			/**
115			* Returns the properties class name.
116			*
117			* @return string The class name
118			* @see \AppserverIo\Lang\Reflection\PropertyInterface::getClassName()
119			*/
120	2		public function getClassName()
121			{
122	2		return $this->className;
123			}
124
125			/**
126			* Returns the property name.
127			*
128			* @return string The property name
129			* @see \AppserverIo\Lang\Reflection\PropertyInterface::getPropertyName()
130			*/
131	2		public function getPropertyName()
132			{
133	2		return $this->propertyName;
134			}
135
136			/**
137			* Returns an array with annotation names we want to ignore when loaded.
138			*
139			* @return array The annotation names we want to ignore
140			* @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationsToIgnore()
141			*/
142	2		public function getAnnotationsToIgnore()
143			{
144	2		return $this->annotationsToIgnore;
145			}
146
147			/**
148			* Returns an array with annotation aliases used when create annotation instances.
149			*
150			* @return array The annotation aliases used when create annotation instances
151			* @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationAliases()
152			*/
153	3		public function getAnnotationAliases()
154			{
155	3		return $this->annotationAliases;
156			}
157
158			/**
159			* Registers the annotation alias for the passed class name.
160			*
161			* @param string $annotationName The alias
162			* @param string $annotationClassName The resolving class name
163			*
164			* @return void
165			* @see \AppserverIo\Lang\Reflection\PropertyInterface::addAnnotationAlias()
166			*/
167	1		public function addAnnotationAlias($annotationName, $annotationClassName)
168			{
169	1		$this->annotationAliases[$annotationName] = $annotationClassName;
170	1		}
171
172			/**
173			* Returns the method annotations.
174			*
175			* @return array The method annotations
176			* @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotations()
177			*/
178	2		public function getAnnotations()
179			{
180
181			// check if the annotations has been loaded
182	2		if (isset($this->annotations) === false) {
183	2		$this->annotations = ReflectionAnnotation::fromReflectionProperty($this);
184			}
185
186			// return the annotations
187	2		return $this->annotations;
188			}
189
190			/**
191			* Queries whether the reflection method has an annotation with the passed name or not.
192			*
193			* @param string $annotationName The annotation we want to query
194			*
195			* @return boolean TRUE if the reflection method has the annotation, else FALSE
196			* @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
197			*/
198			public function hasAnnotation($annotationName)
199			{
200			$annotations = $this->getAnnotations();
201			return isset($annotations[$annotationName]);
202			}
203
204			/**
205			* Returns the annotation instance with the passed name.
206			*
207			* @param string $annotationName The name of the requested annotation instance
208			*
209			* @return \AppserverIo\Lang\Reflection\AnnotationInterface\|null The requested annotation instance
210			* @throws \AppserverIo\Lang\Reflection\ReflectionException Is thrown if the requested annotation is not available
211			* @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
212			*/
213	2	View Code Duplication	public function getAnnotation($annotationName)
			0 ignored issues – show Duplication introduced 2017-11-27 20:32 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
214			{
215
216			// first check if the method is available
217	2		$annotations = $this->getAnnotations();
218	2		if (isset($annotations[$annotationName])) {
219			// if yes, return it
220	1		return $annotations[$annotationName];
221			}
222
223			// if not, throw an exception
224	1		throw new ReflectionException(sprintf('The requested reflection annotation %s is not available', $annotationName));
225			}
226
227			/**
228			* Serializes the timeout method and returns a string representation.
229			*
230			* @return string The serialized string representation of the instance
231			* @see \Serializable::serialize()
232			*/
233	1		public function serialize()
234			{
235	1		return serialize(get_object_vars($this));
236			}
237
238			/**
239			* Restores the instance with the serialized data of the passed string.
240			*
241			* @param string $data The serialized property representation
242			*
243			* @return void
244			* @see \Serializable::unserialize()
245			*/
246	1		public function unserialize($data)
247			{
248	1		foreach (unserialize($data) as $propertyName => $propertyValue) {
249	1		$this->$propertyName = $propertyValue;
250			}
251	1		}
252
253			/**
254			* Returns a PHP reflection property representation of this instance.
255			*
256			* @return \ReflectionProperty The PHP reflection property instance
257			* @see \AppserverIo\Lang\Reflection\PropertyInterface::toPhpReflectionProperty()
258			*/
259	2		public function toPhpReflectionProperty()
260			{
261	2		return new \ReflectionProperty($this->getClassName(), $this->getPropertyName());
262			}
263
264			/**
265			* Returns an array of reflection property instances from the passed reflection class.
266			*
267			* @param \AppserverIo\Lang\Reflection\ReflectionClass $reflectionClass The reflection class to return the properties for
268			* @param integer $filter The filter used for loading the properties
269			* @param array $annotationsToIgnore An array with annotations names we want to ignore when loaded
270			* @param array $annotationAliases An array with annotation aliases used when create annotation instances
271			*
272			* @return array An array with ReflectionProperty instances
273			*/
274	1		public static function fromReflectionClass(ReflectionClass $reflectionClass, $filter = 0, array $annotationsToIgnore = array(), array $annotationAliases = array())
275			{
276
277			// initialize the array for the reflection properties
278	1		$reflectionProperties = array();
279
280			// load the reflection properties and initialize the array with the reflection properties
281	1		$phpReflectionClass = $reflectionClass->toPhpReflectionClass();
282	1		foreach ($phpReflectionClass->getProperties($filter) as $phpReflectionProperty) {
283	1		$reflectionProperties[$phpReflectionProperty->getName()] = ReflectionProperty::fromPhpReflectionProperty($phpReflectionProperty, $annotationsToIgnore, $annotationAliases);
284			}
285
286			// return the array with the initialized reflection properties
287	1		return $reflectionProperties;
288			}
289
290			/**
291			* Creates a new reflection property instance from the passed PHP reflection property.
292			*
293			* @param \ReflectionProperty $reflectionProperty The reflection property to load the data from
294			* @param array $annotationsToIgnore An array with annotations names we want to ignore when loaded
295			* @param array $annotationAliases An array with annotation aliases used when create annotation instances
296			*
297			* @return \AppserverIo\Lang\Reflection\ReflectionProperty The instance
298			*/
299	1		public static function fromPhpReflectionProperty(\ReflectionProperty $reflectionProperty, array $annotationsToIgnore = array(), array $annotationAliases = array())
300			{
301
302			// load class and method name from the reflection class
303	1		$className = $reflectionProperty->getDeclaringClass()->getName();
304	1		$propertyName = $reflectionProperty->getName();
305
306			// initialize and return the timeout method instance
307	1		return new ReflectionProperty($className, $propertyName, $annotationsToIgnore, $annotationAliases);
308			}
309			}
310

appserver-io / lang

Pull Request — master (#25)

ReflectionProperty::toPhpReflectionProperty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like