php-school · AydinHassan · Jan 24, 2016 · Jan 24, 2016
diff --git a/app/config.php b/app/config.php
@@ -22,6 +22,7 @@
 use PhpSchool\PhpWorkshop\ExerciseDispatcher;
 use PhpSchool\PhpWorkshop\Factory\EventDispatcherFactory;
 use PhpSchool\PhpWorkshop\Factory\MenuFactory;
+use PhpSchool\PhpWorkshop\Factory\ResultRendererFactory;
 use PhpSchool\PhpWorkshop\Factory\RunnerFactory;
 use PhpSchool\PhpWorkshop\Listener\CodePatchListener;
 use PhpSchool\PhpWorkshop\Listener\PrepareSolutionListener;
@@ -242,28 +243,16 @@
             $c->get(OutputInterface::class)
         );
     }),
+    ResultRendererFactory::class => object(),
     ResultsRenderer::class => factory(function (ContainerInterface $c) {
-        $renderer = new ResultsRenderer(
+        return new ResultsRenderer(
             $c->get('appName'),
             $c->get(Color::class),
             $c->get(TerminalInterface::class),
             $c->get(ExerciseRepository::class),
-            $c->get(SyntaxHighlighter::class)
+            $c->get(SyntaxHighlighter::class),
+            $c->get(ResultRendererFactory::class)
         );
-
-        foreach ($c->get('renderers') as $resultRenderer) {
-            $renderer->registerRenderer(...$resultRenderer);
-        }
-        return $renderer;
-    }),
-    'renderers' => factory(function (ContainerInterface $c) {
-        return [
-            [StdOutFailure::class, new OutputFailureRenderer],
-            [CgiOutResult::class, new CgiOutResultRenderer],
-            [FunctionRequirementsFailure::class, new FunctionRequirementsFailureRenderer],
-            [Success::class, new SuccessRenderer],
-            [Failure::class, new FailureRenderer],
-        ];
     }),
     'coreContributors' => [
         '@AydinHassan' => 'Aydin Hassan',

diff --git a/src/Application.php b/src/Application.php
@@ -33,11 +33,6 @@ final class Application
      */
     private $exercises = [];
 
-    /**
-     * @var array
-     */
-    private $renderers = [];
-
     /**
      * @var string
      */
@@ -86,16 +81,6 @@ public function addExercise($exercise)
         $this->exercises[] = $exercise;
     }
 
-    /**
-     * @param ResultRendererInterface $renderer
-     * @param string $resultClass
-     */
-    public function addRenderer(ResultRendererInterface $renderer, $resultClass)
-    {
-        //TODO Use reflection to check that $resultClass exists and implements ResultInterface
-        $this->renderers[] = [$renderer, $resultClass];
-    }
-
     /**
      * @param string $logo
      */
@@ -154,9 +139,6 @@ public function run()
                 );
             }
         }
