Initial commit with Symfony 2.1+Vendors

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

vendor/jms/cg/src/CG/Proxy/Enhancer.php

@@ -0,0 +1,158 @@
+<?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 CG\Proxy;
+
+use CG\Core\NamingStrategyInterface;
+
+use CG\Generator\Writer;
+use CG\Generator\PhpMethod;
+use CG\Generator\PhpDocblock;
+use CG\Generator\PhpClass;
+use CG\Core\AbstractClassGenerator;
+
+/**
+ * Class enhancing generator implementation.
+ *
+ * This class enhances existing classes by generating a proxy and leveraging
+ * different generator implementation.
+ *
+ * There are several built-in generator such as lazy-initializing objects, or
+ * a generator for creating AOP joinpoints.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Enhancer extends AbstractClassGenerator
+{
+    private $generatedClass;
+    private $class;
+    private $interfaces;
+    private $generators;
+
+    public function __construct(\ReflectionClass $class, array $interfaces = array(), array $generators = array())
+    {
+        if (empty($generators) && empty($interfaces)) {
+            throw new \RuntimeException('Either generators, or interfaces must be given.');
+        }
+
+        $this->class = $class;
+        $this->interfaces = $interfaces;
+        $this->generators = $generators;
+    }
+
+    /**
+     * Creates a new instance  of the enhanced class.
+     *
+     * @param array $args
+     * @return object
+     */
+    public function createInstance(array $args = array())
+    {
+        $generatedClass = $this->getClassName($this->class);
+
+        if (!class_exists($generatedClass, false)) {
+            eval($this->generateClass());
+        }
+
+        $ref = new \ReflectionClass($generatedClass);
+
+        return $ref->newInstanceArgs($args);
+    }
+
+    public function writeClass($filename)
+    {
+        if (!is_dir($dir = dirname($filename))) {
+            if (false === @mkdir($dir, 0777, true)) {
+                throw new \RuntimeException(sprintf('Could not create directory "%s".', $dir));
+            }
+        }
+
+        if (!is_writable($dir)) {
+            throw new \RuntimeException(sprintf('The directory "%s" is not writable.', $dir));
+        }
+
+        file_put_contents($filename, "<?php\n\n".$this->generateClass());
+    }
+
+    /**
+     * Creates a new enhanced class
+     *
+     * @return string
+     */
+    public final function generateClass()
+    {
+        static $docBlock;
+        if (empty($docBlock)) {
+            $writer = new Writer();
+            $writer
+                ->writeln('/**')
+                ->writeln(' * CG library enhanced proxy class.')
+                ->writeln(' *')
+                ->writeln(' * This code was generated automatically by the CG library, manual changes to it')
+                ->writeln(' * will be lost upon next generation.')
+                ->writeln(' */')
+            ;
+            $docBlock = $writer->getContent();
+        }
+
+        $this->generatedClass = PhpClass::create()
+            ->setDocblock($docBlock)
+            ->setParentClassName($this->class->name)
+        ;
+
+        $proxyClassName = $this->getClassName($this->class);
+        if (false === strpos($proxyClassName, NamingStrategyInterface::SEPARATOR)) {
+            throw new \RuntimeException(sprintf('The proxy class name must be suffixed with "%s" and an optional string, but got "%s".', NamingStrategyInterface::SEPARATOR, $proxyClassName));
+        }
+        $this->generatedClass->setName($proxyClassName);
+
+        if (!empty($this->interfaces)) {
+            $this->generatedClass->setInterfaceNames(array_map(function($v) { return '\\'.$v; }, $this->interfaces));
+
+            foreach ($this->getInterfaceMethods() as $method) {
+                $method = PhpMethod::fromReflection($method);
+                $method->setAbstract(false);
+
+                $this->generatedClass->setMethod($method);
+            }
+        }
+
+        if (!empty($this->generators)) {
+            foreach ($this->generators as $generator) {
+                $generator->generate($this->class, $this->generatedClass);
+            }
+        }
+
+        return $this->generateCode($this->generatedClass);
+    }
+
+    /**
+     * Adds stub methods for the interfaces that have been implemented.
+     */
+    protected function getInterfaceMethods()
+    {
+        $methods = array();
+
+        foreach ($this->interfaces as $interface) {
+            $ref = new \ReflectionClass($interface);
+            $methods = array_merge($methods, $ref->getMethods());
+        }
+
+        return $methods;
+    }
+}

