AdviceMatcher::getAdvicesForClass() - 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

AdviceMatcher::getAdvicesForClass() C

↳ Parent: AdviceMatcher

Complexity

Conditions	8
Paths	20

Size

Total Lines	36
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	8.3518

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
dl	0
loc	36
ccs	14
cts	17
cp	0.8235
rs	5.3846
c	2
b	0
f	0
cc	8
eloc	20
nc	20
nop	2
crap	8.3518

<?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 ReflectionMethod;
use ReflectionProperty;
use Go\Aop;
use Go\Aop\Support\NamespacedReflectionFunction;
use TokenReflection\ReflectionClass as ParsedReflectionClass;
use TokenReflection\ReflectionFileNamespace;

/**
 * Advice matcher returns the list of advices for the specific point of code
 */
class AdviceMatcher
{
    /**
     * Loader of aspects
     *
     * @var AspectLoader
     */
    protected $loader;

    /**
     * Flag to enable/disable support of global function interception
     *
     * @var bool
     */
    private $isInterceptFunctions = false;

    /**
     * Constructor
     *
     * @param AspectLoader $loader Instance of aspect loader
     * @param bool $isInterceptFunctions Optional flag to enable function interception
     */
    public function __construct(AspectLoader $loader, $isInterceptFunctions = false)
    {
        $this->loader = $loader;

        $this->isInterceptFunctions = $isInterceptFunctions;
    }

    /**
     * Returns list of function advices for namespace
     *
     * @param ReflectionFileNamespace $namespace
     * @param array|Aop\Advisor[] $advisors List of advisor to match
     *
     * @return array
     */
    public function getAdvicesForFunctions(ReflectionFileNamespace $namespace, array $advisors)
    {
        if (!$this->isInterceptFunctions || $namespace->getName() == 'no-namespace') {
            return [];
        }

        $advices = [];

        foreach ($advisors as $advisorId => $advisor) {


            if ($advisor instanceof Aop\PointcutAdvisor) {


                $pointcut = $advisor->getPointcut();
                $isFunctionAdvisor = $pointcut->getKind() & Aop\PointFilter::KIND_FUNCTION;
                if ($isFunctionAdvisor && $pointcut->getClassFilter()->matches($namespace)) {
                    $advices = array_merge_recursive(
                        $advices,
                        $this->getFunctionAdvicesFromAdvisor($namespace, $advisor, $advisorId, $pointcut)
                    );
                }
            }
        }

        return $advices;
    }

    /**
     * Return list of advices for class
     *
     * @param ParsedReflectionClass $class Class to advise
     * @param array|Aop\Advisor[] $advisors List of advisor to match
     *
     * @return array|Aop\Advice[] List of advices for class
     */
    public function getAdvicesForClass(ParsedReflectionClass $class, array $advisors)
    {
        $classAdvices = [];
        $parentClass  = $class->getParentClass();

        if ($parentClass && preg_match('/' . AspectContainer::AOP_PROXIED_SUFFIX . '$/', $parentClass->name)) {
            $originalClass = $parentClass;
        } else {
            $originalClass = $class;
        }

        foreach ($advisors as $advisorId => $advisor) {


            if ($advisor instanceof Aop\PointcutAdvisor) {


                $pointcut = $advisor->getPointcut();
                if ($pointcut->getClassFilter()->matches($class)) {
                    $classAdvices = array_merge_recursive(
                        $classAdvices,
                        $this->getAdvicesFromAdvisor($originalClass, $advisor, $advisorId, $pointcut)
                    );
                }
            }

            if ($advisor instanceof Aop\IntroductionAdvisor) {
                if ($advisor->getClassFilter()->matches($class)) {
                    $classAdvices = array_merge_recursive(
                        $classAdvices,
                        $this->getIntroductionFromAdvisor($originalClass, $advisor, $advisorId)
                    );
                }
            }
        }

        return $classAdvices;
    }

    /**
     * Returns list of advices from advisor and point filter
     *
     * @param ParsedReflectionClass $class Class to inject advices
     * @param Aop\PointcutAdvisor $advisor Advisor for class
     * @param string $advisorId Identifier of advisor
     * @param Aop\PointFilter $filter Filter for points
     *
     * @return array
     */
    private function getAdvicesFromAdvisor(
        ParsedReflectionClass $class,
        Aop\PointcutAdvisor $advisor,
        $advisorId,
        Aop\PointFilter $filter)

