AbstractAspectLoaderExtension::makeLexicalAnalyze() - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/2.x'" - goaop/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bfa80e...3adc88 )

by Alexander

created 2017-08-17 14:40 UTC

makeLexicalAnalyze() B

↳ Parent: AbstractAspectLoaderExtension

Complexity

Conditions	5
Paths	3

Size

Total Lines	23
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
dl	0
loc	23
c	0
b	0
f	0
ccs	0
cts	16
cp	0
rs	8.5906
cc	5
eloc	18
nc	3
nop	3
crap	30

<?php
declare(strict_types = 1);
/*
 * 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 Dissect\Lexer\Exception\RecognitionException;
use Dissect\Lexer\Lexer;
use Dissect\Lexer\TokenStream\TokenStream;
use Dissect\Parser\Exception\UnexpectedTokenException;
use Dissect\Parser\Parser;
use Go\Aop\Aspect;
use Go\Aop\Pointcut;
use Go\Aop\PointFilter;
use Go\Lang\Annotation;
use ReflectionMethod;
use ReflectionProperty;

/**
 * Abstract aspect loader
 */
abstract class AbstractAspectLoaderExtension implements AspectLoaderExtension
{

    /**
     * Instance of pointcut lexer
     *
     * @var Lexer
     */
    protected $pointcutLexer;

    /**
     * Instance of pointcut parser
     *
     * @var Parser
     */
    protected $pointcutParser;

    /**
     * Default initialization of dependencies
     *
     * @param Lexer $pointcutLexer Instance of pointcut lexer
     * @param Parser $pointcutParser Instance of pointcut parser
     */
    public function __construct(Lexer $pointcutLexer, Parser $pointcutParser)
    {
        $this->pointcutLexer  = $pointcutLexer;
        $this->pointcutParser = $pointcutParser;
    }

    /**
     * General method for parsing pointcuts
     *
     * @param Aspect $aspect Instance of current aspect
     * @param Annotation\BaseAnnotation|Annotation\BaseInterceptor $metaInformation
     * @param mixed|\ReflectionMethod|\ReflectionProperty $reflection Reflection of point
     *
     * @throws \UnexpectedValueException if there was an error during parsing
     * @return Pointcut|PointFilter
     */
    protected function parsePointcut(Aspect $aspect, $reflection, $metaInformation) : PointFilter
    {
        $stream = $this->makeLexicalAnalyze($aspect, $reflection, $metaInformation);

        return $this->parseTokenStream($reflection, $metaInformation, $stream);
    }

    /**
     * Performs lexical analyze of pointcut
     *
     * @param Aspect $aspect Instance of aspect
     * @param ReflectionMethod|ReflectionProperty $reflection
     * @param Annotation\BaseAnnotation $metaInformation
     *
     * @return TokenStream
     * @throws \UnexpectedValueException
     */
    protected function makeLexicalAnalyze(Aspect $aspect, $reflection, $metaInformation) : TokenStream
    {
        try {
            $resolvedThisPointcut = str_replace('$this', get_class($aspect), $metaInformation->value);
            $stream = $this->pointcutLexer->lex($resolvedThisPointcut);
        } catch (RecognitionException $e) {
            $message = "Can not recognize the lexical structure `%s` before %s, defined in %s:%d";
            $message = sprintf(
                $message,
                $metaInformation->value,
                (isset($reflection->class) ? $reflection->class . '->' : '') . $reflection->name,
                method_exists($reflection, 'getFileName')
                    ? $reflection->getFileName()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    : $reflection->getDeclaringClass()->getFileName(),
                method_exists($reflection, 'getStartLine')
                    ? $reflection->getStartLine()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    : 0
            );
            throw new \UnexpectedValueException($message, 0, $e);
        }

        return $stream;
    }

    /**
     * Performs parsing of pointcut
     *
     * @param ReflectionMethod|ReflectionProperty $reflection
     * @param Annotation\BaseAnnotation $metaInformation
     * @param TokenStream $stream
     * @return Pointcut|PointFilter
     *
     * @throws \UnexpectedValueException
     */
    protected function parseTokenStream($reflection, $metaInformation, TokenStream $stream) : PointFilter
    {
        try {
            $pointcut = $this->pointcutParser->parse($stream);
        } catch (UnexpectedTokenException $e) {
            $token   = $e->getToken();
            $message = "Unexpected token %s in the `%s` before %s, defined in %s:%d." . PHP_EOL;
            $message .= "Expected one of: %s";
            $message = sprintf(
                $message,
                $token->getValue(),
                $metaInformation->value,
                (isset($reflection->class) ? $reflection->class . '->' : '') . $reflection->name,
                method_exists($reflection, 'getFileName')
                    ? $reflection->getFileName()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    : $reflection->getDeclaringClass()->getFileName(),
                method_exists($reflection, 'getStartLine')
                    ? $reflection->getStartLine()
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    : 0,
                implode(', ', $e->getExpected())
            );
            throw new \UnexpectedValueException($message, 0, $e);
        }

        return $pointcut;
    }
}


