AspectLoader::load() - Code Metrics - Inspection of "Merge pull request #286 from goaop/fix/php-token-r..." - goaop/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.x ( c183a4...05b51a )

by Alexander

created 2016-05-23 11:19 UTC

AspectLoader::load() B

↳ Parent: AspectLoader

Complexity

Conditions	6
Paths	8

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	25
ccs	0
cts	14
cp	0
rs	8.439
c	1
b	0
f	0
cc	6
eloc	14
nc	8
nop	1
crap	42

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2012, Lisachenko Alexander <[email protected]>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Core;

use Doctrine\Common\Annotations\Reader;
use Go\Aop\Advisor;
use Go\Aop\Aspect;
use Go\Aop\Pointcut;
use ReflectionClass;

/**
 * Loader of aspects into the container
 */
class AspectLoader
{

    /**
     * Aspect container instance
     *
     * @var null|AspectContainer
     */
    protected $container = null;

    /**
     * List of aspect loaders
     *
     * @var array
     */
    protected $loaders = [];

    /**
     * Annotation reader for aspects
     *
     * @var Reader|null
     */
    protected $annotationReader = null;

    /**
     * List of aspects that was loaded
     *
     * @var array
     */
    protected $loadedAspects = [];

    /**
     * Loader constructor
     *
     * @param AspectContainer $container Instance of container to store pointcuts and advisors
     * @param Reader $reader Reader for annotations that is used for aspects
     */
    public function __construct(AspectContainer $container, Reader $reader)
    {
        $this->container        = $container;
        $this->annotationReader = $reader;
    }

    /**
     * Register an aspect loader extension
     *
     * This method allows to extend the logic of aspect loading by registering an extension for loader.
     *
     * @param AspectLoaderExtension $loader Loader to register
     */
    public function registerLoaderExtension(AspectLoaderExtension $loader)
    {
        $targets = (array) $loader->getTarget();
        foreach ($targets as $target) {
            $this->loaders[$target][] = $loader;
        }
    }

    /**
     * Loads an aspect with the help of aspect loaders, but don't register it in the container
     *
     * @see loadAndRegister() method for registration
     *
     * @param \Go\Aop\Aspect $aspect Aspect to load
     *
     * @return array|Pointcut[]|Advisor[]
     */
    public function load(Aspect $aspect)
    {
        $loadedItems = [];
        $refAspect   = new \ReflectionClass($aspect);

        if (!empty($this->loaders[AspectLoaderExtension::TARGET_CLASS])) {
            $loadedItems += $this->loadFrom($aspect, $refAspect, $this->loaders[AspectLoaderExtension::TARGET_CLASS]);
        }

        if (!empty($this->loaders[AspectLoaderExtension::TARGET_METHOD])) {
            $refMethods = $refAspect->getMethods();
            foreach ($refMethods as $refMethod) {
                $loadedItems += $this->loadFrom($aspect, $refMethod, $this->loaders[AspectLoaderExtension::TARGET_METHOD]);
            }
        }

        if (!empty($this->loaders[AspectLoaderExtension::TARGET_PROPERTY])) {
            $refProperties = $refAspect->getProperties();
            foreach ($refProperties as $refProperty) {
                $loadedItems += $this->loadFrom($aspect, $refProperty, $this->loaders[AspectLoaderExtension::TARGET_PROPERTY]);
            }
        }

        return $loadedItems;
    }

    /**
     * Loads and register all items of aspect in the container
     *
     * @param Aspect $aspect
     */
    public function loadAndRegister(Aspect $aspect)
    {
        $loadedItems = $this->load($aspect);
        foreach ($loadedItems as $itemId => $item) {
            if ($item instanceof Pointcut) {
                $this->container->registerPointcut($item, $itemId);
            }
            if ($item instanceof Advisor) {
                $this->container->registerAdvisor($item, $itemId);
            }
        }

        $aspectClass = get_class($aspect);
        $this->loadedAspects[$aspectClass] = $aspectClass;
    }

    /**
     * Returns list of unloaded aspects in the container
     *
     * @return array|Aspect[]
     */
    public function getUnloadedAspects()
    {
        $unloadedAspects = [];

        foreach ($this->container->getByTag('aspect') as $aspect) {
            if (!isset($this->loadedAspects[get_class($aspect)])) {
                $unloadedAspects[] = $aspect;
            }
        }

        return $unloadedAspects;
    }