vendor/jms/cg/src/CG/Proxy/GeneratorInterface.php

@@ -0,0 +1,38 @@
+<?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 CG\Proxy;
+
+use CG\Generator\PhpClass;
+
+/**
+ * Interface for enhancing generators.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface GeneratorInterface
+{
+    /**
+     * Generates the necessary changes in the class.
+     *
+     * @param \ReflectionClass $originalClass
+     * @param PhpClass $generatedClass The generated class
+     * @return void
+     */
+    function generate(\ReflectionClass $originalClass, PhpClass $generatedClass);
+}

vendor/jms/cg/src/CG/Proxy/InterceptionGenerator.php

@@ -0,0 +1,117 @@
+<?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 CG\Proxy;
+
+use CG\Core\ClassUtils;
+
+use CG\Core\ReflectionUtils;
+
+use CG\Generator\PhpParameter;
+use CG\Generator\PhpProperty;
+use CG\Generator\PhpMethod;
+use CG\Generator\PhpClass;
+
+/**
+ * Interception Generator.
+ *
+ * This generator creates joinpoints to allow for AOP advices. Right now, it only
+ * supports the most powerful around advice.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class InterceptionGenerator implements GeneratorInterface
+{
+    private $prefix = '__CGInterception__';
+    private $filter;
+    private $requiredFile;
+
+    public function setRequiredFile($file)
+    {
+        $this->requiredFile = $file;
+    }
+
+    public function setPrefix($prefix)
+    {
+        $this->prefix = $prefix;
+    }
+
+    public function setFilter(\Closure $filter)
+    {
+        $this->filter = $filter;
+    }
+
+    public function generate(\ReflectionClass $originalClass, PhpClass $genClass)
+    {
+        $methods = ReflectionUtils::getOverrideableMethods($originalClass);
+
+        if (null !== $this->filter) {
+            $methods = array_filter($methods, $this->filter);
+        }
+
+        if (empty($methods)) {
+            return;
+        }
+
+        if (!empty($this->requiredFile)) {
+            $genClass->addRequiredFile($this->requiredFile);
+        }
+
+        $interceptorLoader = new PhpProperty();
+        $interceptorLoader
+            ->setName($this->prefix.'loader')
+            ->setVisibility(PhpProperty::VISIBILITY_PRIVATE)
+        ;
+        $genClass->setProperty($interceptorLoader);
+
+        $loaderSetter = new PhpMethod();
+        $loaderSetter
+            ->setName($this->prefix.'setLoader')
+            ->setVisibility(PhpMethod::VISIBILITY_PUBLIC)
+            ->setBody('$this->'.$this->prefix.'loader = $loader;')
+        ;
+        $genClass->setMethod($loaderSetter);
+        $loaderParam = new PhpParameter();
+        $loaderParam
+            ->setName('loader')
+            ->setType('CG\Proxy\InterceptorLoaderInterface')
+        ;
+        $loaderSetter->addParameter($loaderParam);
+
+        $interceptorCode =
+             '$ref = new \ReflectionMethod(%s, %s);'."\n"
+            .'$interceptors = $this->'.$this->prefix.'loader->loadInterceptors($ref, $this, array(%s));'."\n"
+        	.'$invocation = new \CG\Proxy\MethodInvocation($ref, $this, array(%s), $interceptors);'."\n\n"
+            .'return $invocation->proceed();'
+        ;
+
+        foreach ($methods as $method) {
+            $params = array();
+            foreach ($method->getParameters() as $param) {
+                $params[] = '$'.$param->name;
+            }
+            $params = implode(', ', $params);
+
+            $genMethod = PhpMethod::fromReflection($method)
+                ->setBody(sprintf($interceptorCode, var_export(ClassUtils::getUserClass($method->class), true), var_export($method->name, true), $params, $params))
+                ->setDocblock(null)
+            ;
+            $genClass->setMethod($genMethod);
+        }
+    }
+}

vendor/jms/cg/src/CG/Proxy/InterceptorLoaderInterface.php

@@ -0,0 +1,38 @@
+<?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 CG\Proxy;
+
+/**
+ * Interception Loader.
+ *
+ * Implementations of this interface are responsible for loading the interceptors
+ * for a certain method.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface InterceptorLoaderInterface
+{
+    /**
+     * Loads interceptors.
+     *
+     * @param \ReflectionMethod $method
+     * @return array<MethodInterceptorInterface>
+     */
+    function loadInterceptors(\ReflectionMethod $method);
+}

