codemirror-rails 4.12 → 4.13

data/vendor/assets/javascripts/codemirror/addons/lint/lint.js

@@ -46,6 +46,7 @@
     }
     var poll = setInterval(function() {
       if (tooltip) for (var n = node;; n = n.parentNode) {
+        if (n && n.nodeType == 11) n = n.host;
         if (n == document.body) return;
         if (!n) { hide(); break; }
       }
@@ -119,7 +120,7 @@
   function startLinting(cm) {
     var state = cm.state.lint, options = state.options;
     var passOptions = options.options || options; // Support deprecated passing of `options` property in options
-    if (options.async)
+    if (options.async || options.getAnnotations.async)
       options.getAnnotations(cm.getValue(), updateLinting, passOptions, cm);
     else
       updateLinting(cm, options.getAnnotations(cm.getValue(), passOptions, cm));

data/vendor/assets/javascripts/codemirror/addons/merge/merge.js

@@ -31,8 +31,6 @@
          insert: "CodeMirror-merge-r-inserted",
          del: "CodeMirror-merge-r-deleted",
          connect: "CodeMirror-merge-r-connect"};
-    if (mv.options.connect == "align")
-      this.aligners = [];
   }
 
   DiffView.prototype = {
@@ -42,7 +40,8 @@
       this.orig = CodeMirror(pane, copyObj({value: orig, readOnly: !this.mv.options.allowEditingOriginals}, copyObj(options)));
 
       this.diff = getDiff(asString(orig), asString(options.value));
-      this.diffOutOfDate = false;
+      this.chunks = getChunks(this.diff);
+      this.diffOutOfDate = this.dealigned = false;
 
       this.showDifferences = options.showDifferences !== false;
       this.forceUpdate = registerUpdate(this);
@@ -61,16 +60,20 @@
   function ensureDiff(dv) {
     if (dv.diffOutOfDate) {
       dv.diff = getDiff(dv.orig.getValue(), dv.edit.getValue());
+      dv.chunks = getChunks(dv.diff);
       dv.diffOutOfDate = false;
       CodeMirror.signal(dv.edit, "updateDiff", dv.diff);
     }
   }
 
+  var updating = false;
   function registerUpdate(dv) {
     var edit = {from: 0, to: 0, marked: []};
     var orig = {from: 0, to: 0, marked: []};
-    var debounceChange;
+    var debounceChange, updatingFast = false;
     function update(mode) {
+      updating = true;
+      updatingFast = false;
       if (mode == "full") {
         if (dv.svg) clear(dv.svg);
         if (dv.copyButtons) clear(dv.copyButtons);
@@ -84,26 +87,38 @@
         updateMarks(dv.orig, dv.diff, orig, DIFF_DELETE, dv.classes);
       }
       makeConnections(dv);
+
+      if (dv.mv.options.connect == "align")
+        alignChunks(dv);
+      updating = false;
     }
-    function set(slow) {
+    function setDealign(fast) {
+      if (updating) return;
+      dv.dealigned = true;
+      set(fast);
+    }
+    function set(fast) {
+      if (updating || updatingFast) return;
       clearTimeout(debounceChange);
-      debounceChange = setTimeout(update, slow == true ? 250 : 100);
+      if (fast === true) updatingFast = true;
+      debounceChange = setTimeout(update, fast === true ? 20 : 250);
     }
-    function change() {
+    function change(_cm, change) {
       if (!dv.diffOutOfDate) {
         dv.diffOutOfDate = true;
         edit.from = edit.to = orig.from = orig.to = 0;
       }
-      set(true);
+      // Update faster when a line was added/removed
+      setDealign(change.text.length - 1 != change.to.line - change.from.line);
     }
     dv.edit.on("change", change);
     dv.orig.on("change", change);
-    dv.edit.on("markerAdded", set);
-    dv.edit.on("markerCleared", set);
-    dv.orig.on("markerAdded", set);
-    dv.orig.on("markerCleared", set);
-    dv.edit.on("viewportChange", set);
-    dv.orig.on("viewportChange", set);
+    dv.edit.on("markerAdded", setDealign);
+    dv.edit.on("markerCleared", setDealign);
+    dv.orig.on("markerAdded", setDealign);
+    dv.orig.on("markerCleared", setDealign);
+    dv.edit.on("viewportChange", function() { set(false); });
+    dv.orig.on("viewportChange", function() { set(false); });
     update();
     return update;
   }
@@ -134,7 +149,7 @@
     } else {
       var halfScreen = .5 * sInfo.clientHeight, midY = sInfo.top + halfScreen;
       var mid = editor.lineAtHeight(midY, "local");
-      var around = chunkBoundariesAround(dv.diff, mid, type == DIFF_INSERT);
+      var around = chunkBoundariesAround(dv.chunks, mid, type == DIFF_INSERT);
       var off = getOffsets(editor, type == DIFF_INSERT ? around.edit : around.orig);
       var offOther = getOffsets(other, type == DIFF_INSERT ? around.orig : around.edit);
       var ratio = (midY - off.top) / (off.bot - off.top);
@@ -259,19 +274,6 @@
   function makeConnections(dv) {
     if (!dv.showDifferences) return;
 
-    var align = dv.mv.options.connect == "align", oldScrollEdit, oldScrollOrig;
-    if (align) {
-      if (!dv.orig.curOp) return dv.orig.operation(function() {
-        makeConnections(dv);
-      });
-      oldScrollEdit = dv.edit.getScrollInfo().top;
-      oldScrollOrig = dv.orig.getScrollInfo().top;
-      for (var i = 0; i < dv.aligners.length; i++)
-        dv.aligners[i].clear();
-      dv.aligners.length = 0;
-      var extraSpaceAbove = {edit: 0, orig: 0};
-    }
-
     if (dv.svg) {
       clear(dv.svg);
       var w = dv.gap.offsetWidth;
@@ -281,34 +283,118 @@
 
     var vpEdit = dv.edit.getViewport(), vpOrig = dv.orig.getViewport();
     var sTopEdit = dv.edit.getScrollInfo().top, sTopOrig = dv.orig.getScrollInfo().top;
-    iterateChunks(dv.diff, function(topOrig, botOrig, topEdit, botEdit) {
-      if (topEdit <= vpEdit.to && botEdit >= vpEdit.from &&
-          topOrig <= vpOrig.to && botOrig >= vpOrig.from)
-        drawConnectorsForChunk(dv, topOrig, botOrig, topEdit, botEdit, sTopOrig, sTopEdit, w);
-      if (align && (topEdit <= vpEdit.to || topOrig <= vpOrig.to)) {
-        var above = (botEdit < vpEdit.from && botOrig < vpOrig.from);
-        alignChunks(dv, topOrig, botOrig, topEdit, botEdit, above && extraSpaceAbove);
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var ch = dv.chunks[i];
+      if (ch.editFrom <= vpEdit.to && ch.editTo >= vpEdit.from &&
+          ch.origFrom <= vpOrig.to && ch.origTo >= vpOrig.from)
+        drawConnectorsForChunk(dv, ch, sTopOrig, sTopEdit, w);
+    }
+  }
+
+  function getMatchingOrigLine(editLine, chunks) {
+    var editStart = 0, origStart = 0;
+    for (var i = 0; i < chunks.length; i++) {
+      var chunk = chunks[i];
+      if (chunk.editTo > editLine && chunk.editFrom <= editLine) return null;
+      if (chunk.editFrom > editLine) break;
+      editStart = chunk.editTo;
+      origStart = chunk.origTo;
+    }
+    return origStart + (editLine - editStart);
+  }
+
+  function findAlignedLines(dv, other) {
+    var linesToAlign = [];
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var chunk = dv.chunks[i];
+      linesToAlign.push([chunk.origTo, chunk.editTo, other ? getMatchingOrigLine(chunk.editTo, other.chunks) : null]);
+    }
+    if (other) {
+      for (var i = 0; i < other.chunks.length; i++) {
+        var chunk = other.chunks[i];
+        for (var j = 0; j < linesToAlign.length; j++) {
+          var align = linesToAlign[j];
+          if (align[1] == chunk.editTo) {
+            j = -1;
+            break;
+          } else if (align[1] > chunk.editTo) {
+            break;
+          }
+        }
+        if (j > -1)
+          linesToAlign.splice(j - 1, 0, [getMatchingOrigLine(chunk.editTo, dv.chunks), chunk.editTo, chunk.origTo]);
       }
+    }
+    return linesToAlign;
+  }
+
+  function alignChunks(dv, force) {
+    if (!dv.dealigned && !force) return;
+    if (!dv.orig.curOp) return dv.orig.operation(function() {
+      alignChunks(dv, force);
     });
-    if (align) {
-      if (extraSpaceAbove.edit)
-        dv.aligners.push(padBelow(dv.edit, 0, extraSpaceAbove.edit));
-      if (extraSpaceAbove.orig)
-        dv.aligners.push(padBelow(dv.orig, 0, extraSpaceAbove.orig));
-      dv.edit.scrollTo(null, oldScrollEdit);
-      dv.orig.scrollTo(null, oldScrollOrig);
+
+    dv.dealigned = false;
+    var other = dv.mv.left == dv ? dv.mv.right : dv.mv.left;
+    if (other) {
+      ensureDiff(other);
+      other.dealigned = false;
     }
+    var linesToAlign = findAlignedLines(dv, other);
+
+    // Clear old aligners
+    var aligners = dv.mv.aligners;
+    for (var i = 0; i < aligners.length; i++)
+      aligners[i].clear();
+    aligners.length = 0;
+
+    var cm = [dv.orig, dv.edit], scroll = [];
+    if (other) cm.push(other.orig);
+    for (var i = 0; i < cm.length; i++)
+      scroll.push(cm[i].getScrollInfo().top);
+
+    for (var ln = 0; ln < linesToAlign.length; ln++)
+      alignLines(cm, linesToAlign[ln], aligners);
+
+    for (var i = 0; i < cm.length; i++)
+      cm[i].scrollTo(null, scroll[i]);
   }
 
-  function drawConnectorsForChunk(dv, topOrig, botOrig, topEdit, botEdit, sTopOrig, sTopEdit, w) {
+  function alignLines(cm, lines, aligners) {
+    var maxOffset = 0, offset = [];
+    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
+      var off = cm[i].heightAtLine(lines[i], "local");
+      offset[i] = off;
+      maxOffset = Math.max(maxOffset, off);
+    }
+    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
+      var diff = maxOffset - offset[i];
+      if (diff > 1)
+        aligners.push(padAbove(cm[i], lines[i], diff));
+    }
+  }
+
+  function padAbove(cm, line, size) {
+    var above = true;
+    if (line > cm.lastLine()) {
+      line--;
+      above = false;
+    }
+    var elt = document.createElement("div");
+    elt.className = "CodeMirror-merge-spacer";
+    elt.style.height = size + "px"; elt.style.minWidth = "1px";
+    return cm.addLineWidget(line, elt, {height: size, above: above});
+  }
+
+  function drawConnectorsForChunk(dv, chunk, sTopOrig, sTopEdit, w) {
     var flip = dv.type == "left";
-    var top = dv.orig.heightAtLine(topOrig, "local") - sTopOrig;
+    var top = dv.orig.heightAtLine(chunk.origFrom, "local") - sTopOrig;
     if (dv.svg) {
       var topLpx = top;
-      var topRpx = dv.edit.heightAtLine(topEdit, "local") - sTopEdit;
+      var topRpx = dv.edit.heightAtLine(chunk.editFrom, "local") - sTopEdit;
       if (flip) { var tmp = topLpx; topLpx = topRpx; topRpx = tmp; }
-      var botLpx = dv.orig.heightAtLine(botOrig, "local") - sTopOrig;
-      var botRpx = dv.edit.heightAtLine(botEdit, "local") - sTopEdit;
+      var botLpx = dv.orig.heightAtLine(chunk.origTo, "local") - sTopOrig;
+      var botRpx = dv.edit.heightAtLine(chunk.editTo, "local") - sTopEdit;
       if (flip) { var tmp = botLpx; botLpx = botRpx; botRpx = tmp; }
       var curveTop = " C " + w/2 + " " + topRpx + " " + w/2 + " " + topLpx + " " + (w + 2) + " " + topLpx;
       var curveBot = " C " + w/2 + " " + botLpx + " " + w/2 + " " + botRpx + " -1 " + botRpx;
@@ -321,48 +407,26 @@
                                                 "CodeMirror-merge-copy"));
       var editOriginals = dv.mv.options.allowEditingOriginals;
       copy.title = editOriginals ? "Push to left" : "Revert chunk";
-      copy.chunk = {topEdit: topEdit, botEdit: botEdit, topOrig: topOrig, botOrig: botOrig};
+      copy.chunk = chunk;
       copy.style.top = top + "px";
 
       if (editOriginals) {
-        var topReverse = dv.orig.heightAtLine(topEdit, "local") - sTopEdit;
+        var topReverse = dv.orig.heightAtLine(chunk.editFrom, "local") - sTopEdit;
         var copyReverse = dv.copyButtons.appendChild(elt("div", dv.type == "right" ? "\u21dd" : "\u21dc",
                                                          "CodeMirror-merge-copy-reverse"));
         copyReverse.title = "Push to right";
-        copyReverse.chunk = {topEdit: topOrig, botEdit: botOrig, topOrig: topEdit, botOrig: botEdit};
+        copyReverse.chunk = {editFrom: chunk.origFrom, editTo: chunk.origTo,
+                             origFrom: chunk.editFrom, origTo: chunk.editTo};
         copyReverse.style.top = topReverse + "px";
         dv.type == "right" ? copyReverse.style.left = "2px" : copyReverse.style.right = "2px";
       }
     }
   }
 
-  function alignChunks(dv, topOrig, botOrig, topEdit, botEdit, aboveViewport) {
-    var topOrigPx = dv.orig.heightAtLine(topOrig, "local");
-    var botOrigPx = dv.orig.heightAtLine(botOrig, "local");
-    var topEditPx = dv.edit.heightAtLine(topEdit, "local");
-    var botEditPx = dv.edit.heightAtLine(botEdit, "local");
-    var origH = botOrigPx -topOrigPx, editH = botEditPx - topEditPx;
-    var diff = editH - origH;
-    if (diff > 1) {
-      if (aboveViewport) aboveViewport.orig += diff;
-      else dv.aligners.push(padBelow(dv.orig, botOrig - 1, diff));
-    } else if (diff < -1) {
-      if (aboveViewport) aboveViewport.edit -= diff;
-      else dv.aligners.push(padBelow(dv.edit, botEdit - 1, -diff));
-    }
-    return 0;
-  }
-
-  function padBelow(cm, line, size) {
-    var elt = document.createElement("div");
-    elt.style.height = size + "px"; elt.style.minWidth = "1px";
-    return cm.addLineWidget(line, elt, {height: size});
-  }
-
   function copyChunk(dv, to, from, chunk) {
     if (dv.diffOutOfDate) return;
-    to.replaceRange(from.getRange(Pos(chunk.topOrig, 0), Pos(chunk.botOrig, 0)),
-                         Pos(chunk.topEdit, 0), Pos(chunk.botEdit, 0));
+    to.replaceRange(from.getRange(Pos(chunk.origFrom, 0), Pos(chunk.origTo, 0)),
+                         Pos(chunk.editFrom, 0), Pos(chunk.editTo, 0));
   }
 
   // Merge view, containing 0, 1, or 2 diff views.
@@ -372,16 +436,11 @@
 
     this.options = options;
     var origLeft = options.origLeft, origRight = options.origRight == null ? options.orig : options.origRight;
-    if (origLeft && origRight) {
-      if (options.connect == "align")
-        throw new Error("connect: \"align\" is not supported for three-way merge views");
-      if (options.collapseIdentical)
-        throw new Error("collapseIdentical option is not supported for three-way merge views");
-    }
 
     var hasLeft = origLeft != null, hasRight = origRight != null;
     var panes = 1 + (hasLeft ? 1 : 0) + (hasRight ? 1 : 0);
     var wrap = [], left = this.left = null, right = this.right = null;
+    var self = this;
 
     if (hasLeft) {
       left = this.left = new DiffView(this, "left");
@@ -410,8 +469,17 @@
     if (left) left.init(leftPane, origLeft, options);
     if (right) right.init(rightPane, origRight, options);
 
-    if (options.collapseIdentical)
-      collapseIdenticalStretches(left || right, options.collapseIdentical);
+    if (options.collapseIdentical) {
+      updating = true;
+      this.editor().operation(function() {
+        collapseIdenticalStretches(self, options.collapseIdentical);
+      });
+      updating = false;
+    }
+    if (options.connect == "align") {
+      this.aligners = [];
+      alignChunks(this.left || this.right, true);
+    }
 
     var onResize = function() {
       if (left) makeConnections(left);
@@ -463,10 +531,10 @@
       if (this.left) this.left.setShowDifferences(val);
     },
     rightChunks: function() {
-      return this.right && getChunks(this.right);
+      if (this.right) { ensureDiff(this.right); return this.right.chunks; }
     },
     leftChunks: function() {
-      return this.left && getChunks(this.left);
+      if (this.left) { ensureDiff(this.left); return this.left.chunks; }
     }
   };
 
@@ -494,7 +562,8 @@
     return diff;
   }
 
-  function iterateChunks(diff, f) {
+  function getChunks(diff) {
+    var chunks = [];
     var startEdit = 0, startOrig = 0;
     var edit = Pos(0, 0), orig = Pos(0, 0);
     for (var i = 0; i < diff.length; ++i) {
@@ -506,7 +575,8 @@
         var endOff = endOfLineClean(diff, i) ? 1 : 0;
         var cleanToEdit = edit.line + endOff, cleanToOrig = orig.line + endOff;
         if (cleanToEdit > cleanFromEdit) {
-          if (i) f(startOrig, cleanFromOrig, startEdit, cleanFromEdit);
+          if (i) chunks.push({origFrom: startOrig, origTo: cleanFromOrig,
+                              editFrom: startEdit, editTo: cleanFromEdit});
           startEdit = cleanToEdit; startOrig = cleanToOrig;
         }
       } else {
@@ -514,17 +584,9 @@
       }
     }
     if (startEdit <= edit.line || startOrig <= orig.line)
-      f(startOrig, orig.line + 1, startEdit, edit.line + 1);
-  }
-
-  function getChunks(dv) {
-    ensureDiff(dv);
-    var collect = [];
-    iterateChunks(dv.diff, function(topOrig, botOrig, topEdit, botEdit) {
-      collect.push({origFrom: topOrig, origTo: botOrig,
-                    editFrom: topEdit, editTo: botEdit});
-    });
-    return collect;
+      chunks.push({origFrom: startOrig, origTo: orig.line + 1,
+                   editFrom: startEdit, editTo: edit.line + 1});
+    return chunks;
   }
 
   function endOfLineClean(diff, i) {
@@ -545,18 +607,19 @@
     return last.charCodeAt(last.length - 1) == 10;
   }
 
-  function chunkBoundariesAround(diff, n, nInEdit) {
+  function chunkBoundariesAround(chunks, n, nInEdit) {
     var beforeE, afterE, beforeO, afterO;
-    iterateChunks(diff, function(fromOrig, toOrig, fromEdit, toEdit) {
-      var fromLocal = nInEdit ? fromEdit : fromOrig;
-      var toLocal = nInEdit ? toEdit : toOrig;
+    for (var i = 0; i < chunks.length; i++) {
+      var chunk = chunks[i];
+      var fromLocal = nInEdit ? chunk.editFrom : chunk.origFrom;
+      var toLocal = nInEdit ? chunk.editTo : chunk.origTo;
       if (afterE == null) {
-        if (fromLocal > n) { afterE = fromEdit; afterO = fromOrig; }
-        else if (toLocal > n) { afterE = toEdit; afterO = toOrig; }
+        if (fromLocal > n) { afterE = chunk.editFrom; afterO = chunk.origFrom; }
+        else if (toLocal > n) { afterE = chunk.editTo; afterO = chunk.origTo; }
       }
-      if (toLocal <= n) { beforeE = toEdit; beforeO = toOrig; }
-      else if (fromLocal <= n) { beforeE = fromEdit; beforeO = fromOrig; }
-    });
+      if (toLocal <= n) { beforeE = chunk.editTo; beforeO = chunk.origTo; }
+      else if (fromLocal <= n) { beforeE = chunk.editFrom; beforeO = chunk.origFrom; }
+    }
     return {edit: {before: beforeE, after: afterE}, orig: {before: beforeO, after: afterO}};
   }
 
@@ -579,25 +642,50 @@
     return {mark: mark, clear: clear};
   }
 
-  function collapseStretch(dv, origStart, editStart, size) {
-    var mOrig = collapseSingle(dv.orig, origStart, origStart + size);
-    var mEdit = collapseSingle(dv.edit, editStart, editStart + size);
-    mOrig.mark.on("clear", function() { mEdit.clear(); });
-    mEdit.mark.on("clear", function() { mOrig.clear(); });
+  function collapseStretch(size, editors) {
+    var marks = [];
+    function clear() {
+      for (var i = 0; i < marks.length; i++) marks[i].clear();
+    }
+    for (var i = 0; i < editors.length; i++) {
+      var editor = editors[i];
+      var mark = collapseSingle(editor.cm, editor.line, editor.line + size);
+      marks.push(mark);
+      mark.mark.on("clear", clear);
+    }
+    return marks[0].mark;
+  }
+
+  function unclearNearChunks(dv, margin, off, clear) {
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var chunk = dv.chunks[i];
+      for (var l = chunk.editFrom - margin; l < chunk.editTo + margin; l++) {
+        var pos = l + off;
+        if (pos >= 0 && pos < clear.length) clear[pos] = false;
+      }
+    }
   }
 
-  function collapseIdenticalStretches(dv, margin) {
+  function collapseIdenticalStretches(mv, margin) {
     if (typeof margin != "number") margin = 2;
-    var lastOrig = dv.orig.firstLine(), lastEdit = dv.edit.firstLine();
-    iterateChunks(dv.diff, function(topOrig, botOrig, _topEdit, botEdit) {
-      var identicalSize = topOrig - margin - lastOrig;
-      if (identicalSize > margin)
-        collapseStretch(dv, lastOrig, lastEdit, identicalSize);
-      lastOrig = botOrig + margin; lastEdit = botEdit + margin;
-    });
-    var bottomSize = dv.orig.lastLine() + 1 - lastOrig;
-    if (bottomSize > margin)
-      collapseStretch(dv, lastOrig, lastEdit, bottomSize);
+    var clear = [], edit = mv.editor(), off = edit.firstLine();
+    for (var l = off, e = edit.lastLine(); l <= e; l++) clear.push(true);
+    if (mv.left) unclearNearChunks(mv.left, margin, off, clear);
+    if (mv.right) unclearNearChunks(mv.right, margin, off, clear);
+
+    for (var i = 0; i < clear.length; i++) {
+      if (clear[i]) {
+        var line = i + off;
+        for (var size = 1; i < clear.length - 1 && clear[i + 1]; i++, size++) {}
+        if (size > margin) {
+          var editors = [{line: line, cm: edit}];
+          if (mv.left) editors.push({line: getMatchingOrigLine(line, mv.left.chunks), cm: mv.left.orig});
+          if (mv.right) editors.push({line: getMatchingOrigLine(line, mv.right.chunks), cm: mv.right.orig});
+          var mark = collapseStretch(size, editors);
+          if (mv.options.onCollapse) mv.options.onCollapse(mv, line, size, mark);
+        }
+      }
+    }
   }
 
   // General utilities