Go\Core\IntroductionAspectExtension

Complexity

Total Complexity

7

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	7

Test Coverage

Coverage

7.41%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getKind()	0	4	1
A	getTargets()	0	4	1
A	supports()	0	6	2
B	load()	0	30	3

<?php
declare(strict_types = 1);
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2012, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Core;

use Go\Aop\Advisor;
use Go\Aop\Aspect;
use Go\Aop\Framework;
use Go\Aop\Pointcut;
use Go\Aop\Support;
use Go\Lang\Annotation;
use ReflectionProperty;
use Reflector;

/**
 * Introduction aspect extension
 */
class IntroductionAspectExtension extends AbstractAspectLoaderExtension
{

    /**
     * Introduction aspect loader works with annotations from aspect
     *
     * For extension that works with annotations additional metaInformation will be passed
     *
     * @return string
     */
    public function getKind() : string
    {
        return self::KIND_ANNOTATION;
    }

    /**
     * Introduction aspect loader works only with properties of aspect
     */
    public function getTargets() : array
    {
        return [self::TARGET_PROPERTY];
    }

    /**
     * Checks if loader is able to handle specific point of aspect
     *
     * @param Aspect $aspect Instance of aspect
     * @param mixed|\ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflection Reflection of point
     * @param mixed|null $metaInformation Additional meta-information, e.g. annotation for method
     *
     * @return boolean true if extension is able to create an advisor from reflection and metaInformation
     */
    public function supports(Aspect $aspect, $reflection, $metaInformation = null) : bool
    {
        return
            ($metaInformation instanceof Annotation\DeclareParents) ||
            ($metaInformation instanceof Annotation\DeclareError);
    }

    /**
     * Loads definition from specific point of aspect into the container
     *
     * @param Aspect $aspect Instance of aspect
     * @param Reflector|ReflectionProperty $reflection Reflection of point
     * @param mixed|null $metaInformation Additional meta-information
     *
     * @throws \UnexpectedValueException
     *
     * @return array|Pointcut[]|Advisor[]
     */
    public function load(Aspect $aspect, Reflector $reflection, $metaInformation = null) : array
    {
        $loadedItems = [];
        $pointcut    = $this->parsePointcut($aspect, $reflection, $metaInformation);
        $propertyId  = $reflection->class . '->' . $reflection->name;

Accessing class on the interface Reflector suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing name on the interface Reflector suggest that you code against a concrete implementation. How about adding an instanceof check?

        switch (true) {
            case ($metaInformation instanceof Annotation\DeclareParents):
                $interface = $metaInformation->interface;
                $implement = $metaInformation->defaultImpl;
                $advice    = new Framework\TraitIntroductionInfo($interface, $implement);
                $advisor   = new Support\DeclareParentsAdvisor($pointcut->getClassFilter(), $advice);
                $loadedItems[$propertyId] = $advisor;
                break;

            case ($metaInformation instanceof Annotation\DeclareError):
                $reflection->setAccessible(true);

It seems like you code against a concrete implementation and not the interface Reflector as the method setAccessible() does only exist in the following implementations of said interface: Doctrine\Common\Reflection\RuntimePublicReflectionProperty, Doctrine\Common\Reflection\StaticReflectionMethod, Doctrine\Common\Reflection\StaticReflectionProperty, Doctrine\ORM\Mapping\ReflectionEmbeddedProperty, Go\Aop\Support\AnnotatedReflectionMethod, Go\ParserReflection\ReflectionMethod, Go\ParserReflection\ReflectionProperty, ReflectionMethod, ReflectionProperty.

                $message = $reflection->getValue($aspect);

It seems like you code against a concrete implementation and not the interface Reflector as the method getValue() does only exist in the following implementations of said interface: Doctrine\Common\Reflection\RuntimePublicReflectionProperty, Doctrine\Common\Reflection\StaticReflectionProperty, Doctrine\ORM\Mapping\ReflectionEmbeddedProperty, Go\ParserReflection\ReflectionProperty, ReflectionProperty.

                $level   = $metaInformation->level;
                $advice  = new Framework\DeclareErrorInterceptor($message, $level, $metaInformation->value);
                $loadedItems[$propertyId] = new Support\DefaultPointcutAdvisor($pointcut, $advice);

$pointcut of type object<Go\Aop\PointFilter> is not a sub-type of object<Go\Aop\Pointcut>. It seems like you assume a child interface of the interface Go\Aop\PointFilter to be always present.

                break;

            default:
                throw new \UnexpectedValueException("Unsupported pointcut class: " . get_class($pointcut));

Blank line found at end of control structure

        }

        return $loadedItems;
    }
}