/**
* Loads definition from specific point of aspect into the container
*
* @param AspectContainer $container Instance of container
* @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
*
* @throws \UnexpectedValueException
*/
public function load(AspectContainer $container, Aspect $aspect, $reflection, $metaInformation = null)
{
$pointcut = $this->parsePointcut($aspect, $reflection, $metaInformation);
$methodId = get_class($aspect) . '->' . $reflection->name;
$adviceCallback = Framework\BaseAdvice::fromAspectReflection($aspect, $reflection);
if (isset($metaInformation->scope) && $metaInformation->scope !== 'aspect') {
$scope = $metaInformation->scope;
$adviceCallback = Framework\BaseAdvice::createScopeCallback($aspect, $adviceCallback, $scope);
}
switch (true) {
// Register a pointcut by its name
case $metaInformation instanceof Annotation\Pointcut:
$container->registerPointcut($pointcut, $methodId);
break;
case $pointcut instanceof PointFilter:
$advice = $this->getInterceptor($metaInformation, $adviceCallback);
if ($pointcut->getKind() & PointFilter::KIND_DYNAMIC) {
$advice = new Framework\DynamicInvocationMatcherInterceptor($pointcut, $advice);
}
$container->registerAdvisor(new DefaultPointcutAdvisor($pointcut, $advice), $methodId);
break;
default:
throw new \UnexpectedValueException("Unsupported pointcut class: " . get_class($pointcut));
}
}
/**
* Configure an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer|Container $container
*
* @return void
*/
protected final function configureAop(AspectContainer $container)
{
$aspectIds = $container->getParameter('aspect.list');
foreach ($aspectIds as $aspectId) {
$container->registerAspect($container->get($aspectId));
}
}
/**
* Configures an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$reader = $container->get('aspect.annotation.reader');
$container->registerAspect(new InvariantCheckerAspect($reader));
$container->registerAspect(new PostconditionCheckerAspect($reader));
$container->registerAspect(new PreconditionCheckerAspect($reader));
}
/**
* {@inheritDoc}
*/
protected function configureAop(AspectContainer $container)
{
$typeCheckers = [new IntegerTypeChecker(), new CallableTypeChecker(), new StringTypeChecker(), new GenericObjectTypeChecker(), new ObjectTypeChecker(), new MixedTypeChecker(), new NullTypeChecker()];
$typeCheckers[] = new TypedTraversableChecker(...$typeCheckers);
$container->registerAspect(new PropertyWriteAspect(new PropertyWriteImmutabilityChecker(), new PropertyWriteTypeChecker()));
$container->registerAspect(new PostConstructAspect(new ObjectStateChecker(new ApplyTypeChecks(...$typeCheckers), new PropertyTypeFinder())));
$container->registerAspect(new PrePublicMethodAspect(new ParameterInterfaceJailer(new JailFactory())));
}
/**
* Configure an AspectContainer with advisors, aspects and pointcuts
*
* @param \Go\Core\AspectContainer $container AOP Container instance
* @return void
*/
protected function configureAop(AspectContainer $container)
{
foreach ((array) aspects() as $class) {
$class = class_exists($class) ? new $class() : null;
if ($class instanceof Aspect) {
$container->registerAspect($class);
}
}
}
/**
* Registers all aspects from magento configuration in the aspect kernel.
*
* @param AspectContainer $container
* @return void
*/
public function configureAop(AspectContainer $container)
{
foreach ($this->_getAspects() as $class) {
if ($class) {
$aspect = new $class();
$container->registerAspect($aspect);
}
}
}
/**
* Registers all aspects from magento configuration in the aspect kernel.
*
* @param AspectContainer $container
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$config = (array) Mage::getConfig()->getNode(self::CONFIG_PATH_AOP_ASPECTS);
foreach ($config as $class) {
if ($class) {
$aspect = new $class();
$container->registerAspect($aspect);
}
}
}
/**
* Configure an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$container->registerAspect(new DeclareErrorAspect());
$container->registerAspect(new CachingAspect());
$container->registerAspect(new LoggingAspect());
$container->registerAspect(new IntroductionAspect());
$container->registerAspect(new PropertyInterceptorAspect());
$container->registerAspect(new FunctionInterceptorAspect());
$container->registerAspect(new FluentInterfaceAspect());
$container->registerAspect(new HealthyLiveAspect());
$container->registerAspect(new DynamicMethodsAspect());
}
/**
* Constructs an wrapper for the composer loader
*
* @param ClassLoader $original Instance of current loader
* @param AspectContainer $container Instance of the container
* @param array $options Configuration options
*/
public function __construct(ClassLoader $original, AspectContainer $container, array $options = [])
{
$this->options = $options;
$this->original = $original;
$prefixes = $original->getPrefixes();
$excludePaths = $options['excludePaths'];
// Let's exclude core dependencies from that list
$excludePaths[] = $prefixes['Dissect'][0];
$excludePaths[] = substr($prefixes['Doctrine\\Common\\Annotations\\'][0], 0, -16);
$fileEnumerator = new Enumerator($options['appDir'], $options['includePaths'], $excludePaths);
$this->fileEnumerator = $fileEnumerator;
$this->cacheState = $container->get('aspect.cache.path.manager')->queryCacheState();
}
/**
* Get the Pointcut that drives this advisor.
*
* @return Pointcut The pointcut
*/
public function getPointcut()
{
if (!$this->pointcut) {
// Inject this dependencies and make them lazy!
// should be extracted from AbstractAspectLoaderExtension into separate class
/** @var Pointcut\PointcutLexer $lexer */
$lexer = $this->container->get('aspect.pointcut.lexer');
/** @var Pointcut\PointcutParser $parser */
$parser = $this->container->get('aspect.pointcut.parser');
$tokenStream = $lexer->lex($this->pointcutExpression);
$this->pointcut = $parser->parse($tokenStream);
}
return $this->pointcut;
}
/**
* Returns a real pointcut from the container
*
* @return Pointcut
*/
public function getPointcut()
{
if (!$this->pointcut) {
$this->pointcut = $this->container->getPointcut($this->pointcutName);
}
return $this->pointcut;
}
/**
* Return list of advices for class
*
* @param string|ReflectionClass|ParsedReflectionClass $class Class to advise
*
* @return array|Aop\Advice[] List of advices for class
*/
public function getAdvicesForClass($class)
{
$this->loader->loadAdvisorsAndPointcuts();
$classAdvices = array();
if (!$class instanceof ReflectionClass && !$class instanceof ParsedReflectionClass) {
$class = new ReflectionClass($class);
}
$parentClass = $class->getParentClass();
if ($parentClass && preg_match('/' . AspectContainer::AOP_PROXIED_SUFFIX . '$/', $parentClass->name)) {
$originalClass = $parentClass;
} else {
$originalClass = $class;
}
foreach ($this->container->getByTag('advisor') as $advisorId => $advisor) {
if ($advisor instanceof Aop\PointcutAdvisor) {
$pointcut = $advisor->getPointcut();
if ($pointcut->getClassFilter()->matches($class)) {
$classAdvices = array_merge_recursive($classAdvices, $this->getAdvicesFromAdvisor($originalClass, $advisor, $advisorId, $pointcut));
}
}
if ($advisor instanceof Aop\IntroductionAdvisor) {
if ($advisor->getClassFilter()->matches($class)) {
$classAdvices = array_merge_recursive($classAdvices, $this->getIntroductionFromAdvisor($originalClass, $advisor, $advisorId));
}
}
}
return $classAdvices;
}
/**
* Magic accessor
*
* @param string $name Key name
*
* @throws \InvalidArgumentException if referenced value is not an advisor
* @return Advice
*/
public function __get($name)
{
if ($this->container->has($name)) {
$advisor = $this->container->get($name);
} else {
list(, $advisorName) = explode('.', $name);
list($aspect) = explode('->', $advisorName);
$aspectInstance = $this->container->getAspect($aspect);
$this->loader->loadAndRegister($aspectInstance);
$advisor = $this->container->get($name);
}
if (!$advisor instanceof Advisor) {
throw new \InvalidArgumentException("Reference {$name} is not an advisor");
}
$this->{$name} = $advisor->getAdvice();
return $this->{$name};
}
/**
* Intercepts access to autowired properties and injects specified dependency
*
* @Around("@access(Warlock\Annotation\Autowired)")
*
* @param FieldAccess $joinpoint Autowiring joinpoint
*
* @return mixed
*/
public function beforeAccessingAutowiredProperty(FieldAccess $joinpoint)
{
$obj = $joinpoint->getThis();
$field = $joinpoint->getField();
if ($joinpoint->getAccessType() == FieldAccess::READ) {
/** @var Autowired $autowired */
$autowired = $this->reader->getPropertyAnnotation($field, self::ANNOTATION_NAME);
$strategy = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
if (!$autowired->required) {
$strategy = ContainerInterface::NULL_ON_INVALID_REFERENCE;
}
$value = $this->container->get($autowired, $strategy);
} else {
$value = $joinpoint->proceed();
}
$field->setValue($obj, $value);
return $value;
}
/**
* Check that list of advices for fields works correctly
*/
public function testGetSinglePropertyAdviceForClassFromAdvisor()
{
$propName = 'container';
// $this->container;
$pointcut = $this->getMock('Go\\Aop\\Pointcut');
$pointcut->expects($this->any())->method('getClassFilter')->will($this->returnValue(TruePointFilter::getInstance()));
$pointcut->expects($this->any())->method('matches')->will($this->returnCallback(function ($point) use($propName) {
return $point->name === $propName;
}));
$pointcut->expects($this->any())->method('getKind')->will($this->returnValue(Pointcut::KIND_PROPERTY));
$advice = $this->getMock('Go\\Aop\\Advice');
$advisor = new DefaultPointcutAdvisor($pointcut, $advice);
$this->container->registerAdvisor($advisor, 'test');
$advices = $this->adviceMatcher->getAdvicesForClass(__CLASS__);
$this->assertArrayHasKey(AspectContainer::PROPERTY_PREFIX, $advices);
$this->assertArrayHasKey($propName, $advices[AspectContainer::PROPERTY_PREFIX]);
$this->assertCount(1, $advices[AspectContainer::PROPERTY_PREFIX]);
}
/**
* Returns list of unloaded aspects in the container
*
* @return array|Aspect[]
*/
public function getUnloadedAspects()
{
$unloadedAspects = [];
foreach ($this->container->getByTag('aspect') as $aspect) {
if (!isset($this->loadedAspects[get_class($aspect)])) {
$unloadedAspects[] = $aspect;
}
}
return $unloadedAspects;
}
/**
* Loads definition from specific point of aspect into the container
*
* @param AspectContainer $container Instance of container
* @param Aspect $aspect Instance of aspect
* @param mixed|\ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflection Reflection of point
* @param mixed|null $metaInformation Additional meta-information
*
* @throws \UnexpectedValueException
*/
public function load(AspectContainer $container, Aspect $aspect, $reflection, $metaInformation = null)
{
$pointcut = $this->parsePointcut($aspect, $reflection, $metaInformation);
$propertyId = $reflection->class . '->' . $reflection->name;
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);
$container->registerAdvisor($advisor, $propertyId);
break;
case $metaInformation instanceof Annotation\DeclareError:
$reflection->setAccessible(true);
$message = $reflection->getValue($aspect);
$level = $metaInformation->level;
$advice = new Framework\DeclareErrorInterceptor($message, $level);
$container->registerAdvisor(new Support\DefaultPointcutAdvisor($pointcut, $advice), $propertyId);
break;
default:
throw new \UnexpectedValueException("Unsupported pointcut class: " . get_class($pointcut));
}
}
/**
* Load pointcuts into container
*
* There is no need to always load pointcuts, so we delay loading
*/
public function loadAdvisorsAndPointcuts()
{
$containerResources = $this->container->getResources();
$resourcesToLoad = array_diff($containerResources, $this->loadedResources);
if (!$resourcesToLoad) {
return;
}
foreach ($this->container->getByTag('aspect') as $aspect) {
$ref = new ReflectionClass($aspect);
if (in_array($ref->getFileName(), $resourcesToLoad)) {
$this->load($aspect);
}
}
$this->loadedResources = $containerResources;
}
/**
* Configure an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$container->registerAspect(new AuthorizationSecurityAspect());
}
/**
* Add resources for kernel
*
* @param AspectContainer $container
*/
protected function addKernelResourcesToContainer(AspectContainer $container)
{
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2);
$refClass = new \ReflectionObject($this);
$container->addResource($trace[1]['file']);
$container->addResource($refClass->getFileName());
}
/**
* Configure an AspectContainer with advisors, aspect and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$container->registerAspect(new DemoAspect('ASPECT!'));
}
/**
* Declares the error message for specific pointcut expression
*
* @param string $pointcutExpression Pointcut, e.g. "within(**)"
* @param string $message Error message to show
* @param integer $level Error level to trigger
*/
public function declareError($pointcutExpression, $message, $level = E_USER_ERROR)
{
$advice = new DeclareErrorInterceptor($message, $level);
$this->container->registerAdvisor(new LazyPointcutAdvisor($this->container, $pointcutExpression, $advice), $this->getPointcutId($pointcutExpression));
}
/**
* Collects list of advisors from the container
*
* @param AspectContainer $aspectContainer Container instance
*
* @return Advisor[] List of advisors in the container
*/
private function loadAdvisorsList(AspectContainer $aspectContainer)
{
/** @var AspectLoader $aspectLoader */
$aspectLoader = $aspectContainer->get('aspect.cached.loader');
$aspects = $aspectLoader->getUnloadedAspects();
foreach ($aspects as $aspect) {
$aspectLoader->loadAndRegister($aspect);
}
$advisors = $aspectContainer->getByTag('advisor');
return $advisors;
}
/**
* Constructs a pointcut grammar with AST
*
* @param AspectContainer $container Instance of the container
* @param RawAnnotationReader $annotationReader
*/
public function __construct(AspectContainer $container = null, RawAnnotationReader $annotationReader = null)
{
$this('empty')->is();
$this('pointcut')->is('pointcut', '||', 'pointcut')->call(function ($first, $_0, $second) {
return new OrPointcut($first, $second);
})->is('pointcut', '&&', 'pointcut')->call(function ($first, $_0, $second) {
return new AndPointcut($first, $second);
})->is('(', 'pointcut', ')')->call(function ($_0, $pointcut) {
return $pointcut;
})->is('!', 'pointcut')->call(function ($_0, $first) {
return new NotPointcut($first);
})->is('cflowbelow', '(', 'pointcut', ')')->call(function ($_0, $_1, $pointcut) {
return new CFlowBelowMethodPointcut($pointcut);
})->is('singlePointcut');
$this('singlePointcut')->is('execution', '(', 'memberModifiers', 'classFilter', 'methodCall', 'namePattern', '(', '*', ')', ')')->call(function ($_0, $_1, ModifierMatcherFilter $memberModifiers, PointFilter $classFilter, $methodCallType, $methodNamePattern) {
if ($methodCallType === '::') {
$memberModifiers->andMatch(\ReflectionMethod::IS_STATIC);
} else {
$memberModifiers->notMatch(\ReflectionMethod::IS_STATIC);
}
$filterKind = PointFilter::KIND_METHOD;
$pointcut = new SignaturePointcut($filterKind, $methodNamePattern, $memberModifiers);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('dynamic', '(', 'memberModifiers', 'classFilter', 'methodCall', 'namePattern', '(', '*', ')', ')')->call(function ($_0, $_1, ModifierMatcherFilter $memberModifiers, PointFilter $classFilter, $methodCallType, $methodNamePattern) {
if ($methodCallType === '::') {
$memberModifiers->andMatch(\ReflectionMethod::IS_STATIC);
} else {
$memberModifiers->notMatch(\ReflectionMethod::IS_STATIC);
}
$pointcut = new MagicMethodPointcut($methodNamePattern, $memberModifiers);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('execution', '(', 'namespacePattern', '(', '*', ')', ')')->call(function ($_0, $_1, $namespacePattern) {
$lastNsPos = strrpos($namespacePattern, '\\');
$namespace = substr($namespacePattern, 0, $lastNsPos);
$funcPattern = substr($namespacePattern, $lastNsPos + 1);
$nsFilter = new SimpleNamespaceFilter($namespace);
$pointcut = new FunctionPointcut($funcPattern);
$pointcut->setNamespaceFilter($nsFilter);
return $pointcut;
})->is('access', '(', 'memberModifiers', 'classFilter', '->', 'namePattern', ')')->call(function ($_0, $_1, ModifierMatcherFilter $memberModifiers, PointFilter $classFilter, $_2, $propertyNamePattern) {
$filterKind = PointFilter::KIND_PROPERTY;
$pointcut = new SignaturePointcut($filterKind, $propertyNamePattern, $memberModifiers);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('within', '(', 'classFilter', ')')->call(function ($_0, $_1, $classFilter) {
$pointcut = new TruePointcut(PointFilter::KIND_ALL);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('annotation', 'access', '(', 'namespacePattern', ')')->call(function ($_0, $_1, $_2, $annotationClassName) use($annotationReader) {
$kindProperty = PointFilter::KIND_PROPERTY;
return new AnnotationPointcut($kindProperty, $annotationReader, $annotationClassName);
})->is('annotation', 'execution', '(', 'namespacePattern', ')')->call(function ($_0, $_1, $_2, $annotationClassName) use($annotationReader) {
$kindMethod = PointFilter::KIND_METHOD;
return new AnnotationPointcut($kindMethod, $annotationReader, $annotationClassName);
})->is('annotation', 'within', '(', 'namespacePattern', ')')->call(function ($_0, $_1, $_2, $annotationClassName) use($annotationReader) {
$pointcut = new TruePointcut(PointFilter::KIND_ALL);
$kindClass = PointFilter::KIND_CLASS;
$classFilter = new AnnotationPointcut($kindClass, $annotationReader, $annotationClassName);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('initialization', '(', 'classFilter', ')')->call(function ($_0, $_1, $classFilter) {
$pointcut = new TruePointcut(PointFilter::KIND_INIT + PointFilter::KIND_CLASS);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('staticinitialization', '(', 'classFilter', ')')->call(function ($_0, $_1, $classFilter) {
$pointcut = new TruePointcut(PointFilter::KIND_STATIC_INIT + PointFilter::KIND_CLASS);
$pointcut->setClassFilter($classFilter);
return $pointcut;
})->is('pointcutReference')->call(function ($pointcutName) use($container) {
return $container->getPointcut($pointcutName);
});
$stringConverter = $this->getNodeToStringConverter();
$this('pointcutReference')->is('namespacePattern', 'methodCall', 'namePart')->call($stringConverter);
// stable
$this('methodCall')->is('::')->call($stringConverter)->is('->')->call($stringConverter);
$this('classFilter')->is('namespacePattern')->call(function ($pattern) {
$filterKind = PointFilter::KIND_CLASS;
$truePointFilter = TruePointFilter::getInstance();
return $pattern === '**' ? $truePointFilter : new SignaturePointcut($filterKind, $pattern, $truePointFilter);
})->is('namespacePattern', '+')->call(function ($parentClassName) {
return new InheritanceClassFilter($parentClassName);
});
// stable
$this('namespacePattern')->is('namePattern')->is('**')->call($stringConverter)->is('namespacePattern', 'nsSeparator', 'namespacePattern')->call($stringConverter);
// stable
$this('namePattern')->is('namePattern', '*')->call($stringConverter)->is('namePattern', 'namePart')->call($stringConverter)->is('namePattern', '|', 'namePart')->call($stringConverter)->is('namePart')->call($stringConverter)->is('*')->call($stringConverter);
// stable
$this('memberModifiers')->is('*')->call(function () {
$matcher = new ModifierMatcherFilter();
return $matcher->orMatch(-1);
})->is('nonEmptyMemberModifiers');
// stable
$this('nonEmptyMemberModifiers')->is('memberModifier')->call(function ($modifier) {
return new ModifierMatcherFilter($modifier);
})->is('nonEmptyMemberModifiers', '|', 'memberModifier')->call(function (ModifierMatcherFilter $matcher, $_0, $modifier) {
return $matcher->orMatch($modifier);
})->is('nonEmptyMemberModifiers', 'memberModifier')->call(function (ModifierMatcherFilter $matcher, $modifier) {
return $matcher->andMatch($modifier);
});
// stable
$converter = $this->getModifierConverter();
$this('memberModifier')->is('public')->call($converter)->is('protected')->call($converter)->is('private')->call($converter)->is('final')->call($converter);
$this->resolve(Grammar::ALL);
$this->start('pointcut');
}
public function registerBundleAspect(\Go\Core\AspectContainer $appAspectContainer)
{
$appAspectContainer->registerAspect(new \examples\exampleBundle\Aspect\AccessAspect());
}
/**
* Configures an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
$reader = $container->get('aspect.annotation.reader');
$container->registerAspect(new ContractCheckerAspect($reader));
}
protected function configureAop(AspectContainer $container)
{
$container->registerAspect(new MonitorAspect());
}
/**
* General method to register advices
*
* @param string $pointcutExpression Pointcut expression string
* @param Advice $advice Instance of advice
*/
private function registerAdviceInContainer($pointcutExpression, Advice $advice)
{
$this->container->registerAdvisor(new LazyPointcutAdvisor($this->container, $pointcutExpression, $advice), $this->getPointcutId($pointcutExpression));
}