vendor/jms/cg/src/CG/Proxy/LazyInitializerGenerator.php

@@ -0,0 +1,153 @@
+<?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 CG\Proxy;
+
+use CG\Generator\Writer;
+use CG\Core\ReflectionUtils;
+use CG\Generator\GeneratorUtils;
+use CG\Generator\PhpParameter;
+use CG\Generator\PhpMethod;
+use CG\Generator\PhpProperty;
+use CG\Generator\PhpClass;
+
+/**
+ * Generator for creating lazy-initializing instances.
+ *
+ * This generator enhances concrete classes to allow for them to be lazily
+ * initialized upon first access.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class LazyInitializerGenerator implements GeneratorInterface
+{
+    private $writer;
+    private $prefix = '__CG__';
+    private $markerInterface;
+
+    public function __construct()
+    {
+        $this->writer = new Writer();
+    }
+
+    public function setPrefix($prefix)
+    {
+        $this->prefix = $prefix;
+    }
+
+    /**
+     * Sets the marker interface which should be implemented by the
+     * generated classes.
+     *
+     * @param string $interface The FQCN of the interface
+     */
+    public function setMarkerInterface($interface)
+    {
+        $this->markerInterface = $interface;
+    }
+
+    /**
+     * Generates the necessary methods in the class.
+     *
+     * @param \ReflectionClass $originalClass
+     * @param PhpClass $class
+     * @return void
+     */
+    public function generate(\ReflectionClass $originalClass, PhpClass $class)
+    {
+        $methods = ReflectionUtils::getOverrideableMethods($originalClass, true);
+
+        // no public, non final methods
+        if (empty($methods)) {
+            return;
+        }
+
+        if (null !== $this->markerInterface) {
+            $class->setImplementedInterfaces(array_merge(
+                $class->getImplementedInterfaces(),
+                array($this->markerInterface)
+            ));
+        }
+
+        $initializer = new PhpProperty();
+        $initializer->setName($this->prefix.'lazyInitializer');
+        $initializer->setVisibility(PhpProperty::VISIBILITY_PRIVATE);
+        $class->setProperty($initializer);
+
+        $initialized = new PhpProperty();
+        $initialized->setName($this->prefix.'initialized');
+        $initialized->setDefaultValue(false);
+        $initialized->setVisibility(PhpProperty::VISIBILITY_PRIVATE);
+        $class->setProperty($initialized);
+
+        $initializerSetter = new PhpMethod();
+        $initializerSetter->setName($this->prefix.'setLazyInitializer');
+        $initializerSetter->setBody('$this->'.$this->prefix.'lazyInitializer = $initializer;');
+
+        $parameter = new PhpParameter();
+        $parameter->setName('initializer');
+        $parameter->setType('\CG\Proxy\LazyInitializerInterface');
+        $initializerSetter->addParameter($parameter);
+        $class->setMethod($initializerSetter);
+
+        $this->addMethods($class, $methods);
+
+        $initializingMethod = new PhpMethod();
+        $initializingMethod->setName($this->prefix.'initialize');
+        $initializingMethod->setVisibility(PhpMethod::VISIBILITY_PRIVATE);
+        $initializingMethod->setBody(
+            $this->writer
+                ->reset()
+                ->writeln('if (null === $this->'.$this->prefix.'lazyInitializer) {')
+                    ->indent()
+                    ->writeln('throw new \RuntimeException("'.$this->prefix.'setLazyInitializer() must be called prior to any other public method on this object.");')
+                    ->outdent()
+                ->write("}\n\n")
+                ->writeln('$this->'.$this->prefix.'lazyInitializer->initializeObject($this);')
+                ->writeln('$this->'.$this->prefix.'initialized = true;')
+                ->getContent()
+        );
+        $class->setMethod($initializingMethod);
+    }
+
+    private function addMethods(PhpClass $class, array $methods)
+    {
+        foreach ($methods as $method) {
+            $initializingCode = 'if (false === $this->'.$this->prefix.'initialized) {'."\n"
+            .'    $this->'.$this->prefix.'initialize();'."\n"
+            .'}';
+
+            if ($class->hasMethod($method->name)) {
+                $genMethod = $class->getMethod($method->name);
+                $genMethod->setBody(
+                $initializingCode."\n"
+                .$genMethod->getBody()
+                );
+
+                continue;
+            }
+
+            $genMethod = PhpMethod::fromReflection($method);
+            $genMethod->setBody(
+            $initializingCode."\n\n"
+            .'return '.GeneratorUtils::callMethod($method).';'
+            );
+            $class->setMethod($genMethod);
+        }
+    }
+}