    /**
     * Load definitions from specific aspect part into the aspect container
     *
     * @param Aspect $aspect Aspect instance
     * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $refPoint Reflection instance
     * @param array|AspectLoaderExtension[] $loaders List of loaders that can produce advisors from aspect class
     *
     * @throws \InvalidArgumentException If kind of loader isn't supported
     *
     * @return array|Pointcut[]|Advisor[]
     */
    protected function loadFrom(Aspect $aspect, $refPoint, array $loaders)
    {
        $loadedItems = [];

        foreach ($loaders as $loader) {


            $loaderKind = $loader->getKind();
            switch ($loaderKind) {


                case AspectLoaderExtension::KIND_REFLECTION:
                    if ($loader->supports($aspect, $refPoint)) {
                        $loadedItems += $loader->load($aspect, $refPoint);
                    }
                    break;

                case AspectLoaderExtension::KIND_ANNOTATION:
                    $annotations = $this->getAnnotations($refPoint);
                    foreach ($annotations as $annotation) {
                        if ($loader->supports($aspect, $refPoint, $annotation)) {
                            $loadedItems += $loader->load($aspect, $refPoint, $annotation);
                        }
                    }
                    break;

                default:
                    throw new \InvalidArgumentException("Unsupported loader kind {$loaderKind}");


            }
        }

        return $loadedItems;
    }

    /**
     * Return list of annotations for reflection point
     *
     * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $refPoint Reflection instance
     *
     * @return array list of annotations
     * @throws \InvalidArgumentException if $refPoint is unsupported
     */
    protected function getAnnotations($refPoint)
    {
        switch (true) {
            case ($refPoint instanceof \ReflectionClass):
                return $this->annotationReader->getClassAnnotations($refPoint);

            case ($refPoint instanceof \ReflectionMethod):
                return $this->annotationReader->getMethodAnnotations($refPoint);

            case ($refPoint instanceof \ReflectionProperty):
                return $this->annotationReader->getPropertyAnnotations($refPoint);

            default:
                throw new \InvalidArgumentException("Unsupported reflection point " . get_class($refPoint));
        }
    }
}


