Mistralys / text-diff

src/Diff.php

Indentation +95 added lines, -95 removed lines

@@ -42,14 +42,14 @@ 
     private string $string2;
     private bool $disposed = false;
 
-   /**
-    * @var string|string[]
-    */
+    /**
+     * @var string|string[]
+     */
     private $sequence1 = '';
     
-   /**
-    * @var string|string[]
-    */
+    /**
+     * @var string|string[]
+     */
     private $sequence2 = '';
     
     public function __construct(string $string1, string $string2)
@@ -58,13 +58,13 @@ 
         $this->string2 = $string2;
     }
     
-   /**
-    * Sets whether to compare single characters. Default is to 
-    * compare only lines.
-    * 
-    * @param bool $compare
-    * @return Diff
-    */
+    /**
+     * Sets whether to compare single characters. Default is to 
+     * compare only lines.
+     * 
+     * @param bool $compare
+     * @return Diff
+     */
     public function setCompareCharacters(bool $compare=true) : Diff
     {
         $this->compareCharacters = $compare;
@@ -72,19 +72,19 @@ 
         return $this;
     }
     
-   /**
-    * Returns the diff for two strings. The return value is an array, each of
-    * whose values are an array containing two values: a line (or character, if
-    * $compareCharacters is true), and one of the constants DIFF::UNMODIFIED (the
-    * line or character is in both strings), DIFF::DELETED (the line or character
-    * is only in the first string), and DIFF::INSERTED (the line or character is
-    * only in the second string).
-    * 
-    * @param string $string1
-    * @param string $string2
-    * @param bool $compareCharacters Whether to compare single characters (compares lines otherwise)
-    * @return Diff
-    */
+    /**
+     * Returns the diff for two strings. The return value is an array, each of
+     * whose values are an array containing two values: a line (or character, if
+     * $compareCharacters is true), and one of the constants DIFF::UNMODIFIED (the
+     * line or character is in both strings), DIFF::DELETED (the line or character
+     * is only in the first string), and DIFF::INSERTED (the line or character is
+     * only in the second string).
+     * 
+     * @param string $string1
+     * @param string $string2
+     * @param bool $compareCharacters Whether to compare single characters (compares lines otherwise)
+     * @return Diff
+     */
     public static function compareStrings(string $string1, string $string2, bool $compareCharacters = false) : Diff
     {
         $diff = new Diff($string1, $string2);
@@ -92,16 +92,16 @@ 
         return $diff;
     }
     
-   /**
-    * Like {@see Diff::compare()}, but returns the diff for two files.
-    *
-    * @param string $file1
-    * @param string $file2
-    * @param bool $compareCharacters Whether to compare single characters (compares lines otherwise)
-    * @return Diff
-    *
-    * @throws FileHelper_Exception If one of the files cannot be found or opened.
-    */
+    /**
+     * Like {@see Diff::compare()}, but returns the diff for two files.
+     *
+     * @param string $file1
+     * @param string $file2
+     * @param bool $compareCharacters Whether to compare single characters (compares lines otherwise)
+     * @return Diff
+     *
+     * @throws FileHelper_Exception If one of the files cannot be found or opened.
+     */
     public static function compareFiles(string $file1, string $file2, bool $compareCharacters = false) : Diff
     {
         return self::compareStrings(
@@ -111,13 +111,13 @@ 
         );
     }
     
-   /**
-    * Creates an instance of the styler class, which
-    * is used to access the CSS used for the syntax
-    * highlighting in the HTML renderers.
-    * 
-    * @return Styler
-    */
+    /**
+     * Creates an instance of the styler class, which
+     * is used to access the CSS used for the syntax
+     * highlighting in the HTML renderers.
+     * 
+     * @return Styler
+     */
     public static function createStyler() : Styler
     {
         return new Styler();
@@ -225,13 +225,13 @@ 
         return $diff;
     }
     
