Updated implementations and tests after rework

mecha · Nov 14, 2019 · Nov 14, 2019 · Nov 14, 2019 · Nov 14, 2019 · Nov 14, 2019
commit 389ffb880ef1b680395fe84318d6b31f9d817d9f
diff --git a/src/Factories/AbstractFactory.php b/src/Factories/AbstractFactory.php
diff --git a/src/Factories/Callback.php b/src/Factories/Callback.php
diff --git a/src/Services/AbstractService.php b/src/Services/AbstractService.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace Dhii\Modular\Module\Services;
+
+use Dhii\Modular\Module\ServiceInterface;
+use Psr\Container\ContainerInterface;
+
+/**
+ * A partial implementation of a service, that is aware of a list of dependency keys.
+ *
+ * @since [*next-version*]
+ */
+abstract class AbstractService implements ServiceInterface
+{
+    /**
+     * @since [*next-version*]
+     *
+     * @var string[]
+     */
+    protected $dependencies;
+
+    /**
+     * Constructor.
+     *
+     * @since [*next-version*]
+     *
+     * @param string[] $dependencies The keys of dependent services.
+     */
+    public function __construct(array $dependencies)
+    {
+        $this->dependencies = $dependencies;
+    }
+
+    /**
+     * @inheritdoc
+     *
+     * @since [*next-version*]
+     */
+    public function getDependencies() : array
+    {
+        return $this->dependencies;
+    }
+
+    /**
+     * Resolves the dependency keys to their corresponding values from a container.
+     *
+     * @since [*next-version*]
+     *
+     * @param ContainerInterface $c The container from which to resolve service values.
+     *
+     * @return array An array of service values, in the same order as in {@link AbstractService::$dependencies}.
+     */
+    protected function resolveDependencies(ContainerInterface $c) : array
+    {
+        return array_map([$c, 'get'], $this->dependencies);
+    }
+}
diff --git a/src/Factories/Alias.php → src/Services/Alias.php b/src/Factories/Alias.php → src/Services/Alias.php
@@ -1,13 +1,29 @@
 <?php
 
-namespace Dhii\Modular\Module\Factories;
+namespace Dhii\Modular\Module\Services;
 
 use Dhii\Modular\Module\FactoryInterface;
 use Psr\Container\ContainerInterface;
 
 /**
  * A service factory that simply resolves to another existing service, and can optionally default to another factory.
  *
+ * Example usage:
+ *  ```
+ *  [
+ *      'service_a' => new Alias('service_b'),
+ *      'service_b' => function() {
+ *          return "hello";
+ *      }
+ *      'service_c' => new Alias('service_d', function () {
+ *          return "default";
+ *      }),
+ *  ]
+ *
+ *  $c->get('service_a'); // "hello"
+ *  $c->get('service_c'); // "default"
+ *  ```
+ *
  * @since [*next-version*]
  */
 class Alias implements FactoryInterface

diff --git a/src/Factories/Extension.php → src/Services/Extension.php b/src/Factories/Extension.php → src/Services/Extension.php
@@ -1,10 +1,11 @@
 <?php
 
-namespace Dhii\Modular\Module\Factories;
+namespace Dhii\Modular\Module\Services;
 
+use Dhii\Modular\Module\ExtensionInterface;
 use Psr\Container\ContainerInterface;
 
