third-party/codemirror-3.15/addon/merge/merge.js

   1 (function() {
   2   "use strict";
   3
   4   var Pos = CodeMirror.Pos;
   5   var svgNS = "http://www.w3.org/2000/svg";
   6
   7   function DiffView(mv, type) {
   8     this.mv = mv;
   9     this.type = type;
  10     this.classes = type == "left"
  11       ? {chunk: "CodeMirror-merge-l-chunk",
  12          start: "CodeMirror-merge-l-chunk-start",
  13          end: "CodeMirror-merge-l-chunk-end",
  14          insert: "CodeMirror-merge-l-inserted",
  15          del: "CodeMirror-merge-l-deleted",
  16          connect: "CodeMirror-merge-l-connect"}
  17       : {chunk: "CodeMirror-merge-r-chunk",
  18          start: "CodeMirror-merge-r-chunk-start",
  19          end: "CodeMirror-merge-r-chunk-end",
  20          insert: "CodeMirror-merge-r-inserted",
  21          del: "CodeMirror-merge-r-deleted",
  22          connect: "CodeMirror-merge-r-connect"};
  23   }
  24
  25   DiffView.prototype = {
  26     constructor: DiffView,
  27     init: function(pane, orig, options) {
  28       this.edit = this.mv.edit;
  29       this.orig = CodeMirror(pane, copyObj({value: orig, readOnly: true}, copyObj(options)));
  30
  31       this.diff = getDiff(orig, options.value);
  32       this.diffOutOfDate = false;
  33
  34       this.forceUpdate = registerUpdate(this);
  35       setScrollLock(this, true, false);
  36       registerScroll(this);
  37     }
  38   };
  39
  40   function registerUpdate(dv) {
  41     var edit = {from: 0, to: 0, marked: []};
  42     var orig = {from: 0, to: 0, marked: []};
  43     var debounceChange;
  44     function update() {
  45       if (dv.diffOutOfDate) {
  46         dv.diff = getDiff(dv.orig.getValue(), dv.edit.getValue());
  47         dv.diffOutOfDate = false;
  48       }
  49       updateMarks(dv.edit, dv.diff, edit, DIFF_INSERT, dv.classes);
  50       updateMarks(dv.orig, dv.diff, orig, DIFF_DELETE, dv.classes);
  51       drawConnectors(dv);
  52     }
  53     function set(slow) {
  54       clearTimeout(debounceChange);
  55       debounceChange = setTimeout(update, slow == true ? 250 : 100);
  56     }
  57     dv.edit.on("change", function() {
  58       if (!dv.diffOutOfDate) {
  59         dv.diffOutOfDate = true;
  60         edit.from = edit.to = orig.from = orig.to = 0;
  61       }
  62       set(true);
  63     });
  64     dv.edit.on("viewportChange", set);
  65     dv.orig.on("viewportChange", set);
  66     update();
  67     return update;
  68   }
  69
  70   function registerScroll(dv) {
  71     dv.edit.on("scroll", function() {
  72       syncScroll(dv, DIFF_INSERT) && drawConnectors(dv);
  73     });
  74     dv.orig.on("scroll", function() {
  75       syncScroll(dv, DIFF_DELETE) && drawConnectors(dv);
  76     });
  77   }
  78
  79   function syncScroll(dv, type) {
  80     // Change handler will do a refresh after a timeout when diff is out of date
  81     if (dv.diffOutOfDate) return false;
  82     if (!dv.lockScroll) return true;
  83     var editor, other, now = +new Date;
  84     if (type == DIFF_INSERT) { editor = dv.edit; other = dv.orig; }
  85     else { editor = dv.orig; other = dv.edit; }
  86     // Don't take action if the position of this editor was recently set
  87     // (to prevent feedback loops)
  88     if (editor.state.scrollSetBy == dv && (editor.state.scrollSetAt || 0) + 50 > now) return false;
  89
  90     var sInfo = editor.getScrollInfo(), halfScreen = .5 * sInfo.clientHeight, midY = sInfo.top + halfScreen;
  91     var mid = editor.lineAtHeight(midY, "local");
  92     var around = chunkBoundariesAround(dv.diff, mid, type == DIFF_INSERT);
  93     var off = getOffsets(editor, type == DIFF_INSERT ? around.edit : around.orig);
  94     var offOther = getOffsets(other, type == DIFF_INSERT ? around.orig : around.edit);
  95     var ratio = (midY - off.top) / (off.bot - off.top);
  96     var targetPos = (offOther.top - halfScreen) + ratio * (offOther.bot - offOther.top);
  97
  98     var botDist, mix;
  99     // Some careful tweaking to make sure no space is left out of view
 100     // when scrolling to top or bottom.
 101     if (targetPos > sInfo.top && (mix = sInfo.top / halfScreen) < 1) {
 102       targetPos = targetPos * mix + sInfo.top * (1 - mix);
 103     } else if ((botDist = sInfo.height - sInfo.clientHeight - sInfo.top) < halfScreen) {
 104       var otherInfo = other.getScrollInfo();
 105       var botDistOther = otherInfo.height - otherInfo.clientHeight - targetPos;
 106       if (botDistOther > botDist && (mix = botDist / halfScreen) < 1)
 107         targetPos = targetPos * mix + (otherInfo.height - otherInfo.clientHeight - botDist) * (1 - mix);
 108     }
 109
 110     other.scrollTo(sInfo.left, targetPos);
 111     other.state.scrollSetAt = now;
 112     other.state.scrollSetBy = dv;
 113     return true;
 114   }
 115
 116   function getOffsets(editor, around) {
 117     var bot = around.after;
 118     if (bot == null) bot = editor.lastLine() + 1;
 119     return {top: editor.heightAtLine(around.before || 0, "local"),
 120             bot: editor.heightAtLine(bot, "local")};
 121   }
 122
 123   function setScrollLock(dv, val, action) {
 124     dv.lockScroll = val;
 125     if (val && action != false) syncScroll(dv, DIFF_INSERT) && drawConnectors(dv);
 126     dv.lockButton.innerHTML = val ? "\u21db\u21da" : "\u21db&nbsp;&nbsp;\u21da";
 127   }
 128
 129   // Updating the marks for editor content
 130
 131   function clearMarks(editor, arr, classes) {
 132     for (var i = 0; i < arr.length; ++i) {
 133       var mark = arr[i];
 134       if (mark instanceof CodeMirror.TextMarker) {
 135         mark.clear();
 136       } else {
 137         editor.removeLineClass(mark, "background", classes.chunk);
 138         editor.removeLineClass(mark, "background", classes.start);
 139         editor.removeLineClass(mark, "background", classes.end);
 140       }
 141     }
 142     arr.length = 0;
 143   }
 144
 145   // FIXME maybe add a margin around viewport to prevent too many updates
 146   function updateMarks(editor, diff, state, type, classes) {
 147     var vp = editor.getViewport();
 148     editor.operation(function() {
 149       if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
 150         clearMarks(editor, state.marked, classes);
 151         markChanges(editor, diff, type, state.marked, vp.from, vp.to, classes);
 152         state.from = vp.from; state.to = vp.to;
 153       } else {
 154         if (vp.from < state.from) {
 155           markChanges(editor, diff, type, state.marked, vp.from, state.from, classes);
 156           state.from = vp.from;
 157         }
 158         if (vp.to > state.to) {
 159           markChanges(editor, diff, type, state.marked, state.to, vp.to, classes);
 160           state.to = vp.to;
 161         }
 162       }
 163     });
 164   }
 165
 166   function markChanges(editor, diff, type, marks, from, to, classes) {
 167     var pos = Pos(0, 0);
 168     var top = Pos(from, 0), bot = editor.clipPos(Pos(to - 1));
 169     var cls = type == DIFF_DELETE ? classes.del : classes.insert;
 170     function markChunk(start, end) {
 171       var bfrom = Math.max(from, start), bto = Math.min(to, end);
 172       for (var i = bfrom; i < bto; ++i) {
 173         var line = editor.addLineClass(i, "background", classes.chunk);
 174         if (i == start) editor.addLineClass(line, "background", classes.start);
 175         if (i == end - 1) editor.addLineClass(line, "background", classes.end);
 176         marks.push(line);
 177       }
 178       // When the chunk is empty, make sure a horizontal line shows up
 179       if (start == end && bfrom == end && bto == end) {
 180         if (bfrom)
 181           marks.push(editor.addLineClass(bfrom - 1, "background", classes.end));
 182         else
 183           marks.push(editor.addLineClass(bfrom, "background", classes.start));
 184       }
 185     }
 186
 187     var chunkStart = 0;
 188     for (var i = 0; i < diff.length; ++i) {
 189       var part = diff[i], tp = part[0], str = part[1];
 190       if (tp == DIFF_EQUAL) {
 191         var cleanFrom = pos.line + (startOfLineClean(diff, i) ? 0 : 1);
 192         moveOver(pos, str);
 193         var cleanTo = pos.line + (endOfLineClean(diff, i) ? 1 : 0);
 194         if (cleanTo > cleanFrom) {
 195           if (i) markChunk(chunkStart, cleanFrom);
 196           chunkStart = cleanTo;
 197         }
 198       } else {
 199         if (tp == type) {
 200           var end = moveOver(pos, str, true);
 201           var a = posMax(top, pos), b = posMin(bot, end);
 202           if (!posEq(a, b))
 203             marks.push(editor.markText(a, b, {className: cls}));
 204           pos = end;
 205         }
 206       }
 207     }
 208     if (chunkStart <= pos.line) markChunk(chunkStart, pos.line + 1);
 209   }
 210
 211   // Updating the gap between editor and original
 212
 213   function drawConnectors(dv) {
 214     if (dv.svg) {
 215       clear(dv.svg);
 216       var w = dv.gap.offsetWidth;
 217       attrs(dv.svg, "width", w, "height", dv.gap.offsetHeight);
 218     }
 219     clear(dv.copyButtons);
 220
 221     var flip = dv.type == "left";
 222     var vpEdit = dv.edit.getViewport(), vpOrig = dv.orig.getViewport();
 223     var sTopEdit = dv.edit.getScrollInfo().top, sTopOrig = dv.orig.getScrollInfo().top;
 224     iterateChunks(dv.diff, function(topOrig, botOrig, topEdit, botEdit) {
 225       if (topEdit > vpEdit.to || botEdit < vpEdit.from ||
 226           topOrig > vpOrig.to || botOrig < vpOrig.from)
 227         return;
 228       var topLpx = dv.orig.heightAtLine(topOrig, "local") - sTopOrig, top = topLpx;
 229       if (dv.svg) {
 230         var topRpx = dv.edit.heightAtLine(topEdit, "local") - sTopEdit;
 231         if (flip) { var tmp = topLpx; topLpx = topRpx; topRpx = tmp; }
 232         var botLpx = dv.orig.heightAtLine(botOrig, "local") - sTopOrig;
 233         var botRpx = dv.edit.heightAtLine(botEdit, "local") - sTopEdit;
 234         if (flip) { var tmp = botLpx; botLpx = botRpx; botRpx = tmp; }
 235         var curveTop = " C " + w/2 + " " + topRpx + " " + w/2 + " " + topLpx + " " + (w + 2) + " " + topLpx;
 236         var curveBot = " C " + w/2 + " " + botLpx + " " + w/2 + " " + botRpx + " -1 " + botRpx;
 237         attrs(dv.svg.appendChild(document.createElementNS(svgNS, "path")),
 238               "d", "M -1 " + topRpx + curveTop + " L " + (w + 2) + " " + botLpx + curveBot + " z",
 239               "class", dv.classes.connect);
 240       }
 241       var copy = dv.copyButtons.appendChild(elt("div", dv.type == "left" ? "\u21dd" : "\u21dc",
 242                                                 "CodeMirror-merge-copy"));
 243       copy.title = "Revert chunk";
 244       copy.chunk = {topEdit: topEdit, botEdit: botEdit, topOrig: topOrig, botOrig: botOrig};
 245       copy.style.top = top + "px";
 246     });
 247   }
 248
 249   function copyChunk(dv, chunk) {
 250     if (dv.diffOutOfDate) return;
 251     dv.edit.replaceRange(dv.orig.getRange(Pos(chunk.topOrig, 0), Pos(chunk.botOrig, 0)),
 252                          Pos(chunk.topEdit, 0), Pos(chunk.botEdit, 0));
 253   }
 254
 255   // Merge view, containing 0, 1, or 2 diff views.
 256
 257   var MergeView = CodeMirror.MergeView = function(node, options) {
 258     if (!(this instanceof MergeView)) return new MergeView(node, options);
 259
 260     var origLeft = options.origLeft, origRight = options.origRight == null ? options.orig : options.origRight;
 261     var hasLeft = origLeft != null, hasRight = origRight != null;
 262     var panes = 1 + (hasLeft ? 1 : 0) + (hasRight ? 1 : 0);
 263     var wrap = [], left = this.left = null, right = this.right = null;
 264
 265     if (hasLeft) {
 266       left = this.left = new DiffView(this, "left");
 267       var leftPane = elt("div", null, "CodeMirror-merge-pane");
 268       wrap.push(leftPane);
 269       wrap.push(buildGap(left));
 270     }
 271
 272     var editPane = elt("div", null, "CodeMirror-merge-pane");
 273     wrap.push(editPane);
 274
 275     if (hasRight) {
 276       right = this.right = new DiffView(this, "right");
 277       wrap.push(buildGap(right));
 278       var rightPane = elt("div", null, "CodeMirror-merge-pane");
 279       wrap.push(rightPane);
 280     }
 281
 282     (hasRight ? rightPane : editPane).className += " CodeMirror-merge-pane-rightmost";
 283
 284     wrap.push(elt("div", null, null, "height: 0; clear: both;"));
 285     var wrapElt = this.wrap = node.appendChild(elt("div", wrap, "CodeMirror-merge CodeMirror-merge-" + panes + "pane"));
 286     this.edit = CodeMirror(editPane, copyObj(options));
 287
 288     if (left) left.init(leftPane, origLeft, options);
 289     if (right) right.init(rightPane, origRight, options);
 290
 291     var onResize = function() {
 292       if (left) drawConnectors(left);
 293       if (right) drawConnectors(right);
 294     };
 295     CodeMirror.on(window, "resize", onResize);
 296     var resizeInterval = setInterval(function() {
 297       for (var p = wrapElt.parentNode; p && p != document.body; p = p.parentNode) {}
 298       if (!p) { clearInterval(resizeInterval); CodeMirror.off(window, "resize", onResize); }
 299     }, 5000);
 300   };
 301
 302   function buildGap(dv) {
 303     var lock = dv.lockButton = elt("div", null, "CodeMirror-merge-scrolllock");
 304     lock.title = "Toggle locked scrolling";
 305     var lockWrap = elt("div", [lock], "CodeMirror-merge-scrolllock-wrap");
 306     CodeMirror.on(lock, "click", function() { setScrollLock(dv, !dv.lockScroll); });
 307     dv.copyButtons = elt("div", null, "CodeMirror-merge-copybuttons-" + dv.type);
 308     CodeMirror.on(dv.copyButtons, "click", function(e) {
 309       var node = e.target || e.srcElement;
 310       if (node.chunk) copyChunk(dv, node.chunk);
 311     });
 312     var gapElts = [dv.copyButtons, lockWrap];
 313     var svg = document.createElementNS && document.createElementNS(svgNS, "svg");
 314     if (svg && !svg.createSVGRect) svg = null;
 315     dv.svg = svg;
 316     if (svg) gapElts.push(svg);
 317
 318     return dv.gap = elt("div", gapElts, "CodeMirror-merge-gap");
 319   }
 320
 321   MergeView.prototype = {
 322     constuctor: MergeView,
 323     editor: function() { return this.edit; },
 324     rightOriginal: function() { return this.right && this.right.orig; },
 325     leftOriginal: function() { return this.left && this.left.orig; }
 326   };
 327
 328   // Operations on diffs
 329
 330   var dmp = new diff_match_patch();
 331   function getDiff(a, b) {
 332     var diff = dmp.diff_main(a, b);
 333     dmp.diff_cleanupSemantic(diff);
 334     // The library sometimes leaves in empty parts, which confuse the algorithm
 335     for (var i = 0; i < diff.length; ++i) {
 336       var part = diff[i];
 337       if (!part[1]) {
 338         diff.splice(i--, 1);
 339       } else if (i && diff[i - 1][0] == part[0]) {
 340         diff.splice(i--, 1);
 341         diff[i][1] += part[1];
 342       }
 343     }
 344     return diff;
 345   }
 346
 347   function iterateChunks(diff, f) {
 348     var startEdit = 0, startOrig = 0;
 349     var edit = Pos(0, 0), orig = Pos(0, 0);
 350     for (var i = 0; i < diff.length; ++i) {
 351       var part = diff[i], tp = part[0];
 352       if (tp == DIFF_EQUAL) {
 353         var startOff = startOfLineClean(diff, i) ? 0 : 1;
 354         var cleanFromEdit = edit.line + startOff, cleanFromOrig = orig.line + startOff;
 355         moveOver(edit, part[1], null, orig);
 356         var endOff = endOfLineClean(diff, i) ? 1 : 0;
 357         var cleanToEdit = edit.line + endOff, cleanToOrig = orig.line + endOff;
 358         if (cleanToEdit > cleanFromEdit) {
 359           if (i) f(startOrig, cleanFromOrig, startEdit, cleanFromEdit);
 360           startEdit = cleanToEdit; startOrig = cleanToOrig;
 361         }
 362       } else {
 363         moveOver(tp == DIFF_INSERT ? edit : orig, part[1]);
 364       }
 365     }
 366     if (startEdit <= edit.line || startOrig <= orig.line)
 367       f(startOrig, orig.line + 1, startEdit, edit.line + 1);
 368   }
 369
 370   function endOfLineClean(diff, i) {
 371     if (i == diff.length - 1) return true;
 372     var next = diff[i + 1][1];
 373     if (next.length == 1 || next.charCodeAt(0) != 10) return false;
 374     if (i == diff.length - 2) return true;
 375     next = diff[i + 2][1];
 376     return next.length > 1 && next.charCodeAt(0) == 10;
 377   }
 378
 379   function startOfLineClean(diff, i) {
 380     if (i == 0) return true;
 381     var last = diff[i - 1][1];
 382     if (last.charCodeAt(last.length - 1) != 10) return false;
 383     if (i == 1) return true;
 384     last = diff[i - 2][1];
 385     return last.charCodeAt(last.length - 1) == 10;
 386   }
 387
 388   function chunkBoundariesAround(diff, n, nInEdit) {
 389     var beforeE, afterE, beforeO, afterO;
 390     iterateChunks(diff, function(fromOrig, toOrig, fromEdit, toEdit) {
 391       var fromLocal = nInEdit ? fromEdit : fromOrig;
 392       var toLocal = nInEdit ? toEdit : toOrig;
 393       if (afterE == null) {
 394         if (fromLocal > n) { afterE = fromEdit; afterO = fromOrig; }
 395         else if (toLocal > n) { afterE = toEdit; afterO = toOrig; }
 396       }
 397       if (toLocal <= n) { beforeE = toEdit; beforeO = toOrig; }
 398       else if (fromLocal <= n) { beforeE = fromEdit; beforeO = fromOrig; }
 399     });
 400     return {edit: {before: beforeE, after: afterE}, orig: {before: beforeO, after: afterO}};
 401   }
 402
 403   // General utilities
 404
 405   function elt(tag, content, className, style) {
 406     var e = document.createElement(tag);
 407     if (className) e.className = className;
 408     if (style) e.style.cssText = style;
 409     if (typeof content == "string") e.appendChild(document.createTextNode(content));
 410     else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
 411     return e;
 412   }
 413
 414   function clear(node) {
 415     for (var count = node.childNodes.length; count > 0; --count)
 416       node.removeChild(node.firstChild);
 417   }
 418
 419   function attrs(elt) {
 420     for (var i = 1; i < arguments.length; i += 2)
 421       elt.setAttribute(arguments[i], arguments[i+1]);
 422   }
 423
 424   function copyObj(obj, target) {
 425     if (!target) target = {};
 426     for (var prop in obj) if (obj.hasOwnProperty(prop)) target[prop] = obj[prop];
 427     return target;
 428   }
 429
 430   function moveOver(pos, str, copy, other) {
 431     var out = copy ? Pos(pos.line, pos.ch) : pos, at = 0;
 432     for (;;) {
 433       var nl = str.indexOf("\n", at);
 434       if (nl == -1) break;
 435       ++out.line;
 436       if (other) ++other.line;
 437       at = nl + 1;
 438     }
 439     out.ch = (at ? 0 : out.ch) + (str.length - at);
 440     if (other) other.ch = (at ? 0 : other.ch) + (str.length - at);
 441     return out;
 442   }
 443
 444   function posMin(a, b) { return (a.line - b.line || a.ch - b.ch) < 0 ? a : b; }
 445   function posMax(a, b) { return (a.line - b.line || a.ch - b.ch) > 0 ? a : b; }
 446   function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
 447 })();