Reader::getMethodAnnotations() - Code Metrics - marcioAlmada/annotations - Measure and Improve Code Quality continuously with Scrutinizer

Reader::getMethodAnnotations() A
last analyzed 2019-11-13 10:11 UTC

↳ Parent: Reader

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2

<?php

namespace Minime\Annotations;

use Minime\Annotations\Cache\ArrayCache;
use Minime\Annotations\Interfaces\CacheInterface;
use Minime\Annotations\Interfaces\ParserInterface;
use Minime\Annotations\Interfaces\ReaderInterface;
use Minime\Annotations\Reflector\ReflectionConst;

/**
 * This class is the primary entry point to read annotations
 *
 * @package Minime\Annotations
 */
class Reader implements ReaderInterface
{
    /**
     * @var \Minime\Annotations\Interfaces\ParserInterface
     */
    protected $parser;

    /**
     * @var \Minime\Annotations\Interfaces\CacheInterface
     */
    protected $cache;

    /**
     * @param \Minime\Annotations\Interfaces\ParserInterface $parser
     */
    public function __construct(ParserInterface $parser, CacheInterface $cache = null)
    {
        $this->setParser($parser);
        $this->setCache($cache);
    }

    /**
     * @param \Minime\Annotations\Interfaces\CacheInterface $cache Cache handler
     */
    public function setCache(CacheInterface $cache = null)
    {
        $this->cache = $cache;
    }

    /**
     * @return \Minime\Annotations\Interfaces\CacheInterface Cache handler
     */
    public function getCache()
    {
        return $this->cache;
    }

    /**
     * @param \Minime\Annotations\Interfaces\ParserInterface $parser
     */
    public function setParser(ParserInterface $parser)
    {
        $this->parser = $parser;
    }

    /**
     * @return \Minime\Annotations\Interfaces\ParserInterface
     */
    public function getParser()
    {
        return $this->parser;
    }

    /**
     * Retrieve all annotations from a given function or closure
     *
     * @param  mixed                                                  $fn Full qualified function name or closure
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     * @throws \ReflectionException                                   If function is not found
     */
    public function getFunctionAnnotations($fn)
    {
        return $this->getAnnotations(new \ReflectionFunction($fn));
    }

    /**
     * Retrieve all annotations from a given class
     *
     * @param  mixed                                                  $class Full qualified class name or object
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     * @throws \ReflectionException                                   If class is not found
     */
    public function getClassAnnotations($class)
    {
        return $this->getAnnotations(new \ReflectionClass($class));
    }

    /**
     * Retrieve all annotations from a given property of a class
     *
     * @param  mixed                                                  $class    Full qualified class name or object
     * @param  string                                                 $property Property name
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     * @throws \ReflectionException                                   If property is undefined
     */
    public function getPropertyAnnotations($class, $property)
    {
        return $this->getAnnotations(new \ReflectionProperty($class, $property));
    }

    /**
     * Retrieve all annotations from a given method of a class
     *
     * @param  mixed                                                  $class  Full qualified class name or object
     * @param  string                                                 $method Method name
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     * @throws \ReflectionException                                   If method is undefined
     */
    public function getMethodAnnotations($class, $method)
    {
        return $this->getAnnotations(new \ReflectionMethod($class, $method));
    }

    /**
     * Retrieve all annotations from a given constant of a class
     *
     * @param  string|object                                          $class fully qualified name or instance of the class
     * @param  string                                                 $const name of the constant
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     */
    public function getConstantAnnotations($class, $const)
    {
        return $this->getAnnotations(new ReflectionConst($class, $const));
    }

    /**
     * Retrieve annotations from docblock of a given reflector
     *
     * @param  \Reflector                                             $Reflection Reflector object
     * @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
     */
    public function getAnnotations(\Reflector $Reflection)
    {
        $doc = $Reflection->getDocComment();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        if ($this->cache) {
            $key = $this->cache->getKey($doc);
            $ast = $this->cache->get($key);
            if (! $ast) {
                $ast = $this->parser->parse($doc);
                $this->cache->set($key, $ast);
            }
        } else {
            $ast = $this->parser->parse($doc);
        }

        return new AnnotationsBag($ast);
    }

    /**
     * Shortcut to create an instance of the default annotations Reader
     * bundled with the default Parser implementation
     *
     * @return \Minime\Annotations\Interfaces\ReaderInterface
     */
    public static function createFromDefaults()
    {
        return new self(new Parser, new ArrayCache);
    }
}


