ClassManipulator::implement() can implement abstract classes

Author: dg

readme.md

@@ -902,7 +902,7 @@ $property = $manipulator->inheritProperty('foo');
 $property->setValue('new value');
 ```
 
-The `implement()` method automatically implements all methods from the given interface in your class:
+The `implement()` method automatically implements all methods and properties from the given interface or abstract class:
 
 ```php
 $manipulator->implement(SomeInterface::class);

src/PhpGenerator/ClassManipulator.php

@@ -68,32 +68,44 @@ public function inheritMethod(string $name, bool $returnIfExists = false): Metho
 			} catch (\ReflectionException) {
 				continue;
 			}
-			$method = (new Factory)->fromMethodReflection($rm);
-			$this->class->addMember($method);
-			return $method;
+			return $this->implementMethod($rm);
 		}
 
 		throw new Nette\InvalidStateException("Method '$name' has not been found in any ancestor: " . implode(', ', $parents));
 	}
 
 
 	/**
-	 * Implements all methods from the given interface.
+	 * Implements all methods from the given interface or abstract class.
 	 */
 	public function implement(string $name): void
 	{
 		$definition = new \ReflectionClass($name);
-		if (!$definition->isInterface()) {
-			throw new Nette\InvalidArgumentException("Class '$name' is not an interface.");
+		if ($definition->isInterface()) {
+			$this->class->addImplement($name);
+		} elseif ($definition->isAbstract()) {
+			$this->class->setExtends($name);
+		} else {
+			throw new Nette\InvalidArgumentException("'$name' is not an interface or abstract class.");
 		}
 
-		$this->class->addImplement($name);
 		foreach ($definition->getMethods() as $method) {
-			$this->inheritMethod($method->getName(), returnIfExists: true);
+			if (!$this->class->hasMethod($method->getName()) && $method->isAbstract()) {
+				$this->implementMethod($method);
+			}
 		}
 	}
 
 
+	private function implementMethod(\ReflectionMethod $rm): Method
+	{
+		$method = (new Factory)->fromMethodReflection($rm);
+		$method->setAbstract(false);
+		$this->class->addMember($method);
+		return $method;
+	}
+
+
 	/** @deprecated use implement() */
 	public function implementInterface(string $interfaceName): void
 	{

tests/PhpGenerator/ClassManipulator.implement.phpt

@@ -9,21 +9,64 @@ use Tester\Assert;
 require __DIR__ . '/../bootstrap.php';
 
 
-interface TestInterface
+interface ParentInterface
 {
-	public function testMethod();
+	public function interfaceMethod();
 }
 
+interface TestInterface extends ParentInterface
+{
+}
+
+abstract class ParentAbstract
+{
+	abstract public function abstractMethod();
+
+
+	public function concreteMethod()
+	{
+	}
+}
+
+abstract class TestAbstract extends ParentAbstract
+{
+}
+
+
 $class = new ClassType('TestClass');
 $manipulator = new ClassManipulator($class);
 
-// Test valid interface implementation
+// Test interface implementation
 $manipulator->implement(TestInterface::class);
-Assert::true(in_array(TestInterface::class, $class->getImplements(), true));
-Assert::true($class->hasMethod('testMethod'));
+Assert::match(<<<'XX'
+	class TestClass implements TestInterface
+	{
+		function interfaceMethod()
+		{
+		}
+	}
+
+	XX, (string) $class);
+
+
+// Test abstract class extension
+$class = new ClassType('TestClass');
+$manipulator = new ClassManipulator($class);
+$manipulator->implement(TestAbstract::class);
+Assert::match(<<<'XX'
+	class TestClass extends TestAbstract
+	{
+		public function abstractMethod()
+		{
+		}
+	}
+
+	XX, (string) $class);
+
 
-// Test exception for non-interface
+// Test exception for regular class
 Assert::exception(
 	fn() => $manipulator->implement(stdClass::class),
 	InvalidArgumentException::class,
+	"'stdClass' is not an interface or abstract class.",
 );