Start option to ignore blank lines

DigiLive · JBlond · commit 7b2ab7977148 · 2021-01-19T16:04:35.000+01:00
* Add option `ignoreLines` to control the ability to ignore blank or
  empty lines.
* Add styles of ignored lines to example css.
* Add generator for ignored lines to HTML SideBySide renderer.
* Add `options` property to the Sequence Mather.
* Refactor option `ignoreNewLines` of the Sequence Matcher.
* Add flags to define the level of ignoring blank lines.
* Add tag `ignored` to the opCodes.
* Add method stripLines to Similarity.
* Add default option `ignoreLines` to Diff.
* Add tests for testing option `ignoreLines` of the Sequence Matcher.
* Reformat code.
diff --git a/example/dark-theme.css b/example/dark-theme.css
@@ -97,6 +97,19 @@ a, a:visited {
     background: #EEBB00;
 }
 
+.DifferencesSideBySide .ChangeIgnore .Left,
+.DifferencesSideBySide .ChangeIgnore .Right {
+    background: #FBF2BF;
+}
+
+.DifferencesSideBySide .ChangeIgnore .Left.Ignore {
+    background: #4B4C57;
+}
+
+.DifferencesSideBySide .ChangeIgnore .Right.Ignore {
+    background: #4B4C57;
+}
+
 /*
  * HTML Unified Diff
  */
diff --git a/example/example.php b/example/example.php
@@ -20,6 +20,7 @@
     'trimEqual'        => false,
     'ignoreWhitespace' => true,
     'ignoreCase'       => true,
+    'ignoreLines'      => Diff::DIFF_IGNORE_LINE_EMPTY,
 ];
 
 // Choose one of the initializations.
