ReflectionCompositeFactory::__construct() - Code Metrics - Inspection of "Get inheritance working" - spaark/composite-utils - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#3)

by Emily

created 2017-02-18 16:01 UTC

ReflectionCompositeFactory::__construct() A

↳ Parent: ReflectionCompositeFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

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

<?php
/**
 * This file is part of the Composite Utils package.
 *
 * (c) Emily Shepherd <[email protected]>
 *
 * For the full copyright and license information, please view the
 * LICENSE.md file that was distributed with this source code.
 *
 * @package spaark/composite-utils
 * @author Emily Shepherd <[email protected]>
 * @license MIT
 */

namespace Spaark\CompositeUtils\Factory\Reflection;

use Spaark\CompositeUtils\Factory\BaseFactory;
use Spaark\CompositeUtils\Model\Reflection\ReflectionComposite;
use Spaark\CompositeUtils\Service\ReflectionCompositeProviderInterface;
use Spaark\CompositeUtils\Service\ReflectionCompositeProvider;
use \ReflectionClass as PHPNativeReflectionClass;
use \ReflectionProperty as PHPNativeReflectionProperty;
use \ReflectionMethod as PHPNativeReflectionMethod;
use \Reflector;

/**
 * Builds a ReflectionComposite for a given class
 */
class ReflectionCompositeFactory extends ReflectorFactory
{
    const REFLECTION_OBJECT = ReflectionComposite::class;

    /**
     * @var PHPNativeReflector
     */
    protected $reflector;

    /**
     * @var ReflectionComposite
     */
    protected $object;

    /**
     * @var ReflectionCompositeProviderInterface
     */
    protected $provider;

    /**
     * Creates a new ReflectionCompositeFactory from the given
     * classname
     *
     * @param string $classname The class to build a reflect upon
     * @return ReflectionCompositeFactory
     */
    public static function fromClassName(string $classname)
    {
        return new static
        (
            new PHPNativeReflectionClass($classname),
            ReflectionCompositeProvider::getDefault()
        );
    }

    public function __construct
    (
        PHPNativeReflectionClass $reflect,
        ReflectionCompositeProviderInterface $provider
    )
    {
        parent::__construct($reflect);
        $this->provider = $provider;
    }

    /**
     * Builds the ReflectionComposite from the provided parameters
     *
     * @return ReflectionComposite
     */
    public function build()
    {
        $file = 
            (new ReflectionFileFactory($this->reflector->getFileName()))
                ->build();
        $this->accessor->setRawValue('file', $file);
        $this->accessor->setRawValue
        (
            'classname',
            $this->reflector->name
        );
        $this->accessor->setRawValue
        (
            'namespace',
            $file->namespaces[$this->reflector->getNamespaceName()]
        );

        foreach ($this->reflector->getProperties() as $property)
        {
            if ($this->checkIfLocal($property))
            {
                $this->buildProperty($property);
            }
        }

        foreach ($this->reflector->getMethods() as $method)
        {
            if ($this->checkIfLocal($method))
            {
                $this->buildMethod($method);
            }
        }

        return $this->object;
    }

    /**
     * Uses a ReflectionPropertyFactory to build a ReflectionProperty,
     * and adds that to this ReflectionComposite
     *
     * @param PHPNativeReflectionProperty
     */
    protected function buildProperty
    (
        PHPNativeReflectionProperty $reflect
    )
    {
        $properties = $this->accessor->getRawValue('properties');

        $properties[$reflect->getName()] = 
            (new ReflectionPropertyFactory($reflect))
                ->build
                (
                    $this->object,
                    $this->reflector
                        ->getDefaultProperties()[$reflect->getName()]
                );
    }

    /**
     * Uses a ReflectionMethodFactory to build a ReflectionMethod, and
     * adds that to this ReflectionComposite
     *
     * @param PHPNativeReflectionMethod
     */
    protected function buildMethod(PHPNativeReflectionMethod $reflect)
    {
        $methods = $this->accessor->getRawValue('methods');
        $methods[$reflect->getName()] =

            (new ReflectionMethodFactory($reflect))
                ->build($this->object);
    }

    /**
     * Checks if a property is defined in the class
     *
     * @param Reflector $reflector
     * @return boolean
     */
    protected function checkIfLocal(Reflector $reflector)
    {
        return $reflector->class === $this->reflector->getName();
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
    }
}