1		<?php
2		/*
3		* Go! AOP framework
4		*
5		* @copyright Copyright 2012, Lisachenko Alexander <[email protected]>
6		*
7		* This source file is subject to the license that is bundled
8		* with this source code in the file LICENSE.
9		*/
10
11		namespace Go\Core;
12
13		use Doctrine\Common\Annotations\Reader;
14		use Go\Aop\Advisor;
15		use Go\Aop\Aspect;
16		use Go\Aop\Pointcut;
17		use ReflectionClass;
18
19		/**
20		* Loader of aspects into the container
21		*/
22		class AspectLoader
23		{
24
25		/**
26		* Aspect container instance
27		*
28		* @var null\|AspectContainer
29		*/
30		protected $container = null;
31
32		/**
33		* List of aspect loaders
34		*
35		* @var array
36		*/
37		protected $loaders = [];
38
39		/**
40		* Annotation reader for aspects
41		*
42		* @var Reader\|null
43		*/
44		protected $annotationReader = null;
45
46		/**
47		* List of aspects that was loaded
48		*
49		* @var array
50		*/
51		protected $loadedAspects = [];
52
53		/**
54		* Loader constructor
55		*
56		* @param AspectContainer $container Instance of container to store pointcuts and advisors
57		* @param Reader $reader Reader for annotations that is used for aspects
58		*/
59	13	public function __construct(AspectContainer $container, Reader $reader)
60		{
61	13	$this->container = $container;
62	13	$this->annotationReader = $reader;
63	13	}
64
65		/**
66		* Register an aspect loader extension
67		*
68		* This method allows to extend the logic of aspect loading by registering an extension for loader.
69		*
70		* @param AspectLoaderExtension $loader Loader to register
71		*/
72	2	public function registerLoaderExtension(AspectLoaderExtension $loader)
73		{
74	2	$targets = (array) $loader->getTarget();
75	2	foreach ($targets as $target) {
76	2	$this->loaders[$target][] = $loader;
77		}
78	2	}
79
80		/**
81		* Loads an aspect with the help of aspect loaders, but don't register it in the container
82		*
83		* @see loadAndRegister() method for registration
84		*
85		* @param \Go\Aop\Aspect $aspect Aspect to load
86		*
87		* @return array\|Pointcut[]\|Advisor[]
88		*/
89		public function load(Aspect $aspect)
90		{
91		$loadedItems = [];
92		$refAspect = new \ReflectionClass($aspect);
93
94		if (!empty($this->loaders[AspectLoaderExtension::TARGET_CLASS])) {
95		$loadedItems += $this->loadFrom($aspect, $refAspect, $this->loaders[AspectLoaderExtension::TARGET_CLASS]);
96		}
97
98		if (!empty($this->loaders[AspectLoaderExtension::TARGET_METHOD])) {
99		$refMethods = $refAspect->getMethods();
100		foreach ($refMethods as $refMethod) {
101		$loadedItems += $this->loadFrom($aspect, $refMethod, $this->loaders[AspectLoaderExtension::TARGET_METHOD]);
102		}
103		}
104
105		if (!empty($this->loaders[AspectLoaderExtension::TARGET_PROPERTY])) {
106		$refProperties = $refAspect->getProperties();
107		foreach ($refProperties as $refProperty) {
108		$loadedItems += $this->loadFrom($aspect, $refProperty, $this->loaders[AspectLoaderExtension::TARGET_PROPERTY]);
109		}
110		}
111
112		return $loadedItems;
113		}
114
115		/**
116		* Loads and register all items of aspect in the container
117		*
118		* @param Aspect $aspect
119		*/
120		public function loadAndRegister(Aspect $aspect)
121		{
122		$loadedItems = $this->load($aspect);
123		foreach ($loadedItems as $itemId => $item) {
124		if ($item instanceof Pointcut) {
125		$this->container->registerPointcut($item, $itemId);
126		}
127		if ($item instanceof Advisor) {
128		$this->container->registerAdvisor($item, $itemId);
129		}
130		}
131
132		$aspectClass = get_class($aspect);
133		$this->loadedAspects[$aspectClass] = $aspectClass;
134		}
135
136		/**
137		* Returns list of unloaded aspects in the container
138		*
139		* @return array\|Aspect[]
140		*/
141		public function getUnloadedAspects()
142		{
143		$unloadedAspects = [];
144
145		foreach ($this->container->getByTag('aspect') as $aspect) {
146		if (!isset($this->loadedAspects[get_class($aspect)])) {
147		$unloadedAspects[] = $aspect;
148		}
149		}
150
151		return $unloadedAspects;
152		}
153
154		/**
155		* Load definitions from specific aspect part into the aspect container
156		*
157		* @param Aspect $aspect Aspect instance
158		* @param \ReflectionClass\|\ReflectionMethod\|\ReflectionProperty $refPoint Reflection instance
159		* @param array\|AspectLoaderExtension[] $loaders List of loaders that can produce advisors from aspect class
160		*
161		* @throws \InvalidArgumentException If kind of loader isn't supported
162		*
163		* @return array\|Pointcut[]\|Advisor[]
164		*/
165		protected function loadFrom(Aspect $aspect, $refPoint, array $loaders)
166		{
167		$loadedItems = [];
168
169		foreach ($loaders as $loader) {
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report Blank line found at start of control structure Loading history...
170
171		$loaderKind = $loader->getKind();
172		switch ($loaderKind) {
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report Blank line found at start of control structure Loading history...
173
174		case AspectLoaderExtension::KIND_REFLECTION:
175		if ($loader->supports($aspect, $refPoint)) {
176		$loadedItems += $loader->load($aspect, $refPoint);
177		}
178		break;
179
180		case AspectLoaderExtension::KIND_ANNOTATION:
181		$annotations = $this->getAnnotations($refPoint);
182		foreach ($annotations as $annotation) {
183		if ($loader->supports($aspect, $refPoint, $annotation)) {
184		$loadedItems += $loader->load($aspect, $refPoint, $annotation);
185		}
186		}
187		break;
188
189		default:
190		throw new \InvalidArgumentException("Unsupported loader kind {$loaderKind}");
191
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report Blank line found at end of control structure Loading history...
192		}
193		}
194
195		return $loadedItems;
196		}
197
198		/**
199		* Return list of annotations for reflection point
200		*
201		* @param \ReflectionClass\|\ReflectionMethod\|\ReflectionProperty $refPoint Reflection instance
202		*
203		* @return array list of annotations
204		* @throws \InvalidArgumentException if $refPoint is unsupported
205		*/
206		protected function getAnnotations($refPoint)
207		{
208		switch (true) {
209		case ($refPoint instanceof \ReflectionClass):
210		return $this->annotationReader->getClassAnnotations($refPoint);
211
212		case ($refPoint instanceof \ReflectionMethod):
213		return $this->annotationReader->getMethodAnnotations($refPoint);
214
215		case ($refPoint instanceof \ReflectionProperty):
216		return $this->annotationReader->getPropertyAnnotations($refPoint);
217
218		default:
219		throw new \InvalidArgumentException("Unsupported reflection point " . get_class($refPoint));
220		}
221		}
222		}
223

goaop / framework

Push — 1.x ( c183a4...05b51a )

AspectLoader::load() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like