Code-generation fatal error prevention

src/ProxyManager/Exception/InvalidProxiedClassException.php

@@ -20,6 +20,7 @@
 
 use InvalidArgumentException;
 use ReflectionClass;
+use ReflectionMethod;
 
 /**
  * Exception for invalid proxied classes
@@ -38,4 +39,41 @@ public static function interfaceNotSupported(ReflectionClass $reflection)
     {
         return new self(sprintf('Provided interface "%s" cannot be proxied', $reflection->getName()));
     }
+
+    /**
+     * @param ReflectionClass $reflection
+     *
+     * @return self
+     */
+    public static function finalClassNotSupported(ReflectionClass $reflection)
+    {
+        return new self(sprintf('Provided class "%s" is final and cannot be proxied', $reflection->getName()));
+    }
+
+    /**
+     * @param ReflectionClass $reflection
+     *
+     * @return self
+     */
+    public static function abstractProtectedMethodsNotSupported(ReflectionClass $reflection)
+    {
+        return new self(sprintf(
+            'Provided class "%s" has following protected abstract methods, and therefore cannot be proxied:' . "\n%s",
+            $reflection->getName(),
+            implode(
+                "\n",
+                array_map(
+                    function (ReflectionMethod $reflectionMethod) {
+                        return $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName();
+                    },
+                    array_filter(
+                        $reflection->getMethods(),
+                        function (ReflectionMethod $method) {
+                            return $method->isAbstract() && $method->isProtected();
+                        }
+                    )
+                )
+            )
+        ));
+    }
 }

src/ProxyManager/Generator/Util/ClassGeneratorUtils.php

@@ -19,8 +19,9 @@
 namespace ProxyManager\Generator\Util;
 
 use ReflectionClass;
+use ReflectionMethod;
+use Zend\Code\Generator\ClassGenerator;
 use Zend\Code\Generator\MethodGenerator;
