WyriHaximus\React\Cake\Orm\AsyncTable

Complexity

Total Complexity

26

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUpAsyncTable()	0	7	1
C	callAsyncOrSync()	0	23	10
A	callSync()	0	19	2
A	callAsync()	0	15	2
A	hasClassAnnotation()	0	4	1
A	hasMethodAnnotation()	0	5	1
A	hasNoMethodAnnotation()	0	8	2
B	returnsQuery()	0	16	5
A	getDocBlock()	0	8	2

<?php

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
     */
    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(md5($this->tableName), [
            'className' => $this->tableName,
            'table' => 'screenshots',
        ]);
        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) {

It seems like you code against a specific sub-type and not the parent class phpDocumentor\Reflection\DocBlock\Tag as the method getType() does only exist in the following sub-classes of phpDocumentor\Reflection\DocBlock\Tag: phpDocumentor\Reflection\DocBlock\Tag\MethodTag, phpDocumentor\Reflection\DocBlock\Tag\ParamTag, phpDocumentor\Reflection\DocBlock\Tag\PropertyReadTag, phpDocumentor\Reflection\DocBlock\Tag\PropertyTag, phpDocumentor\Reflection\DocBlock\Tag\PropertyWriteTag, phpDocumentor\Reflection\DocBlock\Tag\ReturnTag, phpDocumentor\Reflection\DocBlock\Tag\ThrowsTag, phpDocumentor\Reflection\DocBlock\Tag\VarTag. Maybe you want to instanceof check for one of these explicitly?

                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);
    }
}