Ray\Aop\Bind

Complexity

Total Complexity

21

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	19
Bugs	4	Features	3

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	annotatedMethodsMatch()	0	7	2
A	annotatedMethodMatch()	0	17	4
A	annotatedMethodMatchBind()	0	12	3
A	getBindings()	0	4	1
A	toString()	0	8	1
A	getAnnotationPointcuts()	0	12	3
A	onionOrderMatch()	0	17	3
A	bind()	0	7	1
A	bindInterceptors()	0	9	2

<?php
/**
 * This file is part of the Ray.Aop package
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace Ray\Aop;

use Doctrine\Common\Annotations\AnnotationReader;

final class Bind implements BindInterface
{
    /**
     * @var array
     */
    private $bindings = [];

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

    public function __construct()
    {
        $this->reader = new AnnotationReader();
    }

    /**
     * @param string $class
     * @param array  $pointcuts
     *
     * @return $this
     */
    public function bind($class, array $pointcuts)

Using PHP4-style constructors that are named like the class is not recommend; better use the more explicit __construct method.

    {
        $pointcuts = $this->getAnnotationPointcuts($pointcuts);
        $this->annotatedMethodsMatch(new \ReflectionClass($class), $pointcuts);

        return $this;
    }

    /**
     * @param ReflectionClass $class
     * @param Pointcut[]      $pointcuts
     */
    private function annotatedMethodsMatch(\ReflectionClass $class, array &$pointcuts)
    {
        $methods = $class->getMethods(ReflectionMethod::IS_PUBLIC);
        foreach ($methods as $method) {
            $this->annotatedMethodMatch($class, $method, $pointcuts);
        }
    }

    /**
     * @param ReflectionClass  $class
     * @param ReflectionMethod $method
     * @param Pointcut[]       $pointcuts
     */
    private function annotatedMethodMatch(\ReflectionClass $class, \ReflectionMethod $method, array $pointcuts)
    {
        $annotations = $this->reader->getMethodAnnotations($method);
        // priority bind
        foreach ($pointcuts as $key => $pointcut) {
            if ($pointcut instanceof PriorityPointcut) {
                $this->annotatedMethodMatchBind($class, $method, $pointcut);
                unset($pointcuts[$key]);
            }
        }
        $onion = $this->onionOrderMatch($class, $method, $pointcuts, $annotations);

        // default binding
        foreach ($onion as $pointcut) {
            $this->annotatedMethodMatchBind($class, $method, $pointcut);
        }
    }

    /**
     * @param ReflectionClass  $class
     * @param ReflectionMethod $method
     * @param PointCut         $pointCut
     */
    private function annotatedMethodMatchBind(\ReflectionClass $class, \ReflectionMethod $method, PointCut $pointCut)
    {
        $isMethodMatch = $pointCut->methodMatcher->matchesMethod($method, $pointCut->methodMatcher->getArguments());
        if (! $isMethodMatch) {
            return;
        }
        $isClassMatch = $pointCut->classMatcher->matchesClass($class, $pointCut->classMatcher->getArguments());
        if (! $isClassMatch) {
            return;
        }
        $this->bindInterceptors($method->name, $pointCut->interceptors);
    }

    /**
     * {@inheritdoc}
     */
    public function bindInterceptors($method, array $interceptors)
    {
        $this->bindings[$method] = !isset($this->bindings[$method]) ? $interceptors : array_merge(
            $this->bindings[$method],
            $interceptors
        );

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getBindings()
    {
        return $this->bindings;
    }

    /**
     * {@inheritdoc}
     */
    public function toString($salt)
    {
        $shortHash = function ($data) {
            return strtr(rtrim(base64_encode(pack('H*', sprintf('%u', crc32(serialize($data))))), '='), '+/', '-_');
        };

        return $shortHash(serialize($this->bindings) . $salt);
    }

    /**
     * @param Pointcut[] $pointcuts
     *
     * @return Pointcut[]
     */
    public function getAnnotationPointcuts(array &$pointcuts)
    {
        $keyPointcuts = [];
        foreach ($pointcuts as $key => $pointcut) {
            if ($pointcut->methodMatcher instanceof AnnotatedMatcher) {
                $key = $pointcut->methodMatcher->annotation;
            }
            $keyPointcuts[$key] = $pointcut;
        }

        return $keyPointcuts;
    }

    /**
     * @param ReflectionClass  $class
     * @param ReflectionMethod $method
     * @param Pointcut[]       $pointcuts
     * @param array            $annotations
     *
     * @return array
     */
    private function onionOrderMatch(
        \ReflectionClass $class,
        \ReflectionMethod $method,
        array $pointcuts,
        $annotations
    ) {
        // method bind in annotation order
        foreach ($annotations as $annotation) {
            $annotationIndex = get_class($annotation);
            if (isset($pointcuts[$annotationIndex])) {
                $this->annotatedMethodMatchBind($class, $method, $pointcuts[$annotationIndex]);
                unset($pointcuts[$annotationIndex]);
            }
        }

        return $pointcuts;
    }
}