Make discovery more SOLID

Author: Nyholm

src/ClassDiscovery.php

@@ -2,93 +2,40 @@
 
 namespace Http\Discovery;
 
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Http\Discovery\Exception\StrategyUnavailableException;
 use Http\Discovery\Exception\NotFoundException;
-use Http\Discovery\Exception\PuliNotAvailableException;
-use Http\Discovery\FallbackStrategy\HttpClients;
-use Http\Discovery\FallbackStrategy\DiactorosFactory;
-use Http\Discovery\FallbackStrategy\GuzzleFactory;
-use Puli\Discovery\Api\Discovery;
+use Http\Discovery\Strategy\DiactorosFactory;
+use Http\Discovery\Strategy\GuzzleFactory;
+use Http\Discovery\Strategy\HttpClients;
+use Http\Discovery\Strategy\Puli;
 
 /**
  * Registry that based find results on class existence.
  *
  * @author David de Boer <[email protected]>
  * @author Márk Sági-Kazár <[email protected]>
+ * @author Tobias Nyholm <[email protected]>
  */
 abstract class ClassDiscovery
 {
     /**
-     * @var GeneratedPuliFactory
-     */
-    private static $puliFactory;
-
-    /**
-     * @var Discovery
-     */
-    private static $puliDiscovery;
-
-    /**
-     * @return GeneratedPuliFactory
-     */
-    public static function getPuliFactory()
-    {
-        if (null === self::$puliFactory) {
-            if (!defined('PULI_FACTORY_CLASS')) {
-                throw new PuliNotAvailableException('Puli Factory is not available');
-            }
-
-            $puliFactoryClass = PULI_FACTORY_CLASS;
-
-            if (!class_exists($puliFactoryClass)) {
-                throw new PuliNotAvailableException('Puli Factory class does not exist');
-            }
-
-            self::$puliFactory = new $puliFactoryClass();
-        }
-
-        return self::$puliFactory;
-    }
-
-    /**
-     * Sets the Puli factory.
+     * A list of strategies to find classes.
      *
-     * @param object $puliFactory
+     * @var array
      */
-    public static function setPuliFactory($puliFactory)
-    {
-        if (!is_callable([$puliFactory, 'createRepository']) || !is_callable([$puliFactory, 'createDiscovery'])) {
-            throw new \InvalidArgumentException('The Puli Factory must expose a repository and a discovery');
-        }
-
-        self::$puliFactory = $puliFactory;
-        self::$puliDiscovery = null;
-    }
+    public static $strategies = [
+        Puli::class,
+        HttpClients::class,
+        GuzzleFactory::class,
+        DiactorosFactory::class,
+    ];
 
     /**
-     * Resets the factory.
+     * Discovery cache to make the second time we use discovery faster.
+     * @var array
      */
-    public static function resetPuliFactory()
-    {
-        self::$puliFactory = null;
-        self::$puliDiscovery = null;
-    }
-
-    /**
-     * Returns the Puli discovery layer.
-     *
-     * @return Discovery
-     */
-    public static function getPuliDiscovery()
-    {
-        if (!isset(self::$puliDiscovery)) {
-            $factory = self::getPuliFactory();
-            $repository = $factory->createRepository();
-
-            self::$puliDiscovery = $factory->createDiscovery($repository);
-        }
-
-        return self::$puliDiscovery;
-    }
+    private static $cache = [];
 
     /**
      * Finds a class.
@@ -101,58 +48,62 @@ public static function getPuliDiscovery()
      */
     public static function findOneByType($type)
     {
-        try {
-            return self::puliFindOneByType($type);
-        } catch (PuliNotAvailableException $e) {
-            if (false !== $class = HttpClients::findOneByType($type)) {
-                return $class;
-            } elseif (false !== $class = GuzzleFactory::findOneByType($type)) {
-                return $class;
-            } elseif (false !== $class = DiactorosFactory::findOneByType($type)) {
-                return $class;
+        $exceptions = [];
+
+        if (null !== $class = self::getFromCache($type)) {
+            return $class;
+        }
+
+        foreach (self::$strategies as $strategy) {
+            try {
+                $bindings = call_user_func($strategy.'::find', $type);
+            } catch (StrategyUnavailableException $e) {
+                $exceptions[] = $e;
+                continue;
+            }
+
+            foreach ($bindings as $binding) {
+                if ($binding['condition']) {
+                    if (!self::evaluateCondition($binding['condition'])) {
+                        continue;
+                    }
+                }
+
+                // save the result for later use
+                self::storeInCache($type, $binding['class']);
+
+                return $binding['class'];
             }
-            throw new NotFoundException('Could not find resource using Puli nor common Guzzle/Diactoros classes', 0, $e);
         }
+
+        throw new DiscoveryFailedException('Could not find resource using any discovery strategy', $exceptions);
     }
 
     /**
-     * Finds a class using Puli.
+     * Get a value from cache
      *
-     * @param $type
-     *
-     * @return string
+     * @param string $type
      *
-     * @throws NotFoundException
-     * @throws PuliNotAvailableException
+     * @return string|null
      */
-    private static function puliFindOneByType($type)
+    private static function getFromCache($type)
     {
-        $bindings = self::getPuliDiscovery()->findBindings($type);
-
-        foreach ($bindings as $binding) {
-            if ($binding->hasParameterValue('depends')) {
-                $dependency = $binding->getParameterValue('depends');
-
-                if (!self::evaluateCondition($dependency)) {
-                    continue;
-                }
-            }
-
-            // TODO: check class binding
-            return $binding->getClassName();
+        if (isset(self::$cache[$type])) {
+            return self::$cache[$type];
         }
 
-        throw new NotFoundException(sprintf('Resource of type "%s" not found', $type));
+        return null;
     }
 
     /**
-     * Finds a resource.
+     * Store a value in cache
      *
-     * @return object
+     * @param string $type
+     * @param string $class
      */
-    public static function find()
+    private static function storeInCache($type, $class)
     {
-        throw new \LogicException('Not implemented');
+        self::$cache[$type] = $class;
     }
 
     /**

src/Exception/DiscoveryFailedException.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+/**
+ * Thrown when all discovery strategies fails to find a resource.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class DiscoveryFailedException extends \RuntimeException
+{
+    /**
+     * @var array
+     */
+    private $exceptions;
+
+    /**
+     *
+     * @param $exceptions
+     */
+    public function __construct($message, array $exceptions = [])
+    {
+        $this->exceptions = $exceptions;
+
+        parent::__construct($message, 0, array_shift($exceptions));
+    }
+
+    /**
+     * @return array
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
+}

src/Exception/PuliNotAvailableException.php renamed to src/Exception/PuliUnavailableException.php

@@ -7,6 +7,6 @@
  *
  * @author Tobias Nyholm <[email protected]>
  */
-class PuliNotAvailableException extends \RuntimeException
+class PuliUnavailableException extends StrategyUnavailableException
 {
 }

src/Exception/StrategyUnavailableException.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+/**
+ * This exception is thrown when we cannot use a discovery strategy. This is *not* thrown when
+ * the discovery fails to find a class. 
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+class StrategyUnavailableException extends \RuntimeException
+{
+
+}