-
-        $renderers = $container->get('renderers');
-        $container->set('renderers', array_merge($renderers, $this->renderers));
 
         $checkRepository = $container->get(CheckRepository::class);
         array_walk($this->checks, function (CheckInterface $check) use ($checkRepository) {

diff --git a/src/Factory/ResultRendererFactory.php b/src/Factory/ResultRendererFactory.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\Factory;
+
+use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
+use PhpSchool\PhpWorkshop\Result\CgiOutResult;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\FunctionRequirementsFailure;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\StdOutFailure;
+use PhpSchool\PhpWorkshop\ResultRenderer\CgiOutResultRenderer;
+use PhpSchool\PhpWorkshop\ResultRenderer\FailureRenderer;
+use PhpSchool\PhpWorkshop\ResultRenderer\FunctionRequirementsFailureRenderer;
+use PhpSchool\PhpWorkshop\ResultRenderer\OutputFailureRenderer;
+use PhpSchool\PhpWorkshop\ResultRenderer\ResultRendererInterface;
+
+/**
+ * Class ResultRendererFactory
+ * @package PhpSchool\PhpWorkshop\Factory
+ * @author Aydin Hassan <[email protected]>
+ */
+class ResultRendererFactory
+{
+    /**
+     * @var array
+     */
+    private $mappings = [
+        StdOutFailure::class                => OutputFailureRenderer::class,
+        CgiOutResult::class                 => CgiOutResultRenderer::class,
+        FunctionRequirementsFailure::class  => FunctionRequirementsFailureRenderer::class,
+        Failure::class                      => FailureRenderer::class,
+    ];
+
+    /**
+     * @param string $resultClass
+     * @param string $rendererClass
+     */
+    public function registerRenderer($resultClass, $rendererClass)
+    {
+        if (!class_implements($resultClass, ResultInterface::class)) {
+            throw new InvalidArgumentException;
+        }
+
+        if (!class_implements($rendererClass, ResultRendererInterface::class)) {
+            throw new InvalidArgumentException;
+        }
+
+        $this->mappings[$resultClass] = $rendererClass;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @return ResultRendererInterface
+     */
+    public function create(ResultInterface $result)
+    {
+        $class = get_class($result);
+        if (!isset($this->mappings[$class])) {
+            throw new \RuntimeException(sprintf('No renderer found for "%s"', $class));
+        }
+
+        return new $this->mappings[$class]($result);
+    }
+}
diff --git a/src/ResultRenderer/CgiOutResultRenderer.php b/src/ResultRenderer/CgiOutResultRenderer.php
@@ -16,17 +16,25 @@ class CgiOutResultRenderer implements ResultRendererInterface
 {
 
     /**
-     * @param ResultInterface $result
+     * @var CgiOutResult
+     */
+    private $result;
+
+    /**
+     * @param CgiOutResult $result
+     */
+    public function __construct(CgiOutResult $result)
+    {
+        $this->result = $result;
+    }
+
+    /**
      * @param ResultsRenderer $renderer
      * @return string
      */
-    public function render(ResultInterface $result, ResultsRenderer $renderer)
+    public function render(ResultsRenderer $renderer)
     {
-        if (!$result instanceof CgiOutResult) {
-            throw new \InvalidArgumentException(sprintf('Incompatible result type: %s', get_class($result)));
-        }
-
-        $results = array_filter($result->getIterator()->getArrayCopy(), function (ResultInterface $result) {
+        $results = array_filter($this->result->getIterator()->getArrayCopy(), function (ResultInterface $result) {
             return $result instanceof FailureInterface;
         });
 

diff --git a/src/ResultRenderer/FailureRenderer.php b/src/ResultRenderer/FailureRenderer.php
@@ -11,18 +11,25 @@
  */
 class FailureRenderer implements ResultRendererInterface
 {
+    /**
+     * @var Failure
+     */
+    private $result;
+
+    /**
+     * @param Failure $result
+     */
+    public function __construct(Failure $result)
+    {
+        $this->result = $result;
+    }
 
     /**
-     * @param ResultInterface $result
      * @param ResultsRenderer $renderer
      * @return string
      */
-    public function render(ResultInterface $result, ResultsRenderer $renderer)
+    public function render(ResultsRenderer $renderer)
     {
-        if (!$result instanceof Failure) {
-            throw new \InvalidArgumentException(sprintf('Incompatible result type: %s', get_class($result)));
-        }
-
-        return '  ' . $result->getReason() . "\n";
+        return '  ' . $this->result->getReason() . "\n";
     }
 }
diff --git a/src/ResultRenderer/FunctionRequirementsFailureRenderer.php b/src/ResultRenderer/FunctionRequirementsFailureRenderer.php
@@ -3,7 +3,6 @@
 namespace PhpSchool\PhpWorkshop\ResultRenderer;
 
 use PhpSchool\PhpWorkshop\Result\FunctionRequirementsFailure;
-use PhpSchool\PhpWorkshop\Result\ResultInterface;
 
 /**
  * Class FunctionRequirementsFailureRenderer
@@ -12,20 +11,27 @@
  */
 class FunctionRequirementsFailureRenderer implements ResultRendererInterface
 {
+    /**
+     * @var FunctionRequirementsFailure
+     */
+    private $result;
+
+    /**
+     * @param FunctionRequirementsFailure $result
+     */
+    public function __construct(FunctionRequirementsFailure $result)
+    {
+        $this->result = $result;
+    }
 
     /**
-     * @param ResultInterface $result
      * @param ResultsRenderer $renderer
      * @return string
      */
-    public function render(ResultInterface $result, ResultsRenderer $renderer)
+    public function render(ResultsRenderer $renderer)
     {
-        if (!$result instanceof FunctionRequirementsFailure) {
-            throw new \InvalidArgumentException(sprintf('Incompatible result type: %s', get_class($result)));
-        }
-
         $output = '';
-        if (count($bannedFunctions = $result->getBannedFunctions())) {
+        if (count($bannedFunctions = $this->result->getBannedFunctions())) {
             $output .= sprintf(
                 "  %s\n%s\n",
                 $renderer->style(
@@ -38,7 +44,7 @@ public function render(ResultInterface $result, ResultsRenderer $renderer)
             );
         }
 
-        if (count($missingFunctions = $result->getMissingFunctions())) {
+        if (count($missingFunctions = $this->result->getMissingFunctions())) {
             $output .= sprintf(
                 "  %s\n%s\n",
                 $renderer->style(

diff --git a/src/ResultRenderer/OutputFailureRenderer.php b/src/ResultRenderer/OutputFailureRenderer.php
@@ -3,7 +3,6 @@
 namespace PhpSchool\PhpWorkshop\ResultRenderer;
 
 use PhpSchool\PhpWorkshop\Result\CgiOutBodyFailure;
-use PhpSchool\PhpWorkshop\Result\ResultInterface;
 use PhpSchool\PhpWorkshop\Result\StdOutFailure;
 
 /**
@@ -14,22 +13,30 @@ class OutputFailureRenderer implements ResultRendererInterface
 {
 
     /**
-     * @param ResultInterface $result
+     * @var StdOutFailure
+     */
+    private $result;
+
+    /**
+     * @param StdOutFailure $result
+     */
+    public function __construct(StdOutFailure $result)
+    {
+        $this->result = $result;
+    }
+
+    /**
      * @param ResultsRenderer $renderer
      * @return string
      */
-    public function render(ResultInterface $result, ResultsRenderer $renderer)
+    public function render(ResultsRenderer $renderer)
     {
-        if (!$result instanceof StdOutFailure) {
-            throw new \InvalidArgumentException(sprintf('Incompatible result type: %s', get_class($result)));
-        }
-
         return sprintf(
             "  %s\n%s\n\n  %s\n%s\n",
             $renderer->style("ACTUAL", ['bold', 'underline', 'yellow']),
-            $this->indent($renderer->style(sprintf('"%s"', $result->getActualOutput()), 'red')),
+            $this->indent($renderer->style(sprintf('"%s"', $this->result->getActualOutput()), 'red')),
             $renderer->style("EXPECTED", ['yellow', 'bold', 'underline']),
-            $this->indent($renderer->style(sprintf('"%s"', $result->getExpectedOutput()), 'red'))
+            $this->indent($renderer->style(sprintf('"%s"', $this->result->getExpectedOutput()), 'red'))
         );
     }
 

diff --git a/src/ResultRenderer/ResultRendererInterface.php b/src/ResultRenderer/ResultRendererInterface.php
@@ -12,9 +12,8 @@ interface ResultRendererInterface
 {
 
     /**
-     * @param ResultInterface $result
      * @param ResultsRenderer $renderer
      * @return string
      */
-    public function render(ResultInterface $result, ResultsRenderer $renderer);
+    public function render(ResultsRenderer $renderer);
 }