1			<?php
2
3			namespace Minime\Annotations;
4
5			use Minime\Annotations\Cache\ArrayCache;
6			use Minime\Annotations\Interfaces\CacheInterface;
7			use Minime\Annotations\Interfaces\ParserInterface;
8			use Minime\Annotations\Interfaces\ReaderInterface;
9			use Minime\Annotations\Reflector\ReflectionConst;
10
11			/**
12			* This class is the primary entry point to read annotations
13			*
14			* @package Minime\Annotations
15			*/
16			class Reader implements ReaderInterface
17			{
18			/**
19			* @var \Minime\Annotations\Interfaces\ParserInterface
20			*/
21			protected $parser;
22
23			/**
24			* @var \Minime\Annotations\Interfaces\CacheInterface
25			*/
26			protected $cache;
27
28			/**
29			* @param \Minime\Annotations\Interfaces\ParserInterface $parser
30			*/
31			public function __construct(ParserInterface $parser, CacheInterface $cache = null)
32			{
33			$this->setParser($parser);
34			$this->setCache($cache);
35			}
36
37			/**
38			* @param \Minime\Annotations\Interfaces\CacheInterface $cache Cache handler
39			*/
40			public function setCache(CacheInterface $cache = null)
41			{
42			$this->cache = $cache;
43			}
44
45			/**
46			* @return \Minime\Annotations\Interfaces\CacheInterface Cache handler
47			*/
48			public function getCache()
49			{
50			return $this->cache;
51			}
52
53			/**
54			* @param \Minime\Annotations\Interfaces\ParserInterface $parser
55			*/
56			public function setParser(ParserInterface $parser)
57			{
58			$this->parser = $parser;
59			}
60
61			/**
62			* @return \Minime\Annotations\Interfaces\ParserInterface
63			*/
64			public function getParser()
65			{
66			return $this->parser;
67			}
68
69			/**
70			* Retrieve all annotations from a given function or closure
71			*
72			* @param mixed $fn Full qualified function name or closure
73			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
74			* @throws \ReflectionException If function is not found
75			*/
76			public function getFunctionAnnotations($fn)
77			{
78			return $this->getAnnotations(new \ReflectionFunction($fn));
79			}
80
81			/**
82			* Retrieve all annotations from a given class
83			*
84			* @param mixed $class Full qualified class name or object
85			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
86			* @throws \ReflectionException If class is not found
87			*/
88			public function getClassAnnotations($class)
89			{
90			return $this->getAnnotations(new \ReflectionClass($class));
91			}
92
93			/**
94			* Retrieve all annotations from a given property of a class
95			*
96			* @param mixed $class Full qualified class name or object
97			* @param string $property Property name
98			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
99			* @throws \ReflectionException If property is undefined
100			*/
101			public function getPropertyAnnotations($class, $property)
102			{
103			return $this->getAnnotations(new \ReflectionProperty($class, $property));
104			}
105
106			/**
107			* Retrieve all annotations from a given method of a class
108			*
109			* @param mixed $class Full qualified class name or object
110			* @param string $method Method name
111			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
112			* @throws \ReflectionException If method is undefined
113			*/
114			public function getMethodAnnotations($class, $method)
115			{
116			return $this->getAnnotations(new \ReflectionMethod($class, $method));
117			}
118
119			/**
120			* Retrieve all annotations from a given constant of a class
121			*
122			* @param string\|object $class fully qualified name or instance of the class
123			* @param string $const name of the constant
124			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
125			*/
126			public function getConstantAnnotations($class, $const)
127			{
128			return $this->getAnnotations(new ReflectionConst($class, $const));
129			}
130
131			/**
132			* Retrieve annotations from docblock of a given reflector
133			*
134			* @param \Reflector $Reflection Reflector object
135			* @return \Minime\Annotations\Interfaces\AnnotationsBagInterface Annotations collection
136			*/
137			public function getAnnotations(\Reflector $Reflection)
138			{
139			$doc = $Reflection->getDocComment();
			0 ignored issues – show Bug introduced 2016-04-27 11:33 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Reflector` as the method `getDocComment()` does only exist in the following implementations of said interface: `Minime\Annotations\Reflector\ReflectionConst`, `ReflectionClass`, `ReflectionFunction`, `ReflectionFunctionAbstract`, `ReflectionMethod`, `ReflectionObject`, `ReflectionProperty`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
140			if ($this->cache) {
141			$key = $this->cache->getKey($doc);
142			$ast = $this->cache->get($key);
143			if (! $ast) {
144			$ast = $this->parser->parse($doc);
145			$this->cache->set($key, $ast);
146			}
147			} else {
148			$ast = $this->parser->parse($doc);
149			}
150
151			return new AnnotationsBag($ast);
152			}
153
154			/**
155			* Shortcut to create an instance of the default annotations Reader
156			* bundled with the default Parser implementation
157			*
158			* @return \Minime\Annotations\Interfaces\ReaderInterface
159			*/
160			public static function createFromDefaults()
161			{
162			return new self(new Parser, new ArrayCache);
163			}
164			}
165

marcioAlmada / annotations

GitHub Access Token became invalid

Reader::getMethodAnnotations() A last analyzed 2019-11-13 10:11 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

Reader::getMethodAnnotations() A
last analyzed 2019-11-13 10:11 UTC