Moves word diff logic to diff-view. Removes extra info passed from compute-diff. Fixes footer ignore whitespace bug.

Author: mupchrch

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.0.7 - XXXX-XX-XX
+* Fixed issue where toggling ignore whitespace from command wouldn't update footer bar
+* Huge code refactor!
+
 ## 1.0.6 - 2016-10-24
 * Fixed next/prev diff highlight skipping a selection after copying to right/left
 * Added keybinding for copy to left/right and scoped it to just the editors #73

lib/compute-diff.js

@@ -8,12 +8,10 @@ var oldText = fs.readFileSync( oldTextPath );
 var newText = fs.readFileSync( newTextPath );
 
 var diffChunks = _computeDiffChunks( oldText, newText, isWhitespaceIgnored );
-var offsets = _computeOffsets( diffChunks.chunks );
-var orderedChunks = _orderDiffChunks( diffChunks.chunks );
+var offsets = _computeOffsets( diffChunks );
+var orderedChunks = _orderDiffChunks( diffChunks );
 
 console.log( JSON.stringify({
-  addedLines: diffChunks.addedLines,
-  removedLines: diffChunks.removedLines,
   oldLineOffsets: offsets.oldLineOffsets,
   newLineOffsets: offsets.newLineOffsets,
   chunks: orderedChunks
@@ -38,30 +36,20 @@ function _computeDiffChunks(oldText, newText, isWhitespaceIgnored) {
   }
 
   var chunks = [];
-  var addedCount = 0;
-  var removedCount = 0;
   var nextOffset = 0;
   var offset = 0;
 
-  var addedLines = [];
-  var removedLines = [];
   lineDiff.forEach( function(part) {
     var added = part.added,
       removed = part.removed,
       value = part.value;
     var count = part.count;//value.split('\n').length - 1;
     if (!added && !removed) {
-      addedCount += count;
-      removedCount += count;
       offset = nextOffset;
       nextOffset = 0;
     } else if (added) {
-      addedLines.push([addedCount, addedCount+count])
-      addedCount += count;
       nextOffset += count;
     } else {
-      removedLines.push([removedCount, removedCount+count])
-      removedCount += count;
       nextOffset -= count;
     }
     chunks.push({
@@ -74,11 +62,7 @@ function _computeDiffChunks(oldText, newText, isWhitespaceIgnored) {
     offset = 0;
   });
 
-  return {
-    addedLines: addedLines,
-    removedLines: removedLines,
-    chunks: chunks,
-  };
+  return chunks;
 }
 
 function _computeOffsets(diffChunks) {

lib/diff-view.js

@@ -1,13 +1,13 @@
 'use babel'
 
 import EditorDiffExtender from './editor-diff-extender';
+import ComputeWordDiff from './compute-word-diff';
+
 
 module.exports = class DiffView {
   /*
    * @param editors Array of editors being diffed.
    * @param diff ex: {
-   *                    addedLines: [startIndex, endIndex],
-   *                    removedLines: [startIndex, endIndex],
    *                    oldLineOffsets: [lineNumber: numOffsetLines, ...],
    *                    newLineOffsets: [lineNumber: numOffsetLines, ...],
    *                    chunks: [{
@@ -33,19 +33,47 @@ module.exports = class DiffView {
    * @param chunks The diff chunks to highlight.
    * @param leftHighlightType The type of highlight (ex: 'added').
    * @param rightHighlightType The type of highlight (ex: 'removed').
+   * @param isWordDiffEnabled Whether differences between words per line should be highlighted.
+   * @param isWhitespaceIgnored Whether whitespace should be ignored.
    */
-  displayDiff( diff, leftHighlightType, rightHighlightType ) {
+  displayDiff( diff, leftHighlightType, rightHighlightType, isWordDiffEnabled, isWhitespaceIgnored ) {
     this._chunks = diff.chunks;
 
+    // make the last chunk equal size on both screens so the editors retain sync scroll #58
+    if( this._chunks.length > 0 ) {
+      var lastChunk = this._chunks[ this._chunks.length - 1 ];
+      var oldChunkRange = lastChunk.oldLineEnd - lastChunk.oldLineStart;
+      var newChunkRange = lastChunk.newLineEnd - lastChunk.newLineStart;
+      if( oldChunkRange > newChunkRange ) {
+        // make the offset as large as needed to make the chunk the same size in both editors
+        diff.newLineOffsets[ lastChunk.newLineStart + newChunkRange ] = oldChunkRange - newChunkRange;
+      } else if( newChunkRange > oldChunkRange ) {
+        // make the offset as large as needed to make the chunk the same size in both editors
+        diff.oldLineOffsets[ lastChunk.oldLineStart + oldChunkRange ] = newChunkRange - oldChunkRange;
+      }
+    }
+
     for( chunk of this._chunks ) {
       this._editorDiffExtender1.highlightLines( chunk.oldLineStart, chunk.oldLineEnd, leftHighlightType );
       this._editorDiffExtender2.highlightLines( chunk.newLineStart, chunk.newLineEnd, rightHighlightType );
+
+      if( isWordDiffEnabled ) {
+        this._highlightWordsInChunk( chunk, leftHighlightType, rightHighlightType, isWhitespaceIgnored );
+      }
     }
 
     this._editorDiffExtender1.setLineOffsets( diff.oldLineOffsets );
     this._editorDiffExtender2.setLineOffsets( diff.newLineOffsets );
   }
 
+  /**
+   * Clears the diff highlighting and offsets from the editors.
+   */
+  clearDiff() {
+    this._editorDiffExtender1.destroyMarkers();
+    this._editorDiffExtender2.destroyMarkers();
+  }
+
   /**
    * Called to move the current selection highlight to the next diff chunk.
    */
@@ -80,27 +108,6 @@ module.exports = class DiffView {
     return this._selectedChunkIndex;
   }
 
-  /**
-   * Selects and highlights the diff chunk in both editors according to the
-   * given index.
-   *
-   * @param index The index of the diff chunk to highlight in both editors.
-   */
-  _selectChunk( index ) {
-    var diffChunk = this._chunks[index];
-    if( diffChunk != null ) {
-      // deselect previous next/prev highlights
-      this._editorDiffExtender1.deselectAllLines();
-      this._editorDiffExtender2.deselectAllLines();
-      // highlight and scroll editor 1
-      this._editorDiffExtender1.selectLines( diffChunk.oldLineStart, diffChunk.oldLineEnd );
-      this._editorDiffExtender1.getEditor().setCursorBufferPosition( [diffChunk.oldLineStart, 0], {autoscroll: true} );
-      // highlight and scroll editor 2
-      this._editorDiffExtender2.selectLines( diffChunk.newLineStart, diffChunk.newLineEnd );
-      this._editorDiffExtender2.getEditor().setCursorBufferPosition( [diffChunk.newLineStart, 0], {autoscroll: true} );
-    }
-  }
-
   /**
    * Copies the currently selected diff chunk from the left editor to the right
    * editor.
@@ -175,11 +182,110 @@ module.exports = class DiffView {
   }
 
   /**
-   * Gets the editor diff abstractions.
+   * Cleans up the editor indicated by index. A clean up will remove the editor
+   * or the pane if necessary. Typically left editor == 1 and right editor == 2.
    *
-   * @return EditorDiffExtender Array containing the editors being diffed.
+   * @param editorIndex The index of the editor to clean up.
    */
-  getEditorDiffExtenders() {
-    return [this._editorDiffExtender1, this._editorDiffExtender2];
+  cleanUpEditor( editorIndex ) {
+    if( editorIndex === 1 ) {
+      this._editorDiffExtender1.cleanUp();
+    } else if( editorIndex === 2 ) {
+      this._editorDiffExtender2.cleanUp();
+    }
+  }
+
+  /**
+   * Destroys the editor diff extenders.
+   */
+  destroy() {
+    this._editorDiffExtender1.destroy();
+    this._editorDiffExtender2.destroy();
+  }
+
+  /**
+   * Gets the number of differences between the editors.
+   *
+   * @return int The number of differences between the editors.
+   */
+  getNumDifferences() {
+    return this._chunks.length;
+  }
+
+  // ----------------------------------------------------------------------- //
+  // --------------------------- PRIVATE METHODS --------------------------- //
+  // ----------------------------------------------------------------------- //
+
+  /**
+   * Selects and highlights the diff chunk in both editors according to the
+   * given index.
+   *
+   * @param index The index of the diff chunk to highlight in both editors.
+   */
+  _selectChunk( index ) {
+    var diffChunk = this._chunks[index];
+    if( diffChunk != null ) {
+      // deselect previous next/prev highlights
+      this._editorDiffExtender1.deselectAllLines();
+      this._editorDiffExtender2.deselectAllLines();
+      // highlight and scroll editor 1
+      this._editorDiffExtender1.selectLines( diffChunk.oldLineStart, diffChunk.oldLineEnd );
+      this._editorDiffExtender1.getEditor().setCursorBufferPosition( [diffChunk.oldLineStart, 0], {autoscroll: true} );
+      // highlight and scroll editor 2
+      this._editorDiffExtender2.selectLines( diffChunk.newLineStart, diffChunk.newLineEnd );
+      this._editorDiffExtender2.getEditor().setCursorBufferPosition( [diffChunk.newLineStart, 0], {autoscroll: true} );
+    }
+  }
+
+  /**
+   * Highlights the word diff of the chunk passed in.
+   *
+   * @param chunk The chunk that should have its words highlighted.
+   */
+  _highlightWordsInChunk( chunk, leftHighlightType, rightHighlightType, isWhitespaceIgnored ) {
+    var leftLineNumber = chunk.oldLineStart;
+    var rightLineNumber = chunk.newLineStart;
+    // for each line that has a corresponding line
+    while( leftLineNumber < chunk.oldLineEnd && rightLineNumber < chunk.newLineEnd ) {
+      // do word diff
+      var wordDiff = ComputeWordDiff.computeWordDiff(
+        this._editorDiffExtender1.getEditor().lineTextForBufferRow( leftLineNumber ),
+        this._editorDiffExtender2.getEditor().lineTextForBufferRow( rightLineNumber )
+      );
+      this._editorDiffExtender1.setWordHighlights( leftLineNumber, wordDiff.removedWords, leftHighlightType, isWhitespaceIgnored );
+      this._editorDiffExtender2.setWordHighlights( rightLineNumber, wordDiff.addedWords, rightHighlightType, isWhitespaceIgnored );
+
+      leftLineNumber++;
+      rightLineNumber++;
+    }
+
+    // highlight remaining lines in left editor
+    while( leftLineNumber < chunk.oldLineEnd ) {
+      this._editorDiffExtender1.setWordHighlights(
+        leftLineNumber,
+        [{
+          changed: true,
+          value: this._editorDiffExtender1.getEditor().lineTextForBufferRow( leftLineNumber )
+        }],
+        leftHighlightType,
+        isWhitespaceIgnored
+      );
+
+      leftLineNumber++;
+    }
+    // highlight remaining lines in the right editor
+    while( rightLineNumber < chunk.newLineEnd ) {
+      this._editorDiffExtender2.setWordHighlights(
+        rightLineNumber,
+        [{
+          changed: true,
+          value: this._editorDiffExtender2.getEditor().lineTextForBufferRow( rightLineNumber )
+        }],
+        rightHighlightType,
+        isWhitespaceIgnored
+      );
+
+      rightLineNumber++;
+    }
   }
 };