Completed the ListDiff diffing functionality.

adamCaxy · adamCaxy · commit 71071c521c8f · 2015-09-22T12:47:14.000-05:00
diff --git a/demo/demo.js b/demo/demo.js
@@ -38,7 +38,6 @@ demo.controller('diffCtrl', ['$scope', '$http', '$sce', '$timeout', function ($s
         $scope.loading = true;
         $http.post('index.php', { oldText: $scope.oldText, newText: $scope.newText })
             .success(function (data) {
-                //alert(JSON.stringify(data));
                 $scope.diff = data.diff;
                 $scope.loading = false;
             });
diff --git a/demo/index.php b/demo/index.php
@@ -10,7 +10,7 @@
     'Caxy/HtmlDiff/HtmlDiff',
     'Caxy/HtmlDiff/Match',
     'Caxy/HtmlDiff/Operation',
-    'Caxy/HtmlDiff/ListDiff',
+    'Caxy/HtmlDiff/ListDiff'
 );
 
 foreach ($classes as $class) {
@@ -21,9 +21,8 @@
 
 if ($input) {
     $data = json_decode($input, true);
-    $diff = new HtmlDiff($_POST['oldText'], $_POST['newText'], 'UTF-8', array());
+    $diff = new HtmlDiff($data['oldText'], $data['newText'], 'UTF-8', array());
     $diff->build();
-    echo $diff->getDifference();die;
 
     header('Content-Type: application/json');
     echo json_encode(array('diff' => $diff->getDifference()));
diff --git a/lib/Caxy/HtmlDiff/HtmlDiff.php b/lib/Caxy/HtmlDiff/HtmlDiff.php
@@ -211,8 +211,7 @@ protected function diffElements($oldText, $newText)
     protected function diffList($oldText, $newText)
     {
         $diff = new ListDiff($oldText, $newText, $this->encoding, $this->isolatedDiffTags, $this->groupDiffs);
-        $diff->build();
-        return $diff->getDifference();
+        return $diff->build();
     }
 
     protected function processEqualOperation($operation)
diff --git a/lib/Caxy/HtmlDiff/ListDiff.php b/lib/Caxy/HtmlDiff/ListDiff.php
@@ -2,7 +2,6 @@
 
 namespace Caxy\HtmlDiff;
 
-
 class ListDiff extends HtmlDiff
 {
     protected $listWords = array();
@@ -18,23 +17,27 @@ class ListDiff extends HtmlDiff
     protected $list; // hold the old/new content of the content of the list
     protected $childLists; // contains the old/new child lists content within this list
     protected $textMatches; // contains the old/new text strings that match
-    //protected $childListObjects;
-    protected $listsIndex;
+    protected $listsIndex; // contains the indexed start positions of each list within word string.
     
+    /**
+     * We're using the same functions as the parent in build() to get us to the point of 
+     * manipulating the data within this class.
+     */
     public function build()
     {
-        ini_set('xdebug.var_display_max_depth', 5);
-        ini_set('xdebug.var_display_max_children', 256);
-        ini_set('xdebug.var_display_max_data', 1024);
-        // get content from li's
+        // Use the parent functions to get the data we need organized.
         $this->splitInputsToWords();
         $this->replaceIsolatedDiffTags();
         $this->indexNewWords();
+        // Now use the custom functions in this class to use the data and generate our diff.
         $this->diffListContent();
         
         return $this->content;
     }
     
+    /**
+     * Calls to the actual custom functions of this class, to diff list content.
+     */
     protected function diffListContent()
     {
         /* Format the list we're focusing on.
@@ -46,14 +49,22 @@ protected function diffListContent()
          * make sure we use placeholders to replace the nested lists
          */
         $this->replaceListIsolatedDiffTags();
-        // Set matches of lists.
+        /* Build a list of matches we can reference when we diff the contents of the lists.
+         * This is needed so that we each NEW list node is matched against the best possible OLD list node/
+         * It helps us determine whether the list was added, removed, or changed.
+         */
         $this->matchAndCompareLists();
-        // Create child lists objects
-        $this->createChildListObjects();
-        // Diff the child lists
+        /* Go through the list of matches, and diff the contents of each.
+         * Any nested lists would be sent to parent's diffList function, which creates a new listDiff class.
+         */
         $this->diff();
     }
     
+    /*
+     * This function is used to remove the wrapped ul, ol, or dl characters from this list
+     * and sets the listType as ul, ol, or dl, so that we can use it later.
+     * $list is being set here as well, as an array with the old and new version of this list content.
+     */
     protected function formatThisListContent()
     {
         foreach ($this->oldIsolatedDiffTags as $key => $diffTagArray) {
@@ -76,14 +87,24 @@ protected function formatThisListContent()
     
     protected function matchAndCompareLists()
     {
-        // Build childLists array of old/new content of lists.
+        /**
+         * Build the an array (childLists) to hold the contents of the list nodes within this list.
+         * This only holds the content of each list node.
+         */
         $this->buildChildLists();
         
+        /**
+         * Index the list, starting positions, so that we can refer back to it later.
+         * This is used to see where one list node starts and another ends.
+         */
         $this->indexLists();
-        // Compare the lists, saving total matches to textMatches array.
+        
+        /**
+         * Compare the lists and build $textMatches array with the matches.
+         * Each match is an array of "new" and "old" keys, with the id of the list it matches to.
+         * Whenever there is no match (in cases where a new list item was added or removed), null is used instead of the id.
+         */
         $this->compareChildLists();
-        // Create the child list objects from textMatches array
-        $this->createChildListObjects();
     }
     
     protected function compareChildLists()
@@ -94,142 +115,161 @@ protected function compareChildLists()
         foreach ($this->childLists['new'] as $thisKey => $thisList) {
             $bestMatchPercentages[$thisKey] = array();
             foreach ($this->childLists['old'] as $thatKey => $thatList) {
+                // Save the percent amount each new list content compares against the old list content.
                 similar_text($thisList, $thatList, $percentage);
                 $bestMatchPercentages[$thisKey][] = $percentage;
             }
         }
         
+        // Sort each array by value, highest percent to lowest percent.
         foreach ($bestMatchPercentages as &$thisMatch) {
             arsort($thisMatch);
         }
-        //var_dump($bestMatchPercentages);
         
         // Build matches.
         $matches = array();
         $taken = array();
+        $takenItems = array();
         $absoluteMatch = 100;
         foreach ($bestMatchPercentages as $item => $percentages) {
             $highestMatch = -1;
             $highestMatchKey = -1;
+            $takeItemKey = -1;
             
             foreach ($percentages as $key => $percent) {
                 // Check that the key for the percentage is not already taken and the new percentage is higher.
                 if (!in_array($key, $taken) && $percent > $highestMatch) {
                     // If an absolute match, choose this one.
                     if ($percent == $absoluteMatch) {
+                        //$this->dump("Absolute found");
                         $highestMatch = $percent;
                         $highestMatchKey = $key;
+                        $takenItemKey = $item;
                         break;
                     } else {
                         // Get all the other matces for the same $key
                         $columns = array_column($bestMatchPercentages, $key);
-                        //$str = "All the other matches for this key:".$key; var_dump($str);
-                        //var_dump($columns);
                         $thisBestMatches = array_filter(
                             $columns,
                             function ($v) use ($percent) {
                                 return $v > $percent;
                             }
                         );
                         
-                        //$str = "Best Matches Sorted, with lower matches filtered out: ".$percent; var_dump($str);
                         arsort($thisBestMatches);
-                        //var_dump($thisBestMatches);
                         
                         // If no greater amounts, use this one.
                         if (!count($thisBestMatches)) {
                             $highestMatch = $percent;
                             $highestMatchKey = $key;
+                            $takenItemKey = $item;
                             break;
                         }
                         
                         // Loop through, comparing only the items that have not already been added.
-                        /*foreach ($thisBestMatches as $k => $v) {
-                            if (!in_array($k, $takenItems)) {
+                        foreach ($thisBestMatches as $k => $v) {
+                            if (in_array($k, $takenItems)) {
                                 $highestMatch = $percent;
                                 $highestMatchKey = $key;
                                 $takenItemKey = $item;
                                 break(2);
                             }
-                        }*/
+                        }
                     }
                 }
             }
             
             $matches[] = array('new' => $item, 'old' => $highestMatchKey > -1 ? $highestMatchKey : null);
             if ($highestMatchKey > -1) {
                 $taken[] = $highestMatchKey;
+                $takenItems[] = $takenItemKey;
+            }
+        }
+        
+        /* Checking for removed items. Basically, if a list item from the old lists is removed
+         * it will not be accounted for, and will disappear in the results altogether.
+         * Loop through all the old lists, any that has not been added, will be added as:
+         * array( new => null, old => oldItemId )
+         */
+        $matchColumns = array_column($matches, 'old');
+        foreach ($this->childLists['old'] as $thisKey => $thisList) {
+            if (!in_array($thisKey, $matchColumns)) {
+                $matches[] = array('new' => null, 'old' => $thisKey);
             }
         }
         
         // Save the matches.
         $this->textMatches = $matches;
-        $this->dump($matches);
     }
     
+    /**
+     * Build multidimensional array holding the contents of each list node, old and new.
+     */
     protected function buildChildLists()
     {
         $this->childLists['old'] = $this->getListsContent($this->list['old']);
         $this->childLists['new'] = $this->getListsContent($this->list['new']);
     }
     
-    protected function createChildListObjects()
-    {
-        /*$this->childListObjects = array();
-        foreach ($this->textMatches as $match) {
-            $object = new ListNode($match['old'], $match['new']);
-            $this->childListObjects[] = $object;
-        }*/
-    }
-    
+    /**
+     * Diff the actual contents of the lists against their matched counterpart.
+     * Build the content of the class.
+     */
     protected function diff()
     {
+        // Add the opening parent node from listType. So if ol, <ol>, etc.
         $this->content = $this->addListTypeWrapper();
         
         foreach ($this->textMatches as $key => $matches) {
             $oldText = $matches['old'] !== null ? $this->childLists['old'][$matches['old']] : '';
             $newText = $matches['new'] !== null ? $this->childLists['new'][$matches['new']] : '';
-            $this->dump("OLD TEXT: ". $oldText);
-            $this->dump("NEW TEXT: ".$newText);
             
+            // Add the opened and closed the list
             $this->content .= "<li>";
-            if ($newText && !$oldText) {
-                $this->content .= $newText;
-            } elseif ($oldText && !$newText) {
-                $this->content .= "THIS RIGHT HERE";
-            } else {
-                $thisDiff = $this->processPlaceholders($this->diffElements($oldText, $newText), $matches);
-                $this->content .= $thisDiff;
-            }
+            // Process any placeholders, if they exist.
+            // Placeholders would be nested lists (a nested ol, ul, dl for example).
+            $this->content .= $this->processPlaceholders($this->diffElements($oldText, $newText), $matches);
             $this->content .= "</li>";
         }
         
+        // Add the closing parent node from listType. So if ol, </ol>, etc.
         $this->content .= $this->addListTypeWrapper(false);
     }
     
+    /**
+     * Return the contents of each list node.
+     * Process any placeholders for nested lists.
+     */
     protected function processPlaceholders($text, array $matches)
     {
+        // Prepare return
         $returnText = array();
+        // Save the contents of all list nodes, new and old.
         $contentVault = array(
             'old' => $this->getListContent('old', $matches),
             'new' => $this->getListContent('new', $matches)
         );
         
         $count = 0;
+        // Loop through the text checking for placeholders. If a nested list is found, create a new ListDiff object for it.
         foreach (explode(' ', $text) as $word) {
             $content = $word;
             if (in_array($word, $this->isolatedDiffTags)) {
                 $oldText = implode('', $contentVault['old'][$count]);
                 $newText = implode('', $contentVault['new'][$count]);
-                $content = $this->diffList($oldText, $newText);
+                $content = $this->diffList($oldText, $newText, true);
                 $count++;
             }
             
             $returnText[] = $content;
         }
+        // Return the result.
         return implode(' ', $returnText);
     }
     
+    /**
+     * Grab the list content using the listsIndex array.
+     */
     protected function getListContent($indexKey = 'new', array $matches)
     {
         $bucket = array();
@@ -243,6 +283,12 @@ protected function getListContent($indexKey = 'new', array $matches)
         return $bucket;
     }
     
+    /**
+     * indexLists
+     * 
+     * Index the list, starting positions, so that we can refer back to it later.
+     * This is used to see where one list node starts and another ends.
+     */
     protected function indexLists()
     {
         $this->listsIndex = array();
@@ -259,22 +305,26 @@ protected function indexLists()
         }
     }
     
+    /**
+     * Adds the opening or closing list html element, based on listType.
+     */
     protected function addListTypeWrapper($opening = true)
     {
         return "<" . (!$opening ? "/" : '') . $this->listType . ">";
     }
     
-    protected function dump($content)
-    {
-        var_dump($content);
-    }
-    
+    /**
+     * Replace nested list with placeholders.
+     */
     public function replaceListIsolatedDiffTags()
     {
         $this->listIsolatedDiffTags['old'] = $this->createIsolatedDiffTagPlaceholders($this->list['old']);
         $this->listIsolatedDiffTags['new'] = $this->createIsolatedDiffTagPlaceholders($this->list['new']);
     }
     
+    /**
+     * Grab the contents of a list node.
+     */
     protected function getListsContent(array $contentArray, $stripTags = true)
     {
         preg_match_all('/<li>(.*?)<\/li>/s', implode('', $contentArray), $matches);
diff --git a/lib/Caxy/HtmlDiff/ListNode.php b/lib/Caxy/HtmlDiff/ListNode.php

Original file line number	Diff line number	Diff line change
`@@ -211,8 +211,7 @@ protected function diffElements($oldText, $newText)`
`211`	`211`	`protected function diffList($oldText, $newText)`
`212`	`212`	`{`
`213`	`213`	`$diff = new ListDiff($oldText, $newText, $this->encoding, $this->isolatedDiffTags, $this->groupDiffs);`
`214`		`- $diff->build();`
`215`		`- return $diff->getDifference();`
	`214`	`+ return $diff->build();`
`216`	`215`	`}`
`217`	`216`
`218`	`217`	`protected function processEqualOperation($operation)`