diff --git a/example/styles.css b/example/styles.css
@@ -6,43 +6,43 @@ body {
 }
 
 pre {
-    width:    100%;
     overflow: auto;
+    width:    100%;
 }
 
 /*
  * HTML Renderers - General
  */
 
 .Differences {
-    width:           100%;
     border-collapse: collapse;
     border-spacing:  0;
     empty-cells:     show;
+    width:           100%;
 }
 
 .Differences thead th {
-    text-align:    left;
-    border-bottom: 1px solid #000000;
     background:    #AAAAAA;
+    border-bottom: 1px solid #000000;
     color:         #000000;
     padding:       4px;
+    text-align:    left;
 }
 
 .Differences tbody th {
-    text-align:     right;
     background:     #CCCCCC;
-    width:          4em;
-    padding:        1px 2px;
     border-right:   1px solid #000000;
-    vertical-align: top;
     font-size:      13px;
+    padding:        1px 2px;
+    text-align:     right;
+    vertical-align: top;
+    width:          4em;
 }
 
 .Differences td {
-    padding:     1px 2px;
     font-family: Consolas, monospace;
     font-size:   13px;
+    padding:     1px 2px;
 }
 
 .Differences .Skipped {
@@ -77,6 +77,19 @@ pre {
     background: #FFDD88;
 }
 
+.DifferencesSideBySide .ChangeIgnore .Left,
+.DifferencesSideBySide .ChangeIgnore .Right {
+    background: #FBF2BF;
+}
+
+.DifferencesSideBySide .ChangeIgnore .Left.Ignore {
+    background: #F7F7F7;
+}
+
+.DifferencesSideBySide .ChangeIgnore .Right.Ignore {
+    background: #F7F7F7;
+}
+
 .Differences ins,
 .Differences del {
     text-decoration: none;
diff --git a/lib/jblond/Diff.php b/lib/jblond/Diff.php
@@ -28,6 +28,18 @@
  */
 class Diff
 {
+    /**
+     * Flag to disable ignore of successive empty/blank lines.
+     */
+    public const DIFF_IGNORE_LINE_NONE = 0;
+    /**
+     * Flag to ignore successive empty lines.
+     */
+    public const DIFF_IGNORE_LINE_EMPTY = 1;
+    /**
+     * Flag to ignore successive blank lines. (Lines which contain no or only non printable characters.)
+     */
+    public const DIFF_IGNORE_LINE_BLANK = 2;
     /**
      * @var array   The first version to compare.
      *              Each element contains a line of this string.
@@ -48,18 +60,20 @@ class Diff
     /**
      * @var array Associative array containing the default options available for the diff class and their default value.
      *
-     *              - context           The amount of lines to include around blocks that differ.
-     *              - trimEqual         Strip blocks of equal lines from the start and end of the text.
-     *              - ignoreWhitespace  When true, tabs and spaces are ignored while comparing.
-     *                                  The spacing of version1 is leading.
-     *              - ignoreCase        When true, character casing is ignored while comparing.
-     *                                  The casing of version1 is leading.
+     *            - context           The amount of lines to include around blocks that differ.
+     *            - trimEqual         Strip blocks of equal lines from the start and end of the text.
+     *            - ignoreWhitespace  True to ignore differences in tabs and spaces.
+     *            - ignoreCase        True to ignore differences in character casing.
+     *            - ignoreLines       0: None.
+     *                                1: Ignore empty lines.
+     *                                2: Ignore blank lines.
      */
     private $defaultOptions = [
         'context'          => 3,
         'trimEqual'        => true,
         'ignoreWhitespace' => false,
         'ignoreCase'       => false,
+        'ignoreLines'      => self::DIFF_IGNORE_LINE_NONE,
     ];
 
     /**
diff --git a/lib/jblond/Diff/Renderer/Html/SideBySide.php b/lib/jblond/Diff/Renderer/Html/SideBySide.php
@@ -282,4 +282,70 @@ public function generateDiffFooter(): string
     {
         return '</table>';
     }
+
+    /**
+     * @inheritDoc
+     *
+     * @return string Html code representing table rows showing ignored text.
+     */
+    public function generateLinesIgnore(array $changes): string
+    {
+        $html = '';
+
+        // Is below comparison result ever false?
+        if (count($changes['base']['lines']) >= count($changes['changed']['lines'])) {
+            foreach ($changes['base']['lines'] as $lineNo => $line) {
+                $fromLine    = $changes['base']['offset'] + $lineNo + 1;
+                $toLine      = '&nbsp;';
+                $changedLine = '&nbsp;';
+                if (isset($changes['changed']['lines'][$lineNo])) {
+                    $toLine      = $changes['changed']['offset'] + $lineNo + 1;
+                    $changedLine = $changes['changed']['lines'][$lineNo];
+                }
+
+                $html .= <<<HTML
+<tr>
+    <th>$fromLine</th>
+    <td class="Left">
+        <span>$line</span>
+    </td>
+    <th>$toLine</th>
+    <td class="Right Ignore">
+        <span>$changedLine</span>
+    </td>
+</tr>
+HTML;
+            }
+
+            return $html;
+        }
+
+        foreach ($changes['changed']['lines'] as $lineNo => $changedLine) {
+            $toLine   = $changes['changed']['offset'] + $lineNo + 1;
+            $fromLine = '&nbsp;';
+            $line     = '&nbsp;';
+            if (isset($changes['base']['lines'][$lineNo])) {
+                $fromLine = $changes['base']['offset'] + $lineNo + 1;
+                $line     = $changes['base']['lines'][$lineNo];
+            }
+
+            $line        = str_replace(["\0", "\1"], $this->options['deleteMarkers'], $line);
+            $changedLine = str_replace(["\0", "\1"], $this->options['insertMarkers'], $changedLine);
+
+            $html .= <<<HTML
+<tr>
+    <th>$fromLine</th>
+    <td class="Left Ignore">
+        <span>$line</span>
+    </td>
+    <th>$toLine</th>
+    <td class="Right">
+        <span>$changedLine</span>
+    </td>
+</tr>
+HTML;
+        }
+
+        return $html;
+    }
 }
diff --git a/lib/jblond/Diff/Renderer/MainRenderer.php b/lib/jblond/Diff/Renderer/MainRenderer.php
@@ -80,6 +80,10 @@ public function renderOutput(array $changes, object $subRenderer)
                     case 'replace':
                         $output .= $subRenderer->generateLinesReplace($change);
                         break;
+                    case 'ignore':
+                        // TODO: Keep backward compatible with renderers?
+                        $output .= $subRenderer->generateLinesIgnore($change);
+                        break;
                 }
 
                 $output .= $subRenderer->generateBlockFooter($change);
@@ -130,6 +134,8 @@ protected function renderSequences(): array
                  * insert  - The string in $newText from $startNew to $endNew should be inserted at $startOld in
                  *           $oldText.
                  * equal   - The two strings with the specified ranges are equal.
+                 * ignore  - The string in $oldText from $startOld to $endOld and
+                 *           the string in $newText from $startNew to $endNew are different, but considered to be equal.
                  */
 
                 $blockSizeOld = $endOld - $startOld;
diff --git a/lib/jblond/Diff/SequenceMatcher.php b/lib/jblond/Diff/SequenceMatcher.php
@@ -22,6 +22,18 @@
  */
 class SequenceMatcher
 {
+    /**
+     * Flag to disable ignore of successive empty/blank lines.
+     */
+    public const DIFF_IGNORE_LINE_NONE = 0;
+    /**
+     * Flag to ignore empty lines.
+     */
+    public const DIFF_IGNORE_LINE_EMPTY = 1;
+    /**
+     * Flag to ignore blank lines. (Lines which contain no or only non printable characters.)
+     */
+    public const DIFF_IGNORE_LINE_BLANK = 2;
     /**
      * @var array The first sequence to compare against.
      */
@@ -30,6 +42,13 @@ class SequenceMatcher
      * @var array The second sequence.
      */
     protected $new;
+    /**
+     * @var array   Associative array containing the options that will be applied for generating the diff.
+     *              The key-value pairs are set at the constructor of this class.
+     *
+     * @see SequenceMatcher::setOptions()
+     */
+    protected $options = [];
     /**
      * @var string|array Either a string or an array containing a callback function to determine
      * if a line is "junk" or not.
@@ -39,12 +58,10 @@ class SequenceMatcher
      * @var array Array of characters that are considered junk from the second sequence. Characters are the array key.
      */
     private $junkDict = [];
-
     /**
      * @var array Array of indices that do not contain junk elements.
      */
     private $b2j = [];
-
     /**
      * @var array A list of all of the op-codes for the differences between the compared strings.
      */
@@ -56,14 +73,22 @@ class SequenceMatcher
     private $matchingBlocks;
 
     /**
-     * @var array
+     * @var array Associative array containing the default options available for the diff class and their default value.
+     *
+     *            - context           The amount of lines to include around blocks that differ.
+     *            - trimEqual         Strip blocks of equal lines from the start and end of the text.
+     *            - ignoreWhitespace  True to ignore differences in tabs and spaces.
+     *            - ignoreCase        True to ignore differences in character casing.
+     *            - ignoreLines       0: None.
+     *                                1: Ignore empty lines.
+     *                                2: Ignore blank lines.
      */
     private $defaultOptions = [
         'context'          => 3,
         'trimEqual'        => true,
         'ignoreWhitespace' => false,
         'ignoreCase'       => false,
-        'ignoreNewLines'   => false,
+        'ignoreLines'      => self::DIFF_IGNORE_LINE_NONE,
     ];
 
     /**
@@ -330,6 +355,28 @@ public function getOpCodes(): array
                 $tag = 'insert';
             }
 
+            if ($this->options['ignoreLines']) {
+                $part1 = array_slice($this->old, $i, $ai - $i);
+                $part2 = array_slice($this->new, $j, $bj - $j);
+
+                if ($this->options['ignoreLines'] == 2) {
+                    array_walk($part1, function (&$line) {
+                        $line = trim($line);
+                    });
+                    array_walk($part2, function (&$line) {
+                        $line = trim($line);
+                    });
+                    unset($line);
+                }
+
+                if (
+                    ($tag == 'delete' && implode('', $part1) == '') ||
+                    ($tag == 'insert' && implode('', $part2) == '')
+                ) {
+                    $tag = 'ignore';
+                }
+            }
+
             if ($tag) {
                 $this->opCodes[] = [
                     $tag,
diff --git a/lib/jblond/Diff/Similarity.php b/lib/jblond/Diff/Similarity.php
@@ -71,6 +71,9 @@ public function getSimilarity(int $type = self::CALC_DEFAULT): float
             case self::CALC_FASTEST:
                 return $this->getRatioFastest();
             default:
+                if ($this->options['ignoreLines']) {
+                    $this->stripLines();
+                }
                 $matches = array_reduce(
                     $this->getMatchingBlocks(),
                     function ($carry, $item) {
@@ -80,6 +83,7 @@ function ($carry, $item) {
                 );
 
                 return $this->calculateRatio($matches, count($this->old) + count($this->new));
+                // TODO: Restore original (un-stripped) versions?
         }
     }
 
@@ -151,6 +155,33 @@ private function getRatioFastest(): float
         return $this->calculateRatio(min($aLength, $bLength), $aLength + $bLength);
     }
 
+    /**
+     * Strip empty or blank lines from the sequences to compare.
+     *
+     */
+    private function stripLines(): void
+    {
+        foreach (['old', 'new'] as $version) {
+            if ($this->options['ignoreLines'] == self::DIFF_IGNORE_LINE_BLANK) {
+                array_walk(
+                    $this->$version,
+                    function (&$line) {
+                        $line = trim($line);
+                    }
+                );
+                unset($line);
+            }
+
+            $this->$version = array_filter(
+                $this->$version,
+                function ($line) {
+                    return $line != '';
+                }
+            );
+        }
+
+        $this->setSequences(array_values($this->old), array_values($this->new));
+    }
 
     /**
      * Helper function to calculate the number of matches for Ratio().
diff --git a/tests/Diff/SequenceMatcherTest.php b/tests/Diff/SequenceMatcherTest.php