    {

        $classAdvices = [];
        $filterKind   = $filter->getKind();

        // Check class only for class filters
        if ($filterKind & Aop\PointFilter::KIND_CLASS) {
            if ($filter->matches($class)) {
                // Dynamic initialization
                if ($filterKind & Aop\PointFilter::KIND_INIT) {
                    $classAdvices[AspectContainer::INIT_PREFIX]['root'][$advisorId] = $advisor->getAdvice();
                }
                // Static initalization
                if ($filterKind & Aop\PointFilter::KIND_STATIC_INIT) {
                    $classAdvices[AspectContainer::STATIC_INIT_PREFIX]['root'][$advisorId] = $advisor->getAdvice();
                }
            }
        }

        // Check methods in class only for method filters
        if ($filterKind & Aop\PointFilter::KIND_METHOD) {


            $mask = ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED;
            foreach ($class->getMethods($mask) as $method) {
                /** @var $method ReflectionMethod| */
                if ($filter->matches($method, $class)) {
                    $prefix = $method->isStatic() ? AspectContainer::STATIC_METHOD_PREFIX : AspectContainer::METHOD_PREFIX;
                    $classAdvices[$prefix][$method->name][$advisorId] = $advisor->getAdvice();
                }
            }
        }

        // Check properties in class only for property filters
        if ($filterKind & Aop\PointFilter::KIND_PROPERTY) {
            $mask = ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED;
            foreach ($class->getProperties($mask) as $property) {
                /** @var $property ReflectionProperty */
                if ($filter->matches($property, $class) && !$property->isStatic()) {
                    $classAdvices[AspectContainer::PROPERTY_PREFIX][$property->name][$advisorId] = $advisor->getAdvice();
                }
            }
        }

        return $classAdvices;
    }

    /**
     * Returns list of introduction advices from advisor
     *
     * @param ParsedReflectionClass $class Class to inject advices
     * @param Aop\IntroductionAdvisor $advisor Advisor for class
     * @param string $advisorId Identifier of advisor
     *
     * @return array
     */
    private function getIntroductionFromAdvisor(
        ParsedReflectionClass $class,
        Aop\IntroductionAdvisor $advisor,
        $advisorId)

    {

        $classAdvices = [];
        // Do not make introduction for traits
        if ($class->isTrait()) {
            return $classAdvices;
        }

        $advice = $advisor->getAdvice();

        $classAdvices[AspectContainer::INTRODUCTION_TRAIT_PREFIX][$advisorId] = $advice;

        return $classAdvices;
    }

    /**
     * Returns list of function advices for specific namespace
     *
     * @param ReflectionFileNamespace $namespace
     * @param Aop\PointcutAdvisor $advisor Advisor for class
     * @param string $advisorId Identifier of advisor
     * @param Aop\PointFilter $pointcut Filter for points
     *
     * @return array
     */
    private function getFunctionAdvicesFromAdvisor(
        ReflectionFileNamespace $namespace,
        Aop\PointcutAdvisor $advisor,
        $advisorId,
        Aop\PointFilter $pointcut)