-use Zend\Code\Generator\ClassGenerator as GeneratorClass;
 
 /**
  * Util class to help to generate code
@@ -32,14 +33,14 @@ final class ClassGeneratorUtils
 {
     /**
      * @param ReflectionClass  $originalClass
-     * @param GeneratorClass   $classGenerator
+     * @param ClassGenerator   $classGenerator
      * @param MethodGenerator  $generatedMethod
      *
      * @return void|false
      */
     public static function addMethodIfNotFinal(
         ReflectionClass $originalClass,
-        GeneratorClass $classGenerator,
+        ClassGenerator $classGenerator,
         MethodGenerator $generatedMethod
     ) {
         $methodName = $generatedMethod->getName();

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizerGenerator.php

@@ -18,11 +18,11 @@
 
 namespace ProxyManager\ProxyGenerator;
 
-use ProxyManager\Exception\InvalidProxiedClassException;
 use ProxyManager\Generator\Util\ClassGeneratorUtils;
 use ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator\SetMethodPrefixInterceptor;
 use ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator\SetMethodSuffixInterceptor;
 use ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator\MethodPrefixInterceptors;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\InterceptedMethod;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicClone;
@@ -31,6 +31,7 @@
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicSet;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicSleep;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicUnset;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
 use ReflectionClass;
 use ReflectionMethod;
@@ -54,9 +55,7 @@ class AccessInterceptorScopeLocalizerGenerator implements ProxyGeneratorInterfac
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
-        if ($originalClass->isInterface()) {
-            throw InvalidProxiedClassException::interfaceNotSupported($originalClass);
-        }
+        CanProxyAssertion::assertClassCanBeProxied($originalClass, false);
 
         $classGenerator->setExtendedClass($originalClass->getName());
         $classGenerator->setImplementedInterfaces(array('ProxyManager\\Proxy\\AccessInterceptorInterface'));

src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolderGenerator.php

@@ -24,13 +24,15 @@
 use ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator\SetMethodSuffixInterceptor;
 use ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator\MethodPrefixInterceptors;
 use ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator\MethodSuffixInterceptors;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\InterceptedMethod;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\MagicClone;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\MagicGet;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\MagicIsset;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\MagicSet;
 use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\MagicUnset;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\LazyLoadingValueHolder\PropertyGenerator\ValueHolderProperty;
 use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
 use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
@@ -58,6 +60,8 @@ class AccessInterceptorValueHolderGenerator implements ProxyGeneratorInterface
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
+        CanProxyAssertion::assertClassCanBeProxied($originalClass);
+
         $publicProperties    = new PublicPropertiesMap($originalClass);
         $interfaces          = array(
             'ProxyManager\\Proxy\\AccessInterceptorInterface',

src/ProxyManager/ProxyGenerator/Assertion/CanProxyAssertion.php

@@ -0,0 +1,102 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+namespace ProxyManager\ProxyGenerator\Assertion;
+
+use BadMethodCallException;
+use ProxyManager\Exception\InvalidProxiedClassException;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Assertion that verifies that a class can be proxied
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+final class CanProxyAssertion
+{
+    /**
+     * Disabled constructor: not meant to be instantiated
+     *
+     * @throws BadMethodCallException
+     */
+    public function __construct()
+    {
+        throw new BadMethodCallException('Unsupported constructor.');
+    }
+
+    /**
+     * @param ReflectionClass $originalClass
+     * @param bool            $allowInterfaces
+     *
+     * @throws InvalidProxiedClassException
+     */
+    public static function assertClassCanBeProxied(ReflectionClass $originalClass, $allowInterfaces = true)
+    {
+        self::isNotFinal($originalClass);
+        self::hasNoAbstractProtectedMethods($originalClass);
+
+        if (! $allowInterfaces) {
+            self::isNotInterface($originalClass);
+        }
+    }
+
+    /**
+     * @param ReflectionClass $originalClass
+     *
+     * @throws InvalidProxiedClassException
+     */
+    private static function isNotFinal(ReflectionClass $originalClass)
+    {
+        if ($originalClass->isFinal()) {
+            throw InvalidProxiedClassException::finalClassNotSupported($originalClass);
+        }
+    }
+
+    /**
+     * @param ReflectionClass $originalClass
+     *
+     * @throws InvalidProxiedClassException
+     */
+    private static function hasNoAbstractProtectedMethods(ReflectionClass $originalClass)
+    {
+        $protectedAbstract = array_filter(
+            $originalClass->getMethods(),
+            function (ReflectionMethod $method) {
+                return $method->isAbstract() && $method->isProtected();
+            }
+        );
+
+        if ($protectedAbstract) {
+            throw InvalidProxiedClassException::abstractProtectedMethodsNotSupported($originalClass);
+        }
+    }
+
+    /**
+     * @param ReflectionClass $originalClass
+     *
+     * @throws InvalidProxiedClassException
+     */
+    private static function isNotInterface(ReflectionClass $originalClass)
+    {
+        if ($originalClass->isInterface()) {
+            throw InvalidProxiedClassException::interfaceNotSupported($originalClass);
+        }
+    }
+}

src/ProxyManager/ProxyGenerator/LazyLoadingGhostGenerator.php

@@ -19,6 +19,8 @@
 namespace ProxyManager\ProxyGenerator;
 
 use ProxyManager\Generator\Util\ClassGeneratorUtils;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\LazyLoading\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator\CallInitializer;
 use ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator\GetProxyInitializer;
@@ -58,6 +60,8 @@ class LazyLoadingGhostGenerator implements ProxyGeneratorInterface
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
+        CanProxyAssertion::assertClassCanBeProxied($originalClass);
+
         $interfaces          = array('ProxyManager\\Proxy\\GhostObjectInterface');
         $publicProperties    = new PublicPropertiesMap($originalClass);
         $publicPropsDefaults = new PublicPropertiesDefaults($originalClass);

src/ProxyManager/ProxyGenerator/LazyLoadingValueHolderGenerator.php

@@ -18,7 +18,10 @@
 
 namespace ProxyManager\ProxyGenerator;
 
+use ProxyManager\Generator\Util\ClassGeneratorUtils;
 use ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator\MagicWakeup;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\LazyLoading\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator\GetProxyInitializer;
 use ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator\InitializeProxy;
@@ -36,7 +39,6 @@
 use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
 use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
 use ProxyManager\ProxyGenerator\ValueHolder\MethodGenerator\GetWrappedValueHolderValue;
-use ProxyManager\Generator\Util\ClassGeneratorUtils;
 use ReflectionClass;
 use ReflectionMethod;
 use Zend\Code\Generator\ClassGenerator;
@@ -58,6 +60,8 @@ class LazyLoadingValueHolderGenerator implements ProxyGeneratorInterface
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
+        CanProxyAssertion::assertClassCanBeProxied($originalClass);
+
         $interfaces          = array('ProxyManager\\Proxy\\VirtualProxyInterface');
         $publicProperties    = new PublicPropertiesMap($originalClass);
 

src/ProxyManager/ProxyGenerator/NullObjectGenerator.php

@@ -19,6 +19,8 @@
 namespace ProxyManager\ProxyGenerator;
 
 use ProxyManager\Generator\Util\ClassGeneratorUtils;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\NullObject\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\NullObject\MethodGenerator\NullObjectMethodInterceptor;
 use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
@@ -41,14 +43,12 @@ class NullObjectGenerator implements ProxyGeneratorInterface
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
+        CanProxyAssertion::assertClassCanBeProxied($originalClass);
+
         $interfaces = array('ProxyManager\\Proxy\\NullObjectInterface');
 
         if ($originalClass->isInterface()) {
             $interfaces[] = $originalClass->getName();
-        } else {
-            foreach ($originalClass->getInterfaceNames() as $name) {
-                $interfaces[] = $name;
-            }
         }
 
         $classGenerator->setImplementedInterfaces($interfaces);

src/ProxyManager/ProxyGenerator/RemoteObjectGenerator.php

@@ -19,6 +19,8 @@
 namespace ProxyManager\ProxyGenerator;
 
 use ProxyManager\Generator\Util\ClassGeneratorUtils;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\AbstractMethod;
+use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
 use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\Constructor;
 use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicGet;
 use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicIsset;
@@ -48,6 +50,8 @@ class RemoteObjectGenerator implements ProxyGeneratorInterface
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
     {
+        CanProxyAssertion::assertClassCanBeProxied($originalClass);
+
         $interfaces = array('ProxyManager\\Proxy\\RemoteObjectInterface');
 
         if ($originalClass->isInterface()) {

tests/ProxyManagerTest/Exception/InvalidProxiedClassExceptionTest.php

@@ -33,9 +33,6 @@
  */
 class InvalidProxiedClassExceptionTest extends PHPUnit_Framework_TestCase
 {
-    /**
-     * @covers \ProxyManager\Exception\InvalidProxiedClassException::interfaceNotSupported
-     */
     public function testInterfaceNotSupported()
     {
         $this->assertSame(
@@ -45,4 +42,26 @@ public function testInterfaceNotSupported()
             )->getMessage()
         );
     }
+
+    public function testFinalClassNotSupported()
+    {
+        $this->assertSame(
+            'Provided class "ProxyManagerTestAsset\FinalClass" is final and cannot be proxied',
+            InvalidProxiedClassException::finalClassNotSupported(
+                new ReflectionClass('ProxyManagerTestAsset\FinalClass')
+            )->getMessage()
+        );
+    }
+
+    public function testAbstractProtectedMethodsNotSupported()
+    {
+        $this->assertSame(
+            'Provided class "ProxyManagerTestAsset\ClassWithAbstractProtectedMethod" has following protected abstract'
+            . ' methods, and therefore cannot be proxied:' . "\n"
+            . 'ProxyManagerTestAsset\ClassWithAbstractProtectedMethod::protectedAbstractMethod',
+            InvalidProxiedClassException::abstractProtectedMethodsNotSupported(
+                new ReflectionClass('ProxyManagerTestAsset\ClassWithAbstractProtectedMethod')
+            )->getMessage()
+        );
+    }
 }