Initial commit with Symfony 2.1+Vendors

Signed-off-by: Gergely POLONKAI (W00d5t0ck) <polesz@w00d5t0ck.info>

vendor/jms/aop-bundle/JMS/AopBundle/Aop/InterceptorLoader.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Aop;
+
+use CG\Proxy\InterceptorLoaderInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Lazy-loading interceptor loader implementation.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class InterceptorLoader implements InterceptorLoaderInterface
+{
+    private $container;
+    private $interceptors;
+    private $loadedInterceptors = array();
+
+    public function __construct(ContainerInterface $container, array $interceptors)
+    {
+        $this->container = $container;
+        $this->interceptors = $interceptors;
+    }
+
+    public function loadInterceptors(\ReflectionMethod $method)
+    {
+        if (!isset($this->interceptors[$method->class][$method->name])) {
+            return array();
+        }
+
+        if (isset($this->loadedInterceptors[$method->class][$method->name])) {
+            return $this->loadedInterceptors[$method->class][$method->name];
+        }
+
+        $interceptors = array();
+        foreach ($this->interceptors[$method->class][$method->name] as $id) {
+            $interceptors[] = $this->container->get($id);
+        }
+
+        return $this->loadedInterceptors[$method->class][$method->name] = $interceptors;
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/Aop/PointcutContainer.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Aop;
+
+final class PointcutContainer
+{
+    private $pointcuts;
+
+    public function __construct(array $pointcuts)
+    {
+        $this->pointcuts = $pointcuts;
+    }
+
+    public function getPointcuts()
+    {
+        return $this->pointcuts;
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/Aop/PointcutInterface.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Aop;
+
+/**
+ * Pointcut Interface.
+ *
+ * Implementations of this class are responsible for making a decision on whether
+ * a certain method call matches the advice which is associated with this pointcut.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface PointcutInterface
+{
+    /**
+     * Determines whether the advice applies to instances of the given class.
+     *
+     * There are some limits as to what you can do in this method. Namely, you may
+     * only base your decision on resources that are part of the ContainerBuilder.
+     * Specifically, you may not use any data in the class itself, such as
+     * annotations.
+     *
+     * @param \ReflectionClass $class
+     * @return boolean
+     */
+    function matchesClass(\ReflectionClass $class);
+
+    /**
+     * Determines whether the advice applies to the given method.
+     *
+     * This method is not limited in the way the matchesClass method is. It may
+     * use information in the associated class to make its decision.
+     *
+     * @param \ReflectionMethod $method
+     * @return boolean
+     */
+    function matchesMethod(\ReflectionMethod $method);
+}

vendor/jms/aop-bundle/JMS/AopBundle/Aop/RegexPointcut.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Aop;
+
+/**
+ * A regex pointcut implementation.
+ *
+ * Uses a regular expression for determining whether the pointcut matches.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RegexPointcut implements PointcutInterface
+{
+    private $pattern;
+
+    public function __construct($pattern)
+    {
+        $this->pattern = $pattern;
+    }
+
+    public function matchesClass(\ReflectionClass $class)
+    {
+        return true;
+    }
+
+    public function matchesMethod(\ReflectionMethod $method)
+    {
+        return 0 < preg_match('#'.$this->pattern.'#', sprintf('%s::%s', $method->class, $method->name));
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/DependencyInjection/Compiler/PointcutMatchingPass.php

@@ -0,0 +1,195 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\DependencyInjection\Compiler;
+
+use CG\Core\ClassUtils;
+
+use JMS\AopBundle\Exception\RuntimeException;
+use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\DependencyInjection\Reference;
+use CG\Proxy\Enhancer;
+use CG\Proxy\InterceptionGenerator;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * Matches pointcuts against service methods.
+ *
+ * This pass will collect the advices that match a certain method, and then
+ * generate proxy classes where necessary.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class PointcutMatchingPass implements CompilerPassInterface
+{
+    private $pointcuts;
+    private $cacheDir;
+    private $container;
+
+    public function __construct(array $pointcuts = null)
+    {
+        $this->pointcuts = $pointcuts;
+    }
+
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+        $this->cacheDir = $container->getParameter('jms_aop.cache_dir').'/proxies';
+        $pointcuts = $this->getPointcuts();
+
+        $interceptors = array();
+        foreach ($container->getDefinitions() as $id => $definition) {
+            $this->processDefinition($definition, $pointcuts, $interceptors);
+
+            $this->processInlineDefinitions($pointcuts, $interceptors, $definition->getArguments());
+            $this->processInlineDefinitions($pointcuts, $interceptors, $definition->getMethodCalls());
+            $this->processInlineDefinitions($pointcuts, $interceptors, $definition->getProperties());
+        }
+
+        $container
+            ->getDefinition('jms_aop.interceptor_loader')
+            ->addArgument($interceptors)
+        ;
+    }
+
+    private function processInlineDefinitions($pointcuts, &$interceptors, array $a) {
+        foreach ($a as $k => $v) {
+            if ($v instanceof Definition) {
+                $this->processDefinition($v, $pointcuts, $interceptors);
+            } else if (is_array($v)) {
+                $this->processInlineDefinitions($pointcuts, $interceptors, $v);
+            }
+        }
+    }
+
+    private function processDefinition(Definition $definition, $pointcuts, &$interceptors)
+    {
+        if ($definition->isSynthetic()) {
+            return;
+        }
+
+        if ($definition->getFactoryService() || $definition->getFactoryClass()) {
+            return;
+        }
+
+        if ($file = $definition->getFile()) {
+            require_once $file;
+        }
+
+        if (!class_exists($definition->getClass())) {
+            return;
+        }
+
+        $class = new \ReflectionClass($definition->getClass());
+
+        // check if class is matched
+        $matchingPointcuts = array();
+        foreach ($pointcuts as $interceptor => $pointcut) {
+            if ($pointcut->matchesClass($class)) {
+                $matchingPointcuts[$interceptor] = $pointcut;
+            }
+        }
+
+        if (empty($matchingPointcuts)) {
+            return;
+        }
+
+        $this->addResources($class, $this->container);
+
+        if ($class->isFinal()) {
+            return;
+        }
+
+        $classAdvices = array();
+        foreach ($class->getMethods(\ReflectionMethod::IS_PROTECTED | \ReflectionMethod::IS_PUBLIC) as $method) {
+            if ($method->isFinal()) {
+                continue;
+            }
+
+            $advices = array();
+            foreach ($matchingPointcuts as $interceptor => $pointcut) {
+                if ($pointcut->matchesMethod($method)) {
+                    $advices[] = $interceptor;
+                }
+            }
+
+            if (empty($advices)) {
+                continue;
+            }
+
+            $classAdvices[$method->name] = $advices;
+        }
+
+        if (empty($classAdvices)) {
+            return;
+        }
+
+        $interceptors[ClassUtils::getUserClass($class->name)] = $classAdvices;
+
+        $generator = new InterceptionGenerator();
+        $generator->setFilter(function(\ReflectionMethod $method) use ($classAdvices) {
+            return isset($classAdvices[$method->name]);
+        });
+        if ($file) {
+            $generator->setRequiredFile($file);
+        }
+        $enhancer = new Enhancer($class, array(), array(
+            $generator
+        ));
+        $enhancer->writeClass($filename = $this->cacheDir.'/'.str_replace('\\', '-', $class->name).'.php');
+        $definition->setFile($filename);
+        $definition->setClass($enhancer->getClassName($class));
+        $definition->addMethodCall('__CGInterception__setLoader', array(
+            new Reference('jms_aop.interceptor_loader')
+        ));
+    }
+
+    private function addResources(\ReflectionClass $class)
+    {
+        do {
+            $this->container->addResource(new FileResource($class->getFilename()));
+        } while (($class = $class->getParentClass()) && $class->getFilename());
+    }
+
+    private function getPointcuts()
+    {
+        if (null !== $this->pointcuts) {
+            return $this->pointcuts;
+        }
+
+        $pointcuts = $pointcutReferences = array();
+
+        foreach ($this->container->findTaggedServiceIds('jms_aop.pointcut') as $id => $attr) {
+            if (!isset($attr[0]['interceptor'])) {
+                throw new RuntimeException('You need to set the "interceptor" attribute for the "jms_aop.pointcut" tag of service "'.$id.'".');
+            }
+
+            $pointcutReferences[$attr[0]['interceptor']] = new Reference($id);
+            $pointcuts[$attr[0]['interceptor']] = $this->container->get($id);
+        }
+
+        $this->container
+            ->getDefinition('jms_aop.pointcut_container')
+            ->addArgument($pointcutReferences)
+        ;
+
+        return $pointcuts;
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/DependencyInjection/Configuration.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\DependencyInjection;
+
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+
+/**
+ * This is the class that validates and merges configuration from your app/config files
+ *
+ * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html#cookbook-bundles-extension-config-class}
+ */
+class Configuration implements ConfigurationInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function getConfigTreeBuilder()
+    {
+        $treeBuilder = new TreeBuilder();
+        $treeBuilder->root('jms_aop')
+            ->children()
+                ->scalarNode('cache_dir')->cannotBeEmpty()->defaultValue('%kernel.cache_dir%/jms_aop')->end()
+            ->end()
+        ;
+
+        return $treeBuilder;
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/DependencyInjection/JMSAopExtension.php

@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\DependencyInjection;
+
+use JMS\AopBundle\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\FileLocator;
+use Symfony\Component\HttpKernel\DependencyInjection\Extension;
+use Symfony\Component\DependencyInjection\Loader;
+
+/**
+ * JMSAopExtension.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class JMSAopExtension extends Extension
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function load(array $configs, ContainerBuilder $container)
+    {
+        $configuration = new Configuration();
+        $config = $this->processConfiguration($configuration, $configs);
+
+        $cacheDir = $container->getParameterBag()->resolveValue($config['cache_dir']);
+        if (!is_dir($cacheDir)) {
+            if (false === @mkdir($cacheDir, 0777, true)) {
+                throw new RuntimeException(sprintf('Could not create cache directory "%s".', $cacheDir));
+            }
+        }
+        $container->setParameter('jms_aop.cache_dir', $cacheDir);
+
+        $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
+        $loader->load('services.xml');
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/Exception/Exception.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Exception;
+
+/**
+ * Base exception for the AopBundle.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface Exception
+{
+}

vendor/jms/aop-bundle/JMS/AopBundle/Exception/RuntimeException.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle\Exception;
+
+/**
+ * RuntimeException for the AopBundle.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RuntimeException extends \RuntimeException implements Exception
+{
+}

vendor/jms/aop-bundle/JMS/AopBundle/JMSAopBundle.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * Copyright 2011 Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace JMS\AopBundle;
+
+use Symfony\Component\DependencyInjection\Compiler\PassConfig;
+use JMS\AopBundle\DependencyInjection\Compiler\PointcutMatchingPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+
+class JMSAopBundle extends Bundle
+{
+	const VERSION = '1.0.0';
+
+    public function build(ContainerBuilder $container)
+    {
+        $container->addCompilerPass(new PointcutMatchingPass(), PassConfig::TYPE_AFTER_REMOVING);
+    }
+}

vendor/jms/aop-bundle/JMS/AopBundle/README

@@ -0,0 +1,8 @@
+For documentation, see:
+
+    Resources/doc
+    
+
+For license, see:
+
+    Resources/meta/LICENSE

vendor/jms/aop-bundle/JMS/AopBundle/Resources/config/services.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <parameters>
+        <parameter key="jms_aop.interceptor_loader.class">JMS\AopBundle\Aop\InterceptorLoader</parameter>
+    </parameters>
+
+    <services>
+        <service id="jms_aop.pointcut_container" class="JMS\AopBundle\Aop\PointcutContainer" />
+        
+        <service id="jms_aop.interceptor_loader" class="%jms_aop.interceptor_loader.class%">
+            <argument type="service" id="service_container" />
+        </service>
+    </services>
+</container>

vendor/jms/aop-bundle/JMS/AopBundle/Resources/doc/index.rst

@@ -0,0 +1,252 @@
+========
+Overview
+========
+
+This bundle adds AOP capabilities to Symfony2.
+
+If you haven't heard of AOP yet, it basically allows you to separate a
+cross-cutting concern (for example, security checks) into a dedicated class,
+and not having to repeat that code in all places where it is needed.
+
+In other words, this allows you to execute custom code before, and after the
+invocation of certain methods in your service layer, or your controllers. You
+can also choose to skip the invocation of the original method, or throw exceptions.
+
+Installation
+------------
+Checkout a copy of the code::
+
+    git submodule add https://github.com/schmittjoh/JMSAopBundle.git src/JMS/AopBundle
+
+Then register the bundle with your kernel::
+
+    // in AppKernel::registerBundles()
+    $bundles = array(
+        // ...
+        new JMS\AopBundle\JMSAopBundle(),
+        // ...
+    );
+
+This bundle also requires the CG library for code generation::
+
+    git submodule add https://github.com/schmittjoh/cg-library.git vendor/cg-library
+
+Make sure that you also register the namespaces with the autoloader::
+
+    // app/autoload.php
+    $loader->registerNamespaces(array(
+        // ...
+        'JMS'              => __DIR__.'/../vendor/bundles',
+        'CG'               => __DIR__.'/../vendor/cg-library/src',
+        // ...
+    ));    
+
+
+Configuration
+-------------
+::
+
+    jms_aop:
+        cache_dir: %kernel.cache_dir%/jms_aop
+
+
+Usage
+-----
+In order to execute custom code, you need two classes. First, you need a so-called
+pointcut. The purpose of this class is to make a decision whether a method call 
+should be intercepted by a certain interceptor. This decision has to be made
+statically only on the basis of the method signature itself.
+
+The second class is the interceptor. This class is being called instead
+of the original method. It contains the custom code that you would like to
+execute. At this point, you have access to the object on which the method is 
+called, and all the arguments which were passed to that method.
+
+Examples
+--------
+
+1. Logging
+~~~~~~~~~~
+
+In this example, we will be implementing logging for all methods that contain
+"delete".
+
+Pointcut
+^^^^^^^^
+
+::
+
+    <?php
+    
+    use JMS\AopBundle\Aop\PointcutInterface;
+    
+    class LoggingPointcut implements PointcutInterface
+    {
+        public function matchesClass(\ReflectionClass $class)
+        {
+            return true;
+        }
+
+        public function matchesMethod(\ReflectionMethod $method)
+        {
+            return false !== strpos($method->name, 'delete');
+        }
+    }
+
+::
+    
+    # services.yml
+    services:
+        my_logging_pointcut:
+            class: LoggingPointcut
+            tags:
+                - { name: jms_aop.pointcut, interceptor: logging_interceptor }
+
+
+LoggingInterceptor
+^^^^^^^^^^^^^^^^^^
+
+::
+
+    <?php
+    
+    use CG\Proxy\MethodInterceptorInterface;
+    use CG\Proxy\MethodInvocation;
+    use Symfony\Component\HttpKernel\Log\LoggerInterface;
+    use Symfony\Component\Security\Core\SecurityContextInterface;
+    
+    class LoggingInterceptor implements MethodInterceptorInterface
+    {
+        private $context;
+        private $logger;
+    
+        public function __construct(SecurityContextInterface $context,
+                                    LoggerInterface $logger)
+        {
+            $this->context = $context;
+            $this->logger = $logger;
+        }
+    
+        public function intercept(MethodInvocation $invocation)
+        {
+            $user = $this->context->getToken()->getUsername();
+            $this->logger->info(sprintf('User "%s" invoked method "%s".', $user, $invocation->reflection->name));
+            
+            // make sure to proceed with the invocation otherwise the original
+            // method will never be called
+            return $invocation->proceed();
+        }
+    }
+    
+::
+
+    # services.yml
+    services:
+        logging_interceptor:
+            class: LoggingInterceptor
+            arguments: [@security.context, @logger]
+
+
+2. Transaction Management
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In this example, we add a @Transactional annotation, and we automatically wrap all methods
+where this annotation is declared in a transaction.
+
+Pointcut
+^^^^^^^^
+
+::
+
+    use Doctrine\Common\Annotations\Reader;
+    use JMS\AopBundle\Aop\PointcutInterface;
+    use JMS\DiExtraBundle\Annotation as DI;
+    
+    /**
+     * @DI\Service
+     * @DI\Tag("jms_aop.pointcut", attributes = {"interceptor" = "aop.transactional_interceptor"})
+     *
+     * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+     */
+    class TransactionalPointcut implements PointcutInterface
+    {
+        private $reader;
+    
+        /**
+         * @DI\InjectParams({
+         *     "reader" = @DI\Inject("annotation_reader"),
+         * })
+         * @param Reader $reader
+         */
+        public function __construct(Reader $reader)
+        {
+            $this->reader = $reader;
+        }
+    
+        public function matchesClass(\ReflectionClass $class)
+        {
+            return true;
+        }
+    
+        public function matchesMethod(\ReflectionMethod $method)
+        {
+            return null !== $this->reader->getMethodAnnotation($method, 'Annotation\Transactional');
+        }
+    }
+
+Interceptor
+^^^^^^^^^^^
+
+::
+    
+    use Symfony\Component\HttpKernel\Log\LoggerInterface;
+    use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+    use CG\Proxy\MethodInvocation;
+    use CG\Proxy\MethodInterceptorInterface;
+    use Doctrine\ORM\EntityManager;
+    use JMS\DiExtraBundle\Annotation as DI;
+    
+    /**
+     * @DI\Service("aop.transactional_interceptor")
+     *
+     * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+     */
+    class TransactionalInterceptor implements MethodInterceptorInterface
+    {
+        private $em;
+        private $logger;
+    
+        /**
+         * @DI\InjectParams
+         * @param EntityManager $em
+         */
+        public function __construct(EntityManager $em, LoggerInterface $logger)
+        {
+            $this->em = $em;
+            $this->logger = $logger;
+        }
+    
+        public function intercept(MethodInvocation $invocation)
+        {
+            $this->logger->info('Beginning transaction for method "'.$invocation.'")');
+            $this->em->getConnection()->beginTransaction();
+            try {
+                $rs = $invocation->proceed();
+    
+                $this->logger->info(sprintf('Comitting transaction for method "%s" (method invocation successful)', $invocation));
+                $this->em->getConnection()->commit();
+    
+                return $rs;
+            } catch (\Exception $ex) {
+                if ($ex instanceof NotFoundHttpException) {
+                    $this->logger->info(sprintf('Committing transaction for method "%s" (exception thrown, but no rollback)', $invocation));
+                    $this->em->getConnection()->commit();
+                } else {
+                    $this->logger->info(sprintf('Rolling back transaction for method "%s" (exception thrown)', $invocation));
+                    $this->em->getConnection()->rollBack();
+                }
+    
+                throw $ex;
+            }
+        }
+    }

vendor/jms/aop-bundle/JMS/AopBundle/Resources/meta/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/jms/aop-bundle/JMS/AopBundle/composer.json

@@ -0,0 +1,21 @@
+{
+    "name": "jms/aop-bundle",
+    "description": "Adds AOP capabilities to Symfony2",
+    "keywords": ["annotations","aop"],
+    "type": "symfony-bundle",
+    "license": "Apache",
+    "authors": [
+        {
+            "name": "Johannes M. Schmitt",
+            "email": "schmittjoh@gmail.com"
+        }
+    ],
+    "require": {
+        "symfony/framework-bundle": "2.*",
+        "jms/cg": "1.0.0"
+    },
+    "autoload": {
+        "psr-0": { "JMS\\AopBundle": "" }
+    },
+    "target-dir": "JMS/AopBundle"
+}