AsyncTable::hasClassAnnotation() - Code Metrics - WyriHaximus/cakephp-async-orm - Measure and Improve Code Quality continuously with Scrutinizer

AsyncTable::hasClassAnnotation() A
last analyzed 2019-04-23 00:19 UTC

↳ Parent: AsyncTable

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php declare(strict_types=1);

namespace WyriHaximus\React\Cake\Orm;

use Cake\ORM\Query;
use Cake\ORM\TableRegistry;
use Doctrine\Common\Annotations\AnnotationReader;
use phpDocumentor\Reflection\DocBlock;
use phpDocumentor\Reflection\DocBlockFactory;
use React\Promise\PromiseInterface;
use WyriHaximus\React\Cake\Orm\Annotations\Async;
use WyriHaximus\React\Cake\Orm\Annotations\Sync;

trait AsyncTable
{
    /**
     * @var Pool
     */
    private $pool;

    /**
     * @var string
     */
    private $tableName;

    /**
     * @var AnnotationReader
     */
    private $annotationReader;

    /**
     * @var \ReflectionClass
     */
    private $reflectionClass;

    /**
     * @param Pool   $pool
     * @param string $tableName
     * @param mixed  $tableClass
     */
    public function setUpAsyncTable(Pool $pool, $tableName, $tableClass)
    {
        $this->pool = $pool;
        $this->tableName = $tableName;
        $this->annotationReader = new AnnotationReader();
        $this->reflectionClass = new \ReflectionClass($tableClass);
    }

    /**
     * @param $function
     * @param  array            $arguments
     * @return PromiseInterface
     */
    protected function callAsyncOrSync($function, $arguments)
    {
        if ($this->pool === null) {
            return (new $this->tableName())->$function(...$arguments);
        }

        if (
            $this->returnsQuery($function) ||
            $this->hasMethodAnnotation($function, Async::class) ||
            (
                $this->hasClassAnnotation(Async::class) &&
                $this->hasNoMethodAnnotation($function)
            ) ||
            strpos(strtolower($function), 'save') === 0 ||
            strpos(strtolower($function), 'find') === 0 ||
            strpos(strtolower($function), 'fetch') === 0 ||
            strpos(strtolower($function), 'retrieve') === 0
        ) {
            return $this->callAsync($function, $arguments);
        }

        return $this->callSync($function, $arguments);
    }

    /**
     * @param $function
     * @param  array            $arguments
     * @return PromiseInterface
     */
    private function callSync($function, array $arguments = [])
    {
        $table = TableRegistry::get($this->tableName);

        if (isset(class_uses($table)[TableRegistryTrait::class])) {
            $table->setRegistry(AsyncTableRegistry::class);

        }

        return \React\Promise\resolve(
            call_user_func_array(
                [
                    $table,
                    $function,
                ],
                $arguments
            )
        );
    }

    /**
     * @param $function
     * @param  array            $arguments
     * @return PromiseInterface
     */
    private function callAsync($function, array $arguments = [])
    {
        $unSerialize = function ($input) {
            if (is_string($input)) {
                return unserialize($input);
            }

            return $input;
        };

        return $this->
            pool->
            call(get_parent_class($this), $this->tableName, $function, $arguments)->
            then($unSerialize, $unSerialize, $unSerialize)
        ;
    }

    /**
     * @param $class
     * @return bool
     */
    private function hasClassAnnotation($class)
    {
        return is_a($this->annotationReader->getClassAnnotation($this->reflectionClass, $class), $class);
    }

    /**
     * @param $method
     * @param $class
     * @return bool
     */
    private function hasMethodAnnotation($method, $class)
    {
        $methodReflection = $this->reflectionClass->getMethod($method);

        return is_a($this->annotationReader->getMethodAnnotation($methodReflection, $class), $class);
    }