-   /**
-    * Splits the string into individual lines.
-    * 
-    * @param string $string
-    * @throws DiffException
-    * @return string[]
-    */
+    /**
+     * Splits the string into individual lines.
+     * 
+     * @param string $string
+     * @throws DiffException
+     * @return string[]
+     */
     public static function splitLines(string $string) : array
     {
         $split = preg_split('/\R/u', $string);
@@ -271,15 +271,15 @@ 
         );
     }
     
-   /**
-    * Returns the table of the longest common subsequence lengths
-    * for the specified sequences.
-    * 
-    * @param int $start
-    * @param int $end1
-    * @param int $end2
-    * @return array<int,array<int,int>>
-    */
+    /**
+     * Returns the table of the longest common subsequence lengths
+     * for the specified sequences.
+     * 
+     * @param int $start
+     * @param int $end1
+     * @param int $end2
+     * @return array<int,array<int,int>>
+     */
     private function computeTable(int $start, int $end1, int $end2) : array
     {
         // determine the lengths to be compared
@@ -313,14 +313,14 @@ 
         return $table;
     }
     
-   /**
-    * Returns the partial diff for the specified sequences, in reverse order.
-    * 
-    * @param int $start
-    * @param int $end1
-    * @param int $end2
-    * @return array<int,array<int,int|string>>
-    */
+    /**
+     * Returns the partial diff for the specified sequences, in reverse order.
+     * 
+     * @param int $start
+     * @param int $end1
+     * @param int $end2
+     * @return array<int,array<int,int|string>>
+     */
     private function generatePartialDiff(int $start, int $end1, int $end2) : array
     {
         // compute the table of the longest common subsequence lengths
@@ -367,13 +367,13 @@ 
         return $diff;
     }
     
-   /**
-    * Returns a diff as a string, where unmodified lines are prefixed by '  ',
-    * deletions are prefixed by '- ', and insertions are prefixed by '+ '.
-    * 
-    * @param string $separator
-    * @return string
-    */
+    /**
+     * Returns a diff as a string, where unmodified lines are prefixed by '  ',
+     * deletions are prefixed by '- ', and insertions are prefixed by '+ '.
+     * 
+     * @param string $separator
+     * @return string
+     */
     public function toString(string $separator = "\n") : string
     {
         $renderer = new PlainText($this);
@@ -382,14 +382,14 @@ 
         return $renderer->render();
     }
     
-   /**
-    * Returns a diff as an HTML string, where unmodified lines are contained
-    * within 'span' elements, deletions are contained within 'del' elements, and
-    * insertions are contained within 'ins' elements.
-    * 
-    * @param string $separator
-    * @return string
-    */
+    /**
+     * Returns a diff as an HTML string, where unmodified lines are contained
+     * within 'span' elements, deletions are contained within 'del' elements, and
+     * insertions are contained within 'ins' elements.
+     * 
+     * @param string $separator
+     * @return string
+     */
     public function toHTML(string $separator = '<br>') : string
     {
         $renderer = new HTML($this);
@@ -398,13 +398,13 @@ 
         return $renderer->render();
     }
     
-   /**
-    * Returns a diff as an HTML table.
-    * 
-    * @param string $indentation
-    * @param string $separator
-    * @return string
-    */
+    /**
+     * Returns a diff as an HTML table.
+     * 
+     * @param string $indentation
+     * @param string $separator
+     * @return string
+     */
     public function toHTMLTable(string $indentation = '', string $separator = '<br>') : string
     {
         $renderer = new HTMLTable($this);
@@ -414,12 +414,12 @@ 
         return $renderer->render();
     }
     