1		<?php
2		declare(strict_types = 1);
3		/*
4		* Go! AOP framework
5		*
6		* @copyright Copyright 2012, Lisachenko Alexander <[email protected]>
7		*
8		* This source file is subject to the license that is bundled
9		* with this source code in the file LICENSE.
10		*/
11
12		namespace Go\Core;
13
14		use Dissect\Lexer\Exception\RecognitionException;
15		use Dissect\Lexer\Lexer;
16		use Dissect\Lexer\TokenStream\TokenStream;
17		use Dissect\Parser\Exception\UnexpectedTokenException;
18		use Dissect\Parser\Parser;
19		use Go\Aop\Aspect;
20		use Go\Aop\Pointcut;
21		use Go\Aop\PointFilter;
22		use Go\Lang\Annotation;
23		use ReflectionMethod;
24		use ReflectionProperty;
25
26		/**
27		* Abstract aspect loader
28		*/
29		abstract class AbstractAspectLoaderExtension implements AspectLoaderExtension
30		{
31
32		/**
33		* Instance of pointcut lexer
34		*
35		* @var Lexer
36		*/
37		protected $pointcutLexer;
38
39		/**
40		* Instance of pointcut parser
41		*
42		* @var Parser
43		*/
44		protected $pointcutParser;
45
46		/**
47		* Default initialization of dependencies
48		*
49		* @param Lexer $pointcutLexer Instance of pointcut lexer
50		* @param Parser $pointcutParser Instance of pointcut parser
51		*/
52	2	public function __construct(Lexer $pointcutLexer, Parser $pointcutParser)
53		{
54	2	$this->pointcutLexer = $pointcutLexer;
55	2	$this->pointcutParser = $pointcutParser;
56	2	}
57
58		/**
59		* General method for parsing pointcuts
60		*
61		* @param Aspect $aspect Instance of current aspect
62		* @param Annotation\BaseAnnotation\|Annotation\BaseInterceptor $metaInformation
63		* @param mixed\|\ReflectionMethod\|\ReflectionProperty $reflection Reflection of point
64		*
65		* @throws \UnexpectedValueException if there was an error during parsing
66		* @return Pointcut\|PointFilter
67		*/
68		protected function parsePointcut(Aspect $aspect, $reflection, $metaInformation) : PointFilter
69		{
70		$stream = $this->makeLexicalAnalyze($aspect, $reflection, $metaInformation);
71
72		return $this->parseTokenStream($reflection, $metaInformation, $stream);
73		}
74
75		/**
76		* Performs lexical analyze of pointcut
77		*
78		* @param Aspect $aspect Instance of aspect
79		* @param ReflectionMethod\|ReflectionProperty $reflection
80		* @param Annotation\BaseAnnotation $metaInformation
81		*
82		* @return TokenStream
83		* @throws \UnexpectedValueException
84		*/
85		protected function makeLexicalAnalyze(Aspect $aspect, $reflection, $metaInformation) : TokenStream
86		{
87		try {
88		$resolvedThisPointcut = str_replace('$this', get_class($aspect), $metaInformation->value);
89		$stream = $this->pointcutLexer->lex($resolvedThisPointcut);
90		} catch (RecognitionException $e) {
91		$message = "Can not recognize the lexical structure `%s` before %s, defined in %s:%d";
92		$message = sprintf(
93		$message,
94		$metaInformation->value,
95		(isset($reflection->class) ? $reflection->class . '->' : '') . $reflection->name,
96		method_exists($reflection, 'getFileName')
97		? $reflection->getFileName()
		0 ignored issues – show Bug introduced 2015-11-22 20:20 UTC by Report Bug Copy Issue Report The method `getFileName` does only exist in `ReflectionMethod`, but not in `ReflectionProperty`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
98		: $reflection->getDeclaringClass()->getFileName(),
99		method_exists($reflection, 'getStartLine')
100		? $reflection->getStartLine()
		0 ignored issues – show Bug introduced 2015-11-22 20:20 UTC by Report Bug Copy Issue Report The method `getStartLine` does only exist in `ReflectionMethod`, but not in `ReflectionProperty`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
101		: 0
102		);
103		throw new \UnexpectedValueException($message, 0, $e);
104		}
105
106		return $stream;
107		}
108
109		/**
110		* Performs parsing of pointcut
111		*
112		* @param ReflectionMethod\|ReflectionProperty $reflection
113		* @param Annotation\BaseAnnotation $metaInformation
114		* @param TokenStream $stream
115		* @return Pointcut\|PointFilter
116		*
117		* @throws \UnexpectedValueException
118		*/
119		protected function parseTokenStream($reflection, $metaInformation, TokenStream $stream) : PointFilter
120		{
121		try {
122		$pointcut = $this->pointcutParser->parse($stream);
123		} catch (UnexpectedTokenException $e) {
124		$token = $e->getToken();
125		$message = "Unexpected token %s in the `%s` before %s, defined in %s:%d." . PHP_EOL;
126		$message .= "Expected one of: %s";
127		$message = sprintf(
128		$message,
129		$token->getValue(),
130		$metaInformation->value,
131		(isset($reflection->class) ? $reflection->class . '->' : '') . $reflection->name,
132		method_exists($reflection, 'getFileName')
133		? $reflection->getFileName()
		0 ignored issues – show Bug introduced 2015-11-22 20:20 UTC by Report Bug Copy Issue Report The method `getFileName` does only exist in `ReflectionMethod`, but not in `ReflectionProperty`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
134		: $reflection->getDeclaringClass()->getFileName(),
135		method_exists($reflection, 'getStartLine')
136		? $reflection->getStartLine()
		0 ignored issues – show Bug introduced 2015-11-22 20:20 UTC by Report Bug Copy Issue Report The method `getStartLine` does only exist in `ReflectionMethod`, but not in `ReflectionProperty`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
137		: 0,
138		implode(', ', $e->getExpected())
139		);
140		throw new \UnexpectedValueException($message, 0, $e);
141		}
142
143		return $pointcut;
144		}
145		}
146

goaop / framework

Push — master ( bfa80e...3adc88 )

makeLexicalAnalyze() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like