appserver-io / doppelgaenger

src/AspectRegister.php

<?php

/**
 * \AppserverIo\Doppelgaenger\AspectRegister
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Bernhard Wick <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */

namespace AppserverIo\Doppelgaenger;

use AppserverIo\Doppelgaenger\Entities\Definitions\Advice;
use AppserverIo\Doppelgaenger\Entities\Definitions\Aspect;
use AppserverIo\Doppelgaenger\Entities\Definitions\AspectDefinition;
use AppserverIo\Doppelgaenger\Entities\Lists\AbstractTypedList;
use AppserverIo\Doppelgaenger\Entities\Lists\TypedList;
use AppserverIo\Doppelgaenger\Entities\PointcutExpression;
use AppserverIo\Doppelgaenger\Entities\Pointcuts\PointcutFactory;
use AppserverIo\Doppelgaenger\Entities\Definitions\Pointcut as PointcutDefinition;
use AppserverIo\Doppelgaenger\Entities\Pointcuts\PointcutPointcut;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Advices\After;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Advices\AfterReturning;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Advices\AfterThrowing;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Advices\Around;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Advices\Before;
use AppserverIo\Psr\MetaobjectProtocol\Aop\Annotations\Pointcut;
use Herrera\Annotations\Convert\ToArray;
use Herrera\Annotations\Tokenizer;
use Herrera\Annotations\Tokens;

/**
 * Class which knows about registered aspects to allow for checks of methods against all given pointcuts
 *
 * @author    Bernhard Wick <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */
class AspectRegister extends AbstractTypedList
{

    /**
     * Default constructor
     */
    public function __construct()
    {
        parent::__construct();

        $this->itemType = '\AppserverIo\Doppelgaenger\Entities\Definitions\Aspect';
        $this->defaultOffset = 'qualifiedName';
    }

    /**
     * Look up a certain advice based on a glob-like expression optionally containing aspect name and advice name
     *
     * @param string $adviceExpression Expression defining the search term
     *
     * @return array<\AppserverIo\Doppelgaenger\Entities\Definitions\Advice>
     */
    public function lookupAdvice($adviceExpression)
    {
        // clean the expression
        $adviceExpression = trim(ltrim(rtrim($adviceExpression, '()'), '\\'));

        // if there is an aspect name within the expression we have to filter our search range and cut the expression
        $container = $this->container;
        if (strpos($adviceExpression, '->')) {
            $aspectExpression = strstr($adviceExpression, '->', true);
            $container = $this->lookupAspects($aspectExpression);
            $adviceExpression = str_replace('->', '', strstr($adviceExpression, '->'));
        }

        $matches = array();
        foreach ($container as $aspect) {
            $matches = array_merge($matches, $this->lookupEntries($aspect->getAdvices(), $adviceExpression));
        }

        return $matches;
    }

    /**
     * Will narrow down the choice of aspects to make when looking up pointcuts or advices.
     * Just pass the expression to look up any of both
     *
     * @param string $expression Expression defining the search term
     *
     * @return array<\AppserverIo\Doppelgaenger\Entities\Definitions\Aspect>
     */
    public function lookupAspects($expression)
    {
        return $this->lookupEntries($this->container, $expression);
    }

    /**
     * Look up certain entities in a container based on their qualified name and a glob-like expression
     *
     * @param array|\Traversable $container  Traversable container we will look in
     * @param string             $expression Expression defining the search term
     *
     * @return array
     */
    protected function lookupEntries($container, $expression)
    {

        // clean the expression
        $expression = trim(ltrim(rtrim($expression, '()'), '\\'));

        // if we got the complete name of the aspect we can return it alone
        if ($this->entryExists($expression)) {
            return array($this->get($expression));
        }

        // as it seems we got something else we have to get all regex about
        $matches = array();
        foreach ($container as $entry) {
            if (fnmatch($expression, $entry->getQualifiedName())) {
                $matches[] = $entry;
            }
        }

        return $matches;
    }

    /**
     * Look up a certain advice based on a glob-like expression optionally containing aspect name and pointcut name
     *
     * @param string $pointcutExpression Expression defining the search term
     *
     * @return array<\AppserverIo\Doppelgaenger\Entities\Definitions\Pointcut>
     */
    public function lookupPointcuts($pointcutExpression)
    {
        // clean the expression
        $pointcutExpression = trim(ltrim(rtrim($pointcutExpression, '()'), '\\'));

        // if there is an aspect name within the expression we have to filter our search range and cut the expression
        $container = $this->container;
        if (strpos($pointcutExpression, '->')) {
            $aspectExpression = strstr($pointcutExpression, '->', true);
            $container = $this->lookupAspects($aspectExpression);
            $pointcutExpression = str_replace('->', '', strstr($pointcutExpression, '->'));
        }

        $matches = array();
        foreach ($container as $aspect) {
            $matches = array_merge($matches, $this->lookupEntries($aspect->getPointcuts(), $pointcutExpression));
        }

        return $matches;
    }