    {

        $functions = [];
        $advices   = [];

        $listOfGlobalFunctions = get_defined_functions();
        foreach ($listOfGlobalFunctions['internal'] as $functionName) {
            $functions[$functionName] = new NamespacedReflectionFunction($functionName, $namespace->getName());
        }

        foreach ($functions as $functionName=>$function) {

            if ($pointcut->matches($function, $namespace)) {
                $advices[AspectContainer::FUNCTION_PREFIX][$functionName][$advisorId] = $advisor->getAdvice();
            }
        }

        return $advices;
    }
}


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 ReflectionMethod;
14		use ReflectionProperty;
15		use Go\Aop;
16		use Go\Aop\Support\NamespacedReflectionFunction;
17		use TokenReflection\ReflectionClass as ParsedReflectionClass;
18		use TokenReflection\ReflectionFileNamespace;
19
20		/**
21		* Advice matcher returns the list of advices for the specific point of code
22		*/
23		class AdviceMatcher
24		{
25		/**
26		* Loader of aspects
27		*
28		* @var AspectLoader
29		*/
30		protected $loader;
31
32		/**
33		* Flag to enable/disable support of global function interception
34		*
35		* @var bool
36		*/
37		private $isInterceptFunctions = false;
38
39		/**
40		* Constructor
41		*
42		* @param AspectLoader $loader Instance of aspect loader
43		* @param bool $isInterceptFunctions Optional flag to enable function interception
44		*/
45	4	public function __construct(AspectLoader $loader, $isInterceptFunctions = false)
46		{
47	4	$this->loader = $loader;
48
49	4	$this->isInterceptFunctions = $isInterceptFunctions;
50	4	}
51
52		/**
53		* Returns list of function advices for namespace
54		*
55		* @param ReflectionFileNamespace $namespace
56		* @param array\|Aop\Advisor[] $advisors List of advisor to match
57		*
58		* @return array
59		*/
60	8	public function getAdvicesForFunctions(ReflectionFileNamespace $namespace, array $advisors)
61		{
62	8	if (!$this->isInterceptFunctions \|\| $namespace->getName() == 'no-namespace') {
63	8	return [];
64		}
65
66		$advices = [];
67
68		foreach ($advisors as $advisorId => $advisor) {
		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...
69
70		if ($advisor instanceof Aop\PointcutAdvisor) {
		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...
71
72		$pointcut = $advisor->getPointcut();
73		$isFunctionAdvisor = $pointcut->getKind() & Aop\PointFilter::KIND_FUNCTION;
74		if ($isFunctionAdvisor && $pointcut->getClassFilter()->matches($namespace)) {
75		$advices = array_merge_recursive(
76		$advices,
77		$this->getFunctionAdvicesFromAdvisor($namespace, $advisor, $advisorId, $pointcut)
78		);
79		}
80		}
81		}
82
83		return $advices;
84		}
85
86		/**
87		* Return list of advices for class
88		*
89		* @param ParsedReflectionClass $class Class to advise
90		* @param array\|Aop\Advisor[] $advisors List of advisor to match
91		*
92		* @return array\|Aop\Advice[] List of advices for class
93		*/
94	3	public function getAdvicesForClass(ParsedReflectionClass $class, array $advisors)
95		{
96	3	$classAdvices = [];
97	3	$parentClass = $class->getParentClass();
98
99	3	if ($parentClass && preg_match('/' . AspectContainer::AOP_PROXIED_SUFFIX . '$/', $parentClass->name)) {
100		$originalClass = $parentClass;
101		} else {
102	3	$originalClass = $class;
103		}
104
105	3	foreach ($advisors as $advisorId => $advisor) {
		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...
106
107	2	if ($advisor instanceof Aop\PointcutAdvisor) {
		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...
108
109	2	$pointcut = $advisor->getPointcut();
110	2	if ($pointcut->getClassFilter()->matches($class)) {
111	2	$classAdvices = array_merge_recursive(
112		$classAdvices,
113	2	$this->getAdvicesFromAdvisor($originalClass, $advisor, $advisorId, $pointcut)
114		);
115		}
116		}
117
118	2	if ($advisor instanceof Aop\IntroductionAdvisor) {
119		if ($advisor->getClassFilter()->matches($class)) {
120		$classAdvices = array_merge_recursive(
121		$classAdvices,
122	2	$this->getIntroductionFromAdvisor($originalClass, $advisor, $advisorId)
123		);
124		}
125		}
126		}
127
128	3	return $classAdvices;
129		}
130
131		/**
132		* Returns list of advices from advisor and point filter
133		*
134		* @param ParsedReflectionClass $class Class to inject advices
135		* @param Aop\PointcutAdvisor $advisor Advisor for class
136		* @param string $advisorId Identifier of advisor
137		* @param Aop\PointFilter $filter Filter for points
138		*
139		* @return array
140		*/
141	2	private function getAdvicesFromAdvisor(
142		ParsedReflectionClass $class,
143		Aop\PointcutAdvisor $advisor,
144		$advisorId,
145		Aop\PointFilter $filter)
		0 ignored issues – show Coding Style introduced 2016-02-13 15:18 UTC by Report Bug Copy Issue Report The closing parenthesis of a multi-line function declaration must be on a new line Loading history...
146		{
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report The closing parenthesis and the opening brace of a multi-line function declaration must be on the same line Loading history...
147	2	$classAdvices = [];
148	2	$filterKind = $filter->getKind();
149
150		// Check class only for class filters
151	2	if ($filterKind & Aop\PointFilter::KIND_CLASS) {
152		if ($filter->matches($class)) {
153		// Dynamic initialization
154		if ($filterKind & Aop\PointFilter::KIND_INIT) {
155		$classAdvices[AspectContainer::INIT_PREFIX]['root'][$advisorId] = $advisor->getAdvice();
156		}
157		// Static initalization
158		if ($filterKind & Aop\PointFilter::KIND_STATIC_INIT) {
159		$classAdvices[AspectContainer::STATIC_INIT_PREFIX]['root'][$advisorId] = $advisor->getAdvice();
160		}
161		}
162		}
163
164		// Check methods in class only for method filters
165	2	if ($filterKind & Aop\PointFilter::KIND_METHOD) {
		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...
166
167	1	$mask = ReflectionMethod::IS_PUBLIC \| ReflectionMethod::IS_PROTECTED;
168	1	foreach ($class->getMethods($mask) as $method) {
169		/** @var $method ReflectionMethod\| */
170	1	if ($filter->matches($method, $class)) {
171	1	$prefix = $method->isStatic() ? AspectContainer::STATIC_METHOD_PREFIX : AspectContainer::METHOD_PREFIX;
172	1	$classAdvices[$prefix][$method->name][$advisorId] = $advisor->getAdvice();
173		}
174		}
175		}
176
177		// Check properties in class only for property filters
178	2	if ($filterKind & Aop\PointFilter::KIND_PROPERTY) {
179	1	$mask = ReflectionProperty::IS_PUBLIC \| ReflectionProperty::IS_PROTECTED;
180	1	foreach ($class->getProperties($mask) as $property) {
181		/** @var $property ReflectionProperty */
182	1	if ($filter->matches($property, $class) && !$property->isStatic()) {
183	1	$classAdvices[AspectContainer::PROPERTY_PREFIX][$property->name][$advisorId] = $advisor->getAdvice();
184		}
185		}
186		}
187
188	2	return $classAdvices;
189		}
190
191		/**
192		* Returns list of introduction advices from advisor
193		*
194		* @param ParsedReflectionClass $class Class to inject advices
195		* @param Aop\IntroductionAdvisor $advisor Advisor for class
196		* @param string $advisorId Identifier of advisor
197		*
198		* @return array
199		*/
200		private function getIntroductionFromAdvisor(
201		ParsedReflectionClass $class,
202		Aop\IntroductionAdvisor $advisor,
203		$advisorId)
		0 ignored issues – show Coding Style introduced 2016-02-13 15:18 UTC by Report Bug Copy Issue Report The closing parenthesis of a multi-line function declaration must be on a new line Loading history...
204		{
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report The closing parenthesis and the opening brace of a multi-line function declaration must be on the same line Loading history...
205		$classAdvices = [];
206		// Do not make introduction for traits
207		if ($class->isTrait()) {
208		return $classAdvices;
209		}
210
211		$advice = $advisor->getAdvice();
212
213		$classAdvices[AspectContainer::INTRODUCTION_TRAIT_PREFIX][$advisorId] = $advice;
214
215		return $classAdvices;
216		}
217
218		/**
219		* Returns list of function advices for specific namespace
220		*
221		* @param ReflectionFileNamespace $namespace
222		* @param Aop\PointcutAdvisor $advisor Advisor for class
223		* @param string $advisorId Identifier of advisor
224		* @param Aop\PointFilter $pointcut Filter for points
225		*
226		* @return array
227		*/
228		private function getFunctionAdvicesFromAdvisor(
229		ReflectionFileNamespace $namespace,
230		Aop\PointcutAdvisor $advisor,
231		$advisorId,
232		Aop\PointFilter $pointcut)
		0 ignored issues – show Coding Style introduced 2016-02-13 15:18 UTC by Report Bug Copy Issue Report The closing parenthesis of a multi-line function declaration must be on a new line Loading history...
233		{
		0 ignored issues – show Coding Style introduced 2016-02-28 20:13 UTC by Report Bug Copy Issue Report The closing parenthesis and the opening brace of a multi-line function declaration must be on the same line Loading history...
234		$functions = [];
235		$advices = [];
236
237		$listOfGlobalFunctions = get_defined_functions();
238		foreach ($listOfGlobalFunctions['internal'] as $functionName) {
239		$functions[$functionName] = new NamespacedReflectionFunction($functionName, $namespace->getName());
240		}
241
242		foreach ($functions as $functionName=>$function) {
		0 ignored issues – show Coding Style introduced 2016-02-13 15:18 UTC by Report Bug Copy Issue Report Expected 1 space before "=>"; 0 found Loading history... Coding Style introduced 2016-02-13 15:18 UTC by Report Bug Copy Issue Report Expected 1 space after "=>"; 0 found Loading history...
243		if ($pointcut->matches($function, $namespace)) {
244		$advices[AspectContainer::FUNCTION_PREFIX][$functionName][$advisorId] = $advisor->getAdvice();
245		}
246		}
247
248		return $advices;
249		}
250		}
251

goaop / framework

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

AdviceMatcher::getAdvicesForClass() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like