1		<?php
2		/**
3		* This file is part of the Composite Utils package.
4		*
5		* (c) Emily Shepherd <[email protected]>
6		*
7		* For the full copyright and license information, please view the
8		* LICENSE.md file that was distributed with this source code.
9		*
10		* @package spaark/composite-utils
11		* @author Emily Shepherd <[email protected]>
12		* @license MIT
13		*/
14
15		namespace Spaark\CompositeUtils\Factory\Reflection;
16
17		use Spaark\CompositeUtils\Factory\BaseFactory;
18		use Spaark\CompositeUtils\Model\Reflection\ReflectionComposite;
19		use Spaark\CompositeUtils\Service\ReflectionCompositeProviderInterface;
20		use Spaark\CompositeUtils\Service\ReflectionCompositeProvider;
21		use \ReflectionClass as PHPNativeReflectionClass;
22		use \ReflectionProperty as PHPNativeReflectionProperty;
23		use \ReflectionMethod as PHPNativeReflectionMethod;
24		use \Reflector;
25
26		/**
27		* Builds a ReflectionComposite for a given class
28		*/
29		class ReflectionCompositeFactory extends ReflectorFactory
30		{
31		const REFLECTION_OBJECT = ReflectionComposite::class;
32
33		/**
34		* @var PHPNativeReflector
35		*/
36		protected $reflector;
37
38		/**
39		* @var ReflectionComposite
40		*/
41		protected $object;
42
43		/**
44		* @var ReflectionCompositeProviderInterface
45		*/
46		protected $provider;
47
48		/**
49		* Creates a new ReflectionCompositeFactory from the given
50		* classname
51		*
52		* @param string $classname The class to build a reflect upon
53		* @return ReflectionCompositeFactory
54		*/
55	19	public static function fromClassName(string $classname)
56		{
57	19	return new static
58		(
59	19	new PHPNativeReflectionClass($classname),
60	19	ReflectionCompositeProvider::getDefault()
61		);
62		}
63
64	19	public function __construct
65		(
66		PHPNativeReflectionClass $reflect,
67		ReflectionCompositeProviderInterface $provider
68		)
69		{
70	19	parent::__construct($reflect);
71	19	$this->provider = $provider;
72	19	}
73
74		/**
75		* Builds the ReflectionComposite from the provided parameters
76		*
77		* @return ReflectionComposite
78		*/
79	19	public function build()
80		{
81		$file =
82	19	(new ReflectionFileFactory($this->reflector->getFileName()))
83	19	->build();
84	19	$this->accessor->setRawValue('file', $file);
85	19	$this->accessor->setRawValue
86		(
87	19	'classname',
88	19	$this->reflector->name
89		);
90	19	$this->accessor->setRawValue
91		(
92	19	'namespace',
93	19	$file->namespaces[$this->reflector->getNamespaceName()]
94		);
95
96	19	foreach ($this->reflector->getProperties() as $property)
97		{
98	19	if ($this->checkIfLocal($property))
99		{
100	19	$this->buildProperty($property);
101		}
102		}
103
104	19	foreach ($this->reflector->getMethods() as $method)
105		{
106	19	if ($this->checkIfLocal($method))
107		{
108	19	$this->buildMethod($method);
109		}
110		}
111
112	19	return $this->object;
113		}
114
115		/**
116		* Uses a ReflectionPropertyFactory to build a ReflectionProperty,
117		* and adds that to this ReflectionComposite
118		*
119		* @param PHPNativeReflectionProperty
120		*/
121	19	protected function buildProperty
122		(
123		PHPNativeReflectionProperty $reflect
124		)
125		{
126	19	$properties = $this->accessor->getRawValue('properties');
127
128	19	$properties[$reflect->getName()] =
129	19	(new ReflectionPropertyFactory($reflect))
130	19	->build
131		(
132	19	$this->object,
133	19	$this->reflector
134	19	->getDefaultProperties()[$reflect->getName()]
135		);
136	19	}
137
138		/**
139		* Uses a ReflectionMethodFactory to build a ReflectionMethod, and
140		* adds that to this ReflectionComposite
141		*
142		* @param PHPNativeReflectionMethod
143		*/
144	19	protected function buildMethod(PHPNativeReflectionMethod $reflect)
145		{
146	19	$methods = $this->accessor->getRawValue('methods');
147	19	$methods[$reflect->getName()] =
		0 ignored issues – show Bug introduced 2017-02-15 22:55 UTC by Report Bug Copy Issue Report Consider using `$reflect->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
148	19	(new ReflectionMethodFactory($reflect))
149	19	->build($this->object);
150	19	}
151
152		/**
153		* Checks if a property is defined in the class
154		*
155		* @param Reflector $reflector
156		* @return boolean
157		*/
158	19	protected function checkIfLocal(Reflector $reflector)
159		{
160	19	return $reflector->class === $this->reflector->getName();
		0 ignored issues – show Bug introduced 2017-02-13 21:10 UTC by Report Bug Copy Issue Report Accessing `class` on the interface `Reflector` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
161		}
162		}
163
164

spaark / composite-utils

Pull Request — master (#3)

ReflectionCompositeFactory::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like