    /**
     * Will register a complete aspect to the AspectRegister.
     * This include its advices and pointcuts which can be looked up from this point on
     *
     * @param \AppserverIo\Doppelgaenger\Entities\Definitions\AspectDefinition $aspectDefinition Structure to register as an aspect
     *
     * @return null
     */
    public function register(AspectDefinition $aspectDefinition)
    {

        // create the new aspect and fill it with things we already know
        $aspect = new Aspect();
        $aspect->setName($aspectDefinition->getName());
        $aspect->setNamespace($aspectDefinition->getNamespace());

        // prepare the tokenizer we will need for further processing
        $needles = array(
            AfterReturning::ANNOTATION,
            AfterThrowing::ANNOTATION,
            After::ANNOTATION,
            Around::ANNOTATION,
            Before::ANNOTATION
        );
        $tokenizer = new Tokenizer();
        $tokenizer->ignore(
            array(
                'param',
                'return',
                'throws'
            )
        );

        // iterate the functions and filter out the ones used as advices
        $scheduledAdviceDefinitions = array();
        foreach ($aspectDefinition->getFunctionDefinitions() as $functionDefinition) {

The expression $aspectDefinition->getFunctionDefinitions() of type null|object<AppserverIo\Doppelgaenger\Entities\Lists\FunctionDefinitionList> is not guaranteed to be traversable. How about adding an additional type check?

            $foundNeedle = false;
            foreach ($needles as $needle) {
                // create the advice
                if (strpos($functionDefinition->getDocBlock(), '@' . $needle) !== false) {
                    $foundNeedle = true;
                    $scheduledAdviceDefinitions[$needle][] = $functionDefinition;

                    break;
                }
            }

            // create the pointcut
            if (!$foundNeedle && strpos($functionDefinition->getDocBlock(), '@' . Pointcut::ANNOTATION) !== false) {
                $pointcut = new PointcutDefinition();
                $pointcut->setName($functionDefinition->getName());

                $tokens = new Tokens($tokenizer->parse($functionDefinition->getDocBlock()));

                // convert to array and run it through our advice factory
                $toArray = new ToArray();
                $annotations = $toArray->convert($tokens);

                // create the entities for the join-points and advices the pointcut describes
                $pointcut->setPointcutExpression(new PointcutExpression(array_pop(array_pop($annotations)->values)));
                $aspect->getPointcuts()->add($pointcut);
            }
        }
        $this->add($aspect);

        // do the pointcut lookups where we will need the pointcut factory for later use
        $pointcutFactory = new PointcutFactory();
        foreach ($scheduledAdviceDefinitions as $codeHook => $hookedAdviceDefinitions) {
            foreach ($hookedAdviceDefinitions as $scheduledAdviceDefinition) {
                // create our advice
                $advice = new Advice();
                $advice->setAspectName($aspectDefinition->getQualifiedName());
                $advice->setName($scheduledAdviceDefinition->getName());
                $advice->setCodeHook((string) $codeHook);

                $tokens = new Tokens($tokenizer->parse($scheduledAdviceDefinition->getDocBlock()));

                // convert to array and run it through our advice factory
                $toArray = new ToArray();
                $annotations = $toArray->convert($tokens);

                // create the entities for the join-points and advices the pointcut describes
                foreach ($annotations as $annotation) {
                    $pointcut = $pointcutFactory->getInstance(array_pop($annotation->values));
                    if ($pointcut instanceof PointcutPointcut) {
                        // get the referenced pointcuts for the split parts of the expression
                        $expressionParts = explode(PointcutPointcut::EXPRESSION_CONNECTOR, $pointcut->getExpression());

                        // lookup all the referenced pointcuts
                        $referencedPointcuts = array();
                        foreach ($expressionParts as $expressionPart) {
                            $referencedPointcuts = array_merge($referencedPointcuts, $this->lookupPointcuts($expressionPart));
                        }

                        $pointcut->setReferencedPointcuts($referencedPointcuts);
                    }

                    $advice->getPointcuts()->add($pointcut);
                }

                $aspect->getAdvices()->add($advice);
            }
        }

        $this->set($aspectDefinition->getQualifiedName(), $aspect);
    }
}