-   /**
-    * Disposes of the diff by clearing the stored strings,
-    * to free memory until the class is destructed.
-    * 
-    * @return Diff
-    */
+    /**
+     * Disposes of the diff by clearing the stored strings,
+     * to free memory until the class is destructed.
+     * 
+     * @return Diff
+     */
     public function dispose() : Diff
     {
         $this->string1 = '';

Spacing +18 added lines, -18 removed lines

@@ -65,7 +65,7 @@ 
     * @param bool $compare
     * @return Diff
     */
-    public function setCompareCharacters(bool $compare=true) : Diff
+    public function setCompareCharacters(bool $compare = true) : Diff
     {
         $this->compareCharacters = $compare;
         
@@ -157,7 +157,7 @@ 
      */
     public function toArray() : array
     {
-        if($this->disposed)
+        if ($this->disposed)
         {
             throw new DiffException(
                 'The diff has been disposed.',
@@ -187,14 +187,14 @@ 
         // skip any common prefix
         while ($start <= $end1 && $start <= $end2 && $this->sequence1[$start] === $this->sequence2[$start])
         {
-            $start ++;
+            $start++;
         }
         
         // skip any common suffix
         while ($end1 >= $start && $end2 >= $start && $this->sequence1[$end1] === $this->sequence2[$end2])
         {
-            $end1 --;
-            $end2 --;
+            $end1--;
+            $end2--;
         }
         
         // generate the partial diff
@@ -203,7 +203,7 @@ 
         // generate the full diff
         $diff = array();
         
-        for ($index = 0; $index < $start; $index ++)
+        for ($index = 0; $index < $start; $index++)
         {
             $diff[] = array($this->sequence1[$index], self::UNMODIFIED);
         }
@@ -213,7 +213,7 @@ 
             $diff[] = array_pop($partialDiff);
         }
         
-        for ($index = $end1 + 1; $index < $totalSequence; $index ++)
+        for ($index = $end1 + 1; $index < $totalSequence; $index++)
         {
             $diff[] = array($this->sequence1[$index], self::UNMODIFIED);
         }
@@ -236,7 +236,7 @@ 
     {
         $split = preg_split('/\R/u', $string);
         
-        if(is_array($split))
+        if (is_array($split))
         {
             return $split;
         }
@@ -259,7 +259,7 @@ 
     {
         $split = mb_str_split($string);
 
-        if(is_array($split))
+        if (is_array($split))
         {
             return $split;
         }
@@ -290,19 +290,19 @@ 
         $table = array(array_fill(0, $length2 + 1, 0));
         
         // loop over the rows
-        for ($index1 = 1; $index1 <= $length1; $index1 ++){
+        for ($index1 = 1; $index1 <= $length1; $index1++) {
             
             // create the new row
             $table[$index1] = array(0);
             
             // loop over the columns
-            for ($index2 = 1; $index2 <= $length2; $index2 ++){
+            for ($index2 = 1; $index2 <= $length2; $index2++) {
                 
                 // store the longest common subsequence length
                 if ($this->sequence1[$index1 + $start - 1]
-                    === $this->sequence2[$index2 + $start - 1]){
+                    === $this->sequence2[$index2 + $start - 1]) {
                         $table[$index1][$index2] = $table[$index1 - 1][$index2 - 1] + 1;
-                }else{
+                } else {
                     $table[$index1][$index2] =
                     max($table[$index1 - 1][$index2], $table[$index1][$index2 - 1]);
                 }
@@ -341,11 +341,11 @@ 
                 $index1 > 0 && $index2 > 0
                 && $this->sequence1[$index1 + $start - 1]
                 === $this->sequence2[$index2 + $start - 1]
-            ){
+            ) {
                 // update the diff and the indices
                 $diff[] = array($this->sequence1[$index1 + $start - 1], self::UNMODIFIED);
-                $index1 --;
-                $index2 --;
+                $index1--;
+                $index2--;
             }
             elseif (
                 $index2 > 0
@@ -353,13 +353,13 @@ 
             ) {
                 // update the diff and the indices
                 $diff[] = array($this->sequence2[$index2 + $start - 1], self::INSERTED);
-                $index2 --;
+                $index2--;
             }
             else
             {
                 // update the diff and the indices
                 $diff[] = array($this->sequence1[$index1 + $start - 1], self::DELETED);
-                $index1 --;
+                $index1--;
             }
         }