    /**
     * @param $method
     * @return bool
     */
    private function hasNoMethodAnnotation($method)
    {
        $methodReflection = $this->reflectionClass->getMethod($method);

        return (
            $this->annotationReader->getMethodAnnotation($methodReflection, Async::class) === null &&
            $this->annotationReader->getMethodAnnotation($methodReflection, Sync::class) === null
        );
    }

    /**
     * @param $function
     * @return bool
     */
    private function returnsQuery($function)
    {
        $docBlockContents = $this->reflectionClass->getMethod($function)->getDocComment();
        if (!is_string($docBlockContents)) {
            return false;
        }

        $docBlock = $this->getDocBlock($docBlockContents);
        foreach ($docBlock->getTags() as $tag) {
            if ($tag->getName() === 'return' && ltrim($tag->getType(), '\\') == Query::class) {
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.
    }
}
                return true;
            }
        }

        return false;
    }

    /**
     * @param $docBlockContents
     * @return DocBlock
     */
    private function getDocBlock($docBlockContents)
    {
        if (class_exists('phpDocumentor\Reflection\DocBlockFactory')) {
            return DocBlockFactory::createInstance()->create($docBlockContents);
        }

        return new DocBlock($docBlockContents);
    }
}


1			<?php declare(strict_types=1);
2
3			namespace WyriHaximus\React\Cake\Orm;
4
5			use Cake\ORM\Query;
6			use Cake\ORM\TableRegistry;
7			use Doctrine\Common\Annotations\AnnotationReader;
8			use phpDocumentor\Reflection\DocBlock;
9			use phpDocumentor\Reflection\DocBlockFactory;
10			use React\Promise\PromiseInterface;
11			use WyriHaximus\React\Cake\Orm\Annotations\Async;
12			use WyriHaximus\React\Cake\Orm\Annotations\Sync;
13
14			trait AsyncTable
15			{
16			/**
17			* @var Pool
18			*/
19			private $pool;
20
21			/**
22			* @var string
23			*/
24			private $tableName;
25
26			/**
27			* @var AnnotationReader
28			*/
29			private $annotationReader;
30
31			/**
32			* @var \ReflectionClass
33			*/
34			private $reflectionClass;
35
36			/**
37			* @param Pool $pool
38			* @param string $tableName
39			* @param mixed $tableClass
40			*/
41			public function setUpAsyncTable(Pool $pool, $tableName, $tableClass)
42			{
43			$this->pool = $pool;
44			$this->tableName = $tableName;
45			$this->annotationReader = new AnnotationReader();
46			$this->reflectionClass = new \ReflectionClass($tableClass);
47			}
48
49			/**
50			* @param $function
51			* @param array $arguments
52			* @return PromiseInterface
53			*/
54			protected function callAsyncOrSync($function, $arguments)
55			{
56			if ($this->pool === null) {
57			return (new $this->tableName())->$function(...$arguments);
58			}
59
60			if (
61			$this->returnsQuery($function) \|\|
62			$this->hasMethodAnnotation($function, Async::class) \|\|
63			(
64			$this->hasClassAnnotation(Async::class) &&
65			$this->hasNoMethodAnnotation($function)
66			) \|\|
67			strpos(strtolower($function), 'save') === 0 \|\|
68			strpos(strtolower($function), 'find') === 0 \|\|
69			strpos(strtolower($function), 'fetch') === 0 \|\|
70			strpos(strtolower($function), 'retrieve') === 0
71			) {
72			return $this->callAsync($function, $arguments);
73			}
74
75			return $this->callSync($function, $arguments);
76			}
77
78			/**
79			* @param $function
80			* @param array $arguments
81			* @return PromiseInterface
82			*/
83			private function callSync($function, array $arguments = [])
84			{
85			$table = TableRegistry::get($this->tableName);
			0 ignored issues – show Deprecated Code introduced 2018-10-21 13:59 UTC by Report Bug Copy Issue Report The method `Cake\ORM\TableRegistry::get()` has been deprecated with message: 3.6.0 Use \Cake\ORM\Locator\TableLocator::get() instead. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
86			if (isset(class_uses($table)[TableRegistryTrait::class])) {
87			$table->setRegistry(AsyncTableRegistry::class);
			0 ignored issues – show Bug introduced 2018-10-21 13:59 UTC by Report Bug Copy Issue Report The method `setRegistry()` does not exist on `Cake\ORM\Table`. Did you maybe mean `setRegistryAlias()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
88			}
89
90			return \React\Promise\resolve(
91			call_user_func_array(
92			[
93			$table,
94			$function,
95			],
96			$arguments
97			)
98			);
99			}
100
101			/**
102			* @param $function
103			* @param array $arguments
104			* @return PromiseInterface
105			*/
106			private function callAsync($function, array $arguments = [])
107			{
108			$unSerialize = function ($input) {
109			if (is_string($input)) {
110			return unserialize($input);
111			}
112
113			return $input;
114			};
115
116			return $this->
117			pool->
118			call(get_parent_class($this), $this->tableName, $function, $arguments)->
119			then($unSerialize, $unSerialize, $unSerialize)
120			;
121			}
122
123			/**
124			* @param $class
125			* @return bool
126			*/
127			private function hasClassAnnotation($class)
128			{
129			return is_a($this->annotationReader->getClassAnnotation($this->reflectionClass, $class), $class);
130			}
131
132			/**
133			* @param $method
134			* @param $class
135			* @return bool
136			*/
137			private function hasMethodAnnotation($method, $class)
138			{
139			$methodReflection = $this->reflectionClass->getMethod($method);
140
141			return is_a($this->annotationReader->getMethodAnnotation($methodReflection, $class), $class);
142			}
143
144			/**
145			* @param $method
146			* @return bool
147			*/
148			private function hasNoMethodAnnotation($method)
149			{
150			$methodReflection = $this->reflectionClass->getMethod($method);
151
152			return (
153			$this->annotationReader->getMethodAnnotation($methodReflection, Async::class) === null &&
154			$this->annotationReader->getMethodAnnotation($methodReflection, Sync::class) === null
155			);
156			}
157
158			/**
159			* @param $function
160			* @return bool
161			*/
162			private function returnsQuery($function)
163			{
164			$docBlockContents = $this->reflectionClass->getMethod($function)->getDocComment();
165			if (!is_string($docBlockContents)) {
166			return false;
167			}
168
169			$docBlock = $this->getDocBlock($docBlockContents);
170			foreach ($docBlock->getTags() as $tag) {
171			if ($tag->getName() === 'return' && ltrim($tag->getType(), '\\') == Query::class) {
			0 ignored issues – show Bug introduced 2016-03-27 22:35 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `phpDocumentor\Reflection\DocBlock\Tag` as the method `getType()` does only exist in the following implementations of said interface: `phpDocumentor\Reflection\DocBlock\Tags\Param`, `phpDocumentor\Reflection\DocBlock\Tags\Property`, `phpDocumentor\Reflection...Block\Tags\PropertyRead`, `phpDocumentor\Reflection...lock\Tags\PropertyWrite`, `phpDocumentor\Reflection\DocBlock\Tags\Return_`, `phpDocumentor\Reflection\DocBlock\Tags\Throws`, `phpDocumentor\Reflection\DocBlock\Tags\Var_`. 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...
172			return true;
173			}
174			}
175
176			return false;
177			}
178
179			/**
180			* @param $docBlockContents
181			* @return DocBlock
182			*/
183			private function getDocBlock($docBlockContents)
184			{
185			if (class_exists('phpDocumentor\Reflection\DocBlockFactory')) {
186			return DocBlockFactory::createInstance()->create($docBlockContents);
187			}
188
189			return new DocBlock($docBlockContents);
190			}
191			}
192

WyriHaximus / cakephp-async-orm

AsyncTable::hasClassAnnotation() A last analyzed 2019-04-23 00:19 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

AsyncTable::hasClassAnnotation() A
last analyzed 2019-04-23 00:19 UTC