Merge pull request #47 from xp-framework/feature/implementation

Implement `Package::implementation()` to load implementations of a given type

Author: thekid

README.md

@@ -164,14 +164,14 @@ if ($parameters->accept($args)) {
 }
 
 foreach ($parameters as $name => $parameter) {
-  $parameter->position();                 // 0
-  $parameter->name();                     // 'arg'
-  $parameter->variadic();                 // false
-  $parameter->optional();                 // true
-  $parameter->default();                  // (parameter default value)
-  $parameter->constraint();               // Constraint
-  $parameter->annotations();              // Annotations
-  $parameter->annotation(Inject::class)   // Annotation or NULL
+  $parameter->position();                  // 0
+  $parameter->name();                      // 'arg'
+  $parameter->variadic();                  // false
+  $parameter->optional();                  // true
+  $parameter->default();                   // (parameter default value)
+  $parameter->constraint();                // Constraint
+  $parameter->annotations();               // Annotations
+  $parameter->annotation(Inject::class)    // Annotation or NULL
 }
 ```
 
@@ -182,12 +182,13 @@ use lang\Reflection;
 
 $package= Reflection::of('org.example');
 
-$package->name();          // org.example
-$package->literal();       // 'org\example'
-$package->type('Fixture'); // Type instance
-$package->types();         // iterable with Type instances
-$package->parent()         // Package or NULL
-$package->child('impl')    // Child package "org.example.impl" or NULL
-$package->children();      // iterable with Package instances
-$package->classLoaders();  // iterable with lang.ClassLoader instances
+$package->name();                          // org.example
+$package->literal();                       // 'org\example'
+$package->type('Fixture');                 // Type instance
+$package->implementation($t, 'Fixture');   // Type instance (subclass of $t)
+$package->types();                         // iterable with Type instances
+$package->parent()                         // Package or NULL
+$package->child('impl')                    // Child package "org.example.impl" or NULL
+$package->children();                      // iterable with Package instances
+$package->classLoaders();                  // iterable with lang.ClassLoader instances
 ```

src/main/php/lang/reflection/Package.class.php

@@ -122,6 +122,21 @@ public function type($name) {
     throw new IllegalArgumentException('Given type '.$type.' is not in package '.$this->name);
   }
 
+  /**
+   * Returns an implementation for a given type
+   *
+   * @param  string|lang.reflection.Type $type
+   * @param  string $name
+   * @return lang.reflection.Type
+   * @throws lang.IllegalArgumentException
+   */
+  public function implementation($type, $name) {
+    $impl= $this->type($name);
+    if ($impl->is($type)) return $impl;
+
+    throw new IllegalArgumentException('Given type '.$impl->name().' is not an implementation of '.$type);
+  }
+
   /** @return string */
   public function hashCode() { return md5($this->name); }
 

src/test/php/lang/reflection/unittest/PackageTest.class.php

@@ -1,10 +1,19 @@
 <?php namespace lang\reflection\unittest;
 
-use lang\IllegalArgumentException;
 use lang\reflection\Package;
+use lang\reflection\unittest\fixture\{Instruction, CreateInstruction};
+use lang\{Reflection, IllegalArgumentException};
 use test\{Assert, Expect, Test, Values};
 
 class PackageTest {
+  const FIXTURES= 'lang.reflection.unittest.fixture';
+
+  /** @return iterable */
+  private function instructions() {
+    yield [Instruction::class, 'class literal'];
+    yield ['lang.reflection.unittest.fixture.Instruction', 'class name'];
+    yield [Reflection::type(Instruction::class), 'type'];
+  }
 
   #[Test, Values(['lang.reflection', 'lang\reflection', 'lang.reflection.'])]
   public function name($arg) {
@@ -90,16 +99,42 @@ public function types() {
 
   #[Test]
   public function type_via_short_name() {
-    Assert::equals(self::class, (new Package(__NAMESPACE__))->type('PackageTest')->literal());
+    Assert::equals(Reflection::type(self::class), (new Package(__NAMESPACE__))->type('PackageTest'));
   }
 
   #[Test]
   public function type_via_full_name() {
-    Assert::equals(self::class, (new Package(__NAMESPACE__))->type(self::class)->literal());
+    Assert::equals(Reflection::type(self::class), (new Package(__NAMESPACE__))->type(self::class));
   }
 
   #[Test, Expect(class: IllegalArgumentException::class, message: 'Given type util.Date is not in package lang')]
   public function type_with_namespace() {
     (new Package('lang'))->type('util.Date');
   }
+
+  #[Test, Values(from: 'instructions')]
+  public function implementation_by_name($type) {
+    Assert::equals(
+      Reflection::type(CreateInstruction::class),
+      (new Package(self::FIXTURES))->implementation($type, 'CreateInstruction')
+    );
+  }
+
+  #[Test, Values(from: 'instructions')]
+  public function implementation_by_class($type) {
+    Assert::equals(
+      Reflection::type(CreateInstruction::class),
+      (new Package(self::FIXTURES))->implementation($type, CreateInstruction::class)
+    );
+  }
+
+  #[Test, Expect(class: IllegalArgumentException::class, message: '/Given type util.Date is not in package .+/')]
+  public function implementation_not_in_package() {
+    (new Package(self::FIXTURES))->implementation(Instruction::class, 'util.Date');
+  }
+
+  #[Test, Expect(class: IllegalArgumentException::class, message: '/Given type .+ is not an implementation of lang.Runnable/')]
+  public function not_an_implementation() {
+    (new Package(self::FIXTURES))->implementation('lang.Runnable', 'CreateInstruction');
+  }
 }

src/test/php/lang/reflection/unittest/fixture/CreateInstruction.class.php

@@ -0,0 +1,5 @@
+<?php namespace lang\reflection\unittest\fixture;
+
+class CreateInstruction implements Instruction {
+  
+}

src/test/php/lang/reflection/unittest/fixture/Instruction.class.php

@@ -0,0 +1,5 @@
+<?php namespace lang\reflection\unittest\fixture;
+
+interface Instruction {
+  
+}