Renderer::render() rather than Diff::render()

A renderer renders, but a diff does not.

Signed-off-by: Jack Cherng <jfcherng@gmail.com>

Author: jfcherng

README.md

@@ -91,7 +91,7 @@ $result = DiffHelper::calculate($old, $new, $template);
 // custom usage
 $diff = new Diff(explode("\n", $old), explode("\n", $new), $diffOptions);
 $renderer = RendererFactory::make($template, $templateOptions); // or your own renderers
-$result = $diff->render($renderer);
+$result = $renderer->render($diff);
 ```
 
 

UPGRADING/UPGRADING_v6.md

@@ -0,0 +1,14 @@
+## Upgrading to v6
+
+- Now `Renderer` has `::render()` API, but a `Diff` does not.
+  If you are only using the `DiffHelper`, there should be nothing changed for you.
+  But if you combine those classes by yourself, it should be wrote like below.
+
+  ```php
+  use Jfcherng\Diff\Diff;
+  use Jfcherng\Diff\Factory\RendererFactory;
+  
+  $diff = new Diff(explode("\n", $old), explode("\n", $new), $diffOptions);
+  $renderer = RendererFactory::make($template, $templateOptions);
+  $result = $renderer->render($diff); // <-- this has been changed
+  ```

src/Diff.php

@@ -21,7 +21,8 @@ final class Diff
      * @var array cached properties and their default values
      */
     private const CACHED_PROPERTIES = [
-        'groupedCodes' => null,
+        'groupedCodes' => [],
+        'oldNewComparison' => 0,
     ];
 
     /**
@@ -50,9 +51,14 @@ final class Diff
     private $sequenceMatcher;
 
     /**
-     * @var null|array array containing the generated opcodes for the differences between the two items
+     * @var int the result of comparing the old and the new with the spaceship operator
      */
-    private $groupedCodes;
+    private $oldNewComparison = 0;
+
+    /**
+     * @var array array containing the generated opcodes for the differences between the two items
+     */
+    private $groupedCodes = [];
 
     /**
      * @var array associative array of the default options available for the diff class and their default value
@@ -186,6 +192,16 @@ public function getOptions(): array
         return $this->options;
     }
 
+    /**
+     * Compare the old and the new with the spaceship operator.
+     *
+     * @return int
+     */
+    public function getOldNewComparison(): int
+    {
+        return $this->oldNewComparison;
+    }
+
     /**
      * Get the singleton.
      *
@@ -208,45 +224,32 @@ public static function getInstance(): self
      */
     public function getGroupedOpcodes(): array
     {
-        $this->finalize();
+        if (!empty($this->groupedCodes)) {
+            return $this->groupedCodes;
+        }
 
-        return $this->groupedCodes = $this->groupedCodes ??
-            $this->sequenceMatcher->getGroupedOpcodes($this->options['context']);
+        return $this->groupedCodes = $this->sequenceMatcher
+            ->getGroupedOpcodes($this->options['context']);
     }
 
     /**
-     * Render a diff using the supplied rendering class and return it.
+     * Claim this class has settled down which means properties will not
+     * be changed before doing diff calculations.
      *
-     * @param AbstractRenderer $renderer an instance of the rendering object to use for generating the diff
+     * Properties will be re-propagated to other classes. This method must be
+     * re-called after any property changed before doing calculations.
      *
-     * @return string the generated diff
-     */
-    public function render(AbstractRenderer $renderer): string
-    {
-        $this->finalize();
-
-        $renderer->setDiff($this);
-
-        // the "no difference" situation may happen frequently
-        // let's save some calculation if possible
-        return $this->old === $this->new
-            ? $renderer::getIdenticalResult()
-            : $renderer->render();
-    }
-
-    /**
-     * Claim this class is all set.
-     *
-     * Properties will be propagated to other classes. You must re-call
-     * this method after any property changed before doing calculation.
+     * This method is called in AbstractRenderer::render() automatically.
      *
      * @return self
      */
-    private function finalize(): self
+    public function finalize(): self
     {
         if ($this->isCacheDirty) {
             $this->resetCachedResults();
 
+            $this->oldNewComparison = $this->old <=> $this->new;
+
             $this->sequenceMatcher
                 ->setOptions($this->options)
                 ->setSequences($this->old, $this->new);

src/DiffHelper.php

@@ -132,10 +132,13 @@ public static function calculate(
         \is_string($old) && ($old = \explode("\n", $old));
         \is_string($new) && ($new = \explode("\n", $new));
 
-        return Diff::getInstance()
-            ->setOldNew($old, $new)
-            ->setOptions($diffOptions)
-            ->render(RendererFactory::getInstance($template)->setOptions($templateOptions));
+        return RendererFactory::getInstance($template)
+            ->setOptions($templateOptions)
+            ->render(
+                Diff::getInstance()
+                    ->setOldNew($old, $new)
+                    ->setOptions($diffOptions)
+            );
     }
 
     /**

src/Renderer/AbstractRenderer.php

@@ -136,6 +136,26 @@ public static function getIdenticalResult(): string
         return '';
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function render(Diff $diff): string
+    {
+        $this->diff = $diff->finalize();
+
+        // the "no difference" situation may happen frequently
+        return $this->diff->getOldNewComparison() === 0
+            ? static::getIdenticalResult()
+            : $this->renderWoker();
+    }
+
+    /**
+     * The real worker for self::render().
+     *
+     * @return string
+     */
+    abstract protected function renderWoker(): string;
+
     /**
      * Update the Language object.
      *

src/Renderer/Html/Inline.php

@@ -22,7 +22,7 @@ final class Inline extends AbstractHtml
     /**
      * {@inheritdoc}
      */
-    public function render(): string
+    protected function renderWoker(): string
     {
         $changes = $this->getChanges();
 

src/Renderer/Html/Json.php

@@ -27,7 +27,15 @@ final class Json extends AbstractHtml
     /**
      * {@inheritdoc}
      */
-    public function render(): string
+    public static function getIdenticalResult(): string
+    {
+        return '[]';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function renderWoker(): string
     {
         $changes = $this->getChanges();
 
@@ -41,14 +49,6 @@ public function render(): string
         );
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public static function getIdenticalResult(): string
-    {
-        return '[]';
-    }
-
     /**
      * Convert tags of changes to their string form for better readability.
      *

src/Renderer/Html/SideBySide.php

@@ -22,7 +22,7 @@ final class SideBySide extends AbstractHtml
     /**
      * {@inheritdoc}
      */
-    public function render(): string
+    protected function renderWoker(): string
     {
         $changes = $this->getChanges();
 

src/Renderer/RendererInterface.php

@@ -4,6 +4,8 @@
 
 namespace Jfcherng\Diff\Renderer;
 
+use Jfcherng\Diff\Diff;
+
 /**
  * Renderer Interface.
  */
@@ -12,7 +14,9 @@ interface RendererInterface
     /**
      * Render and return diff.
      *
+     * @param Diff $diff the diff object to be rendered
+     *
      * @return string
      */
-    public function render(): string;
+    public function render(Diff $diff): string;
 }

src/Renderer/Text/Context.php

@@ -34,7 +34,7 @@ final class Context extends AbstractText
     /**
      * {@inheritdoc}
      */
-    public function render(): string
+    protected function renderWoker(): string
     {
         $ret = '';