vendor/jms/cg/src/CG/Proxy/LazyInitializerInterface.php

@@ -0,0 +1,38 @@
+<?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 CG\Proxy;
+
+/**
+ * Lazy Initializer.
+ *
+ * Implementations of this interface are responsible for lazily initializing
+ * object instances.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface LazyInitializerInterface
+{
+    /**
+     * Initializes the passed object.
+     *
+     * @param object $object
+     * @return void
+     */
+    function initializeObject($object);
+}

vendor/jms/cg/src/CG/Proxy/MethodInterceptorInterface.php

@@ -0,0 +1,42 @@
+<?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 CG\Proxy;
+
+/**
+ * Interface for Method Interceptors.
+ *
+ * Implementations of this interface can execute custom code before, and after the
+ * invocation of the actual method. In addition, they can also catch, or throw
+ * exceptions, modify the return value, or modify the arguments.
+ *
+ * This is also known as around advice in AOP terminology.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface MethodInterceptorInterface
+{
+    /**
+     * Called when intercepting a method call.
+     *
+     * @param MethodInvocation $invocation
+     * @return mixed the return value for the method invocation
+     * @throws \Exception may throw any exception
+     */
+    function intercept(MethodInvocation $invocation);
+}

vendor/jms/cg/src/CG/Proxy/MethodInvocation.php

@@ -0,0 +1,77 @@
+<?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 CG\Proxy;
+
+/**
+ * Represents a method invocation.
+ *
+ * This object contains information for the method invocation, such as the object
+ * on which the method is invoked, and the arguments that are passed to the method.
+ *
+ * Before the actual method is called, first all the interceptors must call the
+ * proceed() method on this class.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class MethodInvocation
+{
+    public $reflection;
+    public $object;
+    public $arguments;
+
+    private $interceptors;
+    private $pointer;
+
+    public function __construct(\ReflectionMethod $reflection, $object, array $arguments, array $interceptors)
+    {
+        $this->reflection = $reflection;
+        $this->object = $object;
+        $this->arguments = $arguments;
+        $this->interceptors = $interceptors;
+        $this->pointer = 0;
+    }
+
+    /**
+     * Proceeds down the call-chain and eventually calls the original method.
+     *
+     * @return mixed
+     */
+    public function proceed()
+    {
+        if (isset($this->interceptors[$this->pointer])) {
+            return $this->interceptors[$this->pointer++]->intercept($this);
+        }
+
+        $this->reflection->setAccessible(true);
+
+        return $this->reflection->invokeArgs($this->object, $this->arguments);
+    }
+
+    /**
+     * Returns a string representation of the method.
+     *
+     * This is intended for debugging purposes only.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return sprintf('%s::%s', $this->reflection->class, $this->reflection->name);
+    }
+}

vendor/jms/cg/src/CG/Proxy/RegexInterceptionLoader.php

@@ -0,0 +1,48 @@
+<?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 CG\Proxy;
+
+class RegexInterceptionLoader implements InterceptorLoaderInterface
+{
+    private $interceptors;
+
+    public function __construct(array $interceptors = array())
+    {
+        $this->interceptors = $interceptors;
+    }
+
+    public function loadInterceptors(\ReflectionMethod $method)
+    {
+        $signature = $method->class.'::'.$method->name;
+
+        $matchingInterceptors = array();
+        foreach ($this->interceptors as $pattern => $interceptor) {
+            if (preg_match('#'.$pattern.'#', $signature)) {
+                $matchingInterceptors[] = $this->initializeInterceptor($interceptor);
+            }
+        }
+
+        return $matchingInterceptors;
+    }
+
+    protected function initializeInterceptor($interceptor)
+    {
+        return $interceptor;
+    }
+}