-class Extension extends AbstractFactory
+class Extension extends AbstractService implements ExtensionInterface
 {
     /**
      * @since [*next-version*]
@@ -37,8 +38,7 @@ public function __construct(array $dependencies, callable $factoryFn)
      */
     public function __invoke(ContainerInterface $c, $prev = null)
     {
-        $deps = array_map([$c, 'get'], $this->dependencies);
-        $args = array_merge([$prev], $deps);
+        $args = array_merge([$prev], $this->resolveDependencies($c));
 
         return call_user_func_array($this->factoryFn, $args);
     }

diff --git a/src/Factories/Service.php → src/Services/Factory.php b/src/Factories/Service.php → src/Services/Factory.php
@@ -1,15 +1,33 @@
 <?php
 
-namespace Dhii\Modular\Module\Factories;
+namespace Dhii\Modular\Module\Services;
 
+use Dhii\Modular\Module\FactoryInterface;
 use Psr\Container\ContainerInterface;
 
 /**
  * A standard service factory implementation.
  *
+ * Example usage:
+ *  ```
+ *  [
+ *      'service_a' => new Factory([], function () {
+ *          return 'hello';
+ *      }),
+ *      'service_b' => new Factory([], function () {
+ *          return 'world';
+ *      }),
+ *      'service_c' => new Factory(['service_a', 'service_b'], function ($a, $b) {
+ *          return "$a $b";
+ *      }),
+ *  ]
+ *
+ *  $c->get('service_c'); // "hello world"
+ *  ```
+ *
  * @since [*next-version*]
  */
-class Service extends AbstractFactory
+class Factory extends AbstractService implements FactoryInterface
 {
     /**
      * @since [*next-version*]
@@ -41,6 +59,6 @@ public function __construct(array $dependencies, callable $factoryFn)
      */
     public function __invoke(ContainerInterface $c)
     {
-        return call_user_func_array($this->factoryFn, array_map([$c, 'get'], $this->dependencies));
+        return call_user_func_array($this->factoryFn, $this->resolveDependencies($c));
     }
 }
diff --git a/src/Factories/FormatStr.php → src/Services/FormatStr.php b/src/Factories/FormatStr.php → src/Services/FormatStr.php
@@ -1,31 +1,28 @@
 <?php
 
-namespace Dhii\Modular\Module\Factories;
+namespace Dhii\Modular\Module\Services;
 
+use Dhii\Modular\Module\FactoryInterface;
 use Psr\Container\ContainerInterface;
 
 /**
  * A factory for string values. Supports interpolation with dependent service values.
  *
  * Example usage:
- *
- * ```
- * // Simple example
- * new FormatStr('Hello world');
- *
- * // Numeric dependencies example
- * new FormatStr('User name is: {0}', ['user_name_service']);
- *
- * // Associative dependencies example
- * new FormatStr('{day} {month}', [
- *     'day'   => 'date/day',
- *     'month' => 'date/month',
- * ]);
- * ```
+ *  ```
+ *  [
+ *      'service_a' => new FormatStr('John Smith'),
+ *      'service_b' => new FormatStr('User name is: {0}', ['service_a']),
+ *      'service_c' => new FormatStr('{day} {month}', [
+ *          'day'   => 'date/day',
+ *          'month' => 'date/month',
+ *      ]),
+ *  ]
+ *  ```
  *
  * @since [*next-version*]
  */
-class FormatStr extends AbstractFactory
+class FormatStr extends AbstractService implements FactoryInterface
 {
     /**
      * @since [*next-version*]

diff --git a/src/Factories/GlobalVar.php → src/Services/GlobalVar.php b/src/Factories/GlobalVar.php → src/Services/GlobalVar.php
@@ -1,13 +1,25 @@
 <?php
 
-namespace Dhii\Modular\Module\Factories;
+namespace Dhii\Modular\Module\Services;
 
 use Dhii\Modular\Module\FactoryInterface;
 use Psr\Container\ContainerInterface;
 
 /**
  * A service factory for referencing global variables.
  *
+ * Example usage:
+ *  ```
+ *  global $var;
+ *  $var = 5;
+ *
+ *  [
+ *      'service_a' => new GlobalVar('var')
+ *  ]
+ *
+ *  $c->get('service_a'); // 5
+ *  ```
+ *
  * @since [*next-version*]
  */
 class GlobalVar implements FactoryInterface

diff --git a/src/Services/Invocable.php b/src/Services/Invocable.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace Dhii\Modular\Module\Services;
+
+use Dhii\Modular\Module\FactoryInterface;
+use Psr\Container\ContainerInterface;
+
+/**
+ * A factory implementation that returns an invocable function.
+ *
+ * The callback's arguments will be equivalent to the service instances that correspond with the `Invocable` instance's
+ * dependency keys, in the order they are given. Those service are fetched only once when the `Invocable` is invoked and
+ * the callback is returned, not when the _returned_ callback is invoked. They are then "cached" in the returned
+ * callback's scope.
+ *
+ * Example usage:
+ *  ```
+ *  [
+ *      'service_a' => function () {
+ *          return "hello";
+ *      },
+ *      'service_b' => function () {
+ *          return "world";
+ *      },
+ *      'service_c' => new Invocable(['service_a', 'service_b'], function ($a, $b) {
+ *          return "$a $b";
+ *      })
+ *  ]
+ *
+ *  $fn = $c->get('service_c');
+ *  echo $fn(); // "hello world"
+ *  ```
+ *
+ * @since [*next-version*]
+ */
+class Invocable extends AbstractService implements FactoryInterface
+{
+    /**
+     * @since [*next-version*]
+     *
+     * @var callable
+     */
+    protected $function;
+
+    /**
+     * Constructor.
+     *
+     * @since [*next-version*]
+     *
+     * @param string[] $dependencies The keys of dependent services.
+     * @param callable $function     The function to return for this service.
+     */
+    public function __construct(array $dependencies, callable $function)
+    {
+        parent::__construct($dependencies);
+
+        $this->function = $function;
+    }
+
+    /**
+     * @inheritdoc
+     *
+     * @since [*next-version*]
+     */
+    public function __invoke(ContainerInterface $c)
+    {
+        $deps = $this->resolveDependencies($c);
+
+        return function () use ($deps) {
+            return ($this->function)(...$deps);
+        };
+    }
+}