gollum 2.0.0 → 2.1.0

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/range_list.js

@@ -0,0 +1,230 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Ajax.org Code Editor (ACE).
+ *
+ * The Initial Developer of the Original Code is
+ * Ajax.org B.V.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *      Harutyun Amirjanyan <amirjanyan AT gmail DOT com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+"use strict";
+
+
+var RangeList = function() {
+    this.ranges = [];
+};
+
+(function() {
+    this.comparePoints = function(p1, p2) {
+        return p1.row - p2.row || p1.column - p2.column;
+    };
+
+    this.pointIndex = function(pos, startIndex) {
+        var list = this.ranges;
+
+        for (var i = startIndex || 0; i < list.length; i++) {
+            var range = list[i];
+            var cmp = this.comparePoints(pos, range.end);
+
+            if (cmp > 0)
+                continue;
+            if (cmp == 0)
+                return i;
+            cmp = this.comparePoints(pos, range.start);
+            if (cmp >= 0)
+                return i;
+
+            return -i-1;
+        }
+        return -i - 1;
+    };
+
+    this.add = function(range) {
+        var startIndex = this.pointIndex(range.start);
+        if (startIndex < 0)
+            startIndex = -startIndex - 1;
+
+        var endIndex = this.pointIndex(range.end, startIndex);
+
+        if (endIndex < 0)
+            endIndex = -endIndex - 1;
+        else
+            endIndex++;
+
+        return this.ranges.splice(startIndex, endIndex - startIndex, range);
+    };
+
+    this.addList = function(list) {
+        var removed = [];
+        for (var i = list.length; i--; ) {
+            removed.push.call(removed, this.add(list[i]));
+        }
+        return removed;
+    };
+
+    this.substractPoint = function(pos) {
+        var i = this.pointIndex(pos);
+
+        if (i >= 0)
+            return this.ranges.splice(i, 1);
+    };
+
+    // merge overlapping ranges
+    this.merge = function() {
+        var removed = [];
+        var list = this.ranges;
+        var next = list[0], range;
+        for (var i = 1; i < list.length; i++) {
+            range = next;
+            next = list[i];
+            var cmp = this.comparePoints(range.end, next.start);
+            if (cmp < 0)
+                continue;
+
+            if (cmp == 0 && !(range.isEmpty() || next.isEmpty()))
+                continue;
+
+            if (this.comparePoints(range.end, next.end) < 0) {
+                range.end.row = next.end.row;
+                range.end.column = next.end.column;
+            }
+
+            list.splice(i, 1);
+            removed.push(next);
+            next = range;
+            i--;
+        }
+
+        return removed;
+    };
+
+    this.contains = function(row, column) {
+        return this.pointIndex({row: row, column: column}) >= 0;
+    };
+
+    this.containsPoint = function(pos) {
+        return this.pointIndex(pos) >= 0;
+    };
+
+    this.rangeAtPoint = function(pos) {
+        var i = this.pointIndex(pos);
+        if (i >= 0)
+            return this.ranges[i];
+    };
+
+
+    this.clipRows = function(startRow, endRow) {
+        var list = this.ranges;
+        if (list[0].start.row > endRow || list[list.length - 1].start.row < startRow)
+            return [];
+
+        var startIndex = this.pointIndex({row: startRow, column: 0});
+        if (startIndex < 0)
+            startIndex = -startIndex - 1;
+        var endIndex = this.pointIndex({row: endRow, column: 0}, startIndex);
+        if (endIndex < 0)
+            endIndex = -endIndex - 1;
+
+        var clipped = [];
+        for (var i = startIndex; i < endIndex; i++) {
+            clipped.push(list[i]);
+        }
+        return clipped;
+    };
+
+    this.removeAll = function() {
+        return this.ranges.splice(0, this.ranges.length);
+    };
+
+    this.attach = function(session) {
+        if (this.session)
+            this.detach();
+
+        this.session = session;
+        this.onChange = this.$onChange.bind(this);
+
+        this.session.on('change', this.onChange);
+    };
+
+    this.detach = function() {
+        if (!this.session)
+            return;
+        this.session.removeListener('change', this.onChange);
+        this.session = null;
+    };
+
+    this.$onChange = function(e) {
+        var changeRange = e.data.range;
+        if (e.data.action[0] == "i"){
+            var start = changeRange.start;
+            var end = changeRange.end;
+        } else {
+            var end = changeRange.start;
+            var start = changeRange.end;
+        }
+        var startRow = start.row;
+        var endRow = end.row;
+        var lineDif = endRow - startRow;
+
+        var colDiff = -start.column + end.column;
+        var ranges = this.ranges;
+
+        for (var i = 0, n = ranges.length; i < n; i++) {
+            var r = ranges[i];
+            if (r.end.row < startRow)
+                continue;
+            if (r.start.row > startRow)
+                break;
+
+            if (r.start.row == startRow && r.start.column >= start.column ) {
+                r.start.column += colDiff;
+                r.start.row += lineDif;
+            }
+            if (r.end.row == startRow && r.end.column >=  start.column) {
+                r.end.column += colDiff;
+                r.end.row += lineDif;
+            }
+        }
+
+        if (lineDif != 0 && i < n) {
+            for (; i < n; i++) {
+                var r = ranges[i];
+                r.start.row += lineDif;
+                r.end.row += lineDif;
+            }
+        }
+    };
+
+}).call(RangeList.prototype);
+
+exports.RangeList = RangeList;
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/range_list_test.js

@@ -0,0 +1,170 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Ajax.org Code Editor (ACE).
+ *
+ * The Initial Developer of the Original Code is
+ * Ajax.org B.V.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *      Fabian Jakobs <fabian AT ajax DOT org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+if (typeof process !== "undefined") {
+    require("amd-loader");
+}
+
+define(function(require, exports, module) {
+"use strict";
+
+var Range = require("./range").Range;
+var RangeList = require("./range_list").RangeList;
+var EditSession = require("./edit_session").EditSession;
+var assert = require("./test/assertions");
+
+function flatten(rangeList) {
+    var points = [];
+    rangeList.ranges.forEach(function(r) {
+        points.push(r.start.row, r.start.column, r.end.row, r.end.column)
+    })
+    return points;
+}
+function testRangeList(rangeList, points) {
+    assert.equal("" + flatten(rangeList), "" + points);
+}
+
+module.exports = {
+
+    name: "ACE range_list.js",
+
+    "test: rangeList pointIndex": function() {
+        var rangeList = new RangeList();
+        rangeList.ranges = [
+            new Range(1,2,3,4),
+            new Range(4,2,5,4),
+            new Range(8,8,9,9)
+        ];
+
+        assert.equal(rangeList.pointIndex({row: 0, column: 1}), -1);
+        assert.equal(rangeList.pointIndex({row: 1, column: 2}), 0);
+        assert.equal(rangeList.pointIndex({row: 1, column: 3}), 0);
+        assert.equal(rangeList.pointIndex({row: 3, column: 4}), 0);
+        assert.equal(rangeList.pointIndex({row: 4, column: 1}), -2);
+        assert.equal(rangeList.pointIndex({row: 5, column: 1}), 1);
+        assert.equal(rangeList.pointIndex({row: 8, column: 9}), 2);
+        assert.equal(rangeList.pointIndex({row: 18, column: 9}), -4);
+    },
+
+    "test: rangeList add": function() {
+        var rangeList = new RangeList();
+        rangeList.addList([
+            new Range(9,0,9,1),
+            new Range(1,2,3,4),
+            new Range(8,8,9,9),
+            new Range(4,2,5,4),
+            new Range(3,20,3,24),
+            new Range(6,6,7,7)
+        ]);
+        assert.equal(rangeList.ranges.length, 5);
+
+        rangeList.add(new Range(1,2,3,5));
+        assert.range(rangeList.ranges[0], 1,2,3,5);
+        assert.equal(rangeList.ranges.length, 5);
+
+        rangeList.add(new Range(7,7,7,7));
+        assert.range(rangeList.ranges[3], 7,7,7,7);
+        rangeList.add(new Range(7,8,7,8));
+        assert.range(rangeList.ranges[4], 7,8,7,8);
+    },
+
+    "test: rangeList add empty": function() {
+        var rangeList = new RangeList();
+        rangeList.addList([
+            new Range(7,10,7,10),
+            new Range(9,10,9,10),
+            new Range(8,10,8,10)
+        ]);
+        assert.equal(rangeList.ranges.length, 3);
+
+        rangeList.add(new Range(9,10,9,10));
+        testRangeList(rangeList, [7,10,7,10,8,10,8,10,9,10,9,10]);
+    },
+
+    "test: rangeList merge": function() {
+        var rangeList = new RangeList();
+        rangeList.addList([
+            new Range(1,2,3,4),
+            new Range(4,2,5,4),
+            new Range(6,6,7,7),
+            new Range(8,8,9,9)
+        ]);
+        var removed = [];
+
+        assert.equal(rangeList.ranges.length, 4);
+
+        rangeList.ranges[1].end.row = 7;
+        removed = rangeList.merge();
+        assert.equal(removed.length, 1);
+        assert.range(rangeList.ranges[1], 4,2,7,7);
+        assert.equal(rangeList.ranges.length, 3);
+
+        rangeList.ranges[0].end.row = 10;
+        removed = rangeList.merge();
+        assert.range(rangeList.ranges[0], 1,2,10,4);
+        assert.equal(removed.length, 2);
+        assert.equal(rangeList.ranges.length, 1);
+
+        rangeList.ranges.push(new Range(10,10,10,10));
+        rangeList.ranges.push(new Range(10,10,10,10));
+        removed = rangeList.merge();
+        assert.equal(rangeList.ranges.length, 2);
+    },
+
+    "test: rangeList remove": function() {
+        var rangeList = new RangeList();
+        var list = [
+            new Range(1,2,3,4),
+            new Range(4,2,5,4),
+            new Range(6,6,7,7),
+            new Range(8,8,9,9)
+        ];
+        rangeList.addList(list);
+        assert.equal(rangeList.ranges.length, 4);
+        rangeList.substractPoint({row: 1, column: 2});
+        assert.equal(rangeList.ranges.length, 3);
+        rangeList.substractPoint({row: 6, column: 7});
+        assert.equal(rangeList.ranges.length, 2);
+    }
+
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/range_test.js

@@ -0,0 +1,198 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Ajax.org Code Editor (ACE).
+ *
+ * The Initial Developer of the Original Code is
+ * Ajax.org B.V.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *      Fabian Jakobs <fabian AT ajax DOT org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+if (typeof process !== "undefined") {
+    require("amd-loader");
+}
+
+define(function(require, exports, module) {
+"use strict";
+
+var Range = require("./range").Range;
+var EditSession = require("./edit_session").EditSession;
+var assert = require("./test/assertions");
+
+module.exports = {
+    
+    name: "ACE range.js",
+    
+    "test: create range": function() {
+        var range = new Range(1,2,3,4);
+
+        assert.equal(range.start.row, 1);
+        assert.equal(range.start.column, 2);
+        assert.equal(range.end.row, 3);
+        assert.equal(range.end.column, 4);
+    },
+
+    "test: create from points": function() {
+        var range = Range.fromPoints({row: 1, column: 2}, {row:3, column:4});
+
+        assert.equal(range.start.row, 1);
+        assert.equal(range.start.column, 2);
+        assert.equal(range.end.row, 3);
+        assert.equal(range.end.column, 4);
+    },
+
+    "test: clip to rows": function() {
+        assert.range(new Range(0, 20, 100, 30).clipRows(10, 30), 10, 0, 31, 0);
+        assert.range(new Range(0, 20, 30, 10).clipRows(10, 30), 10, 0, 30, 10);
+
+        var range = new Range(0, 20, 3, 10);
+        var range = range.clipRows(10, 30);
+
+        assert.ok(range.isEmpty());
+        assert.range(range, 10, 0, 10, 0);
+    },
+
+    "test: isEmpty": function() {
+        var range = new Range(1, 2, 1, 2);
+        assert.ok(range.isEmpty());
+
+        var range = new Range(1, 2, 1, 6);
+        assert.notOk(range.isEmpty());
+    },
+
+    "test: is multi line": function() {
+        var range = new Range(1, 2, 1, 6);
+        assert.notOk(range.isMultiLine());
+
+        var range = new Range(1, 2, 2, 6);
+        assert.ok(range.isMultiLine());
+    },
+
+    "test: clone": function() {
+        var range = new Range(1, 2, 3, 4);
+        var clone = range.clone();
+
+        assert.position(clone.start, 1, 2);
+        assert.position(clone.end, 3, 4);
+
+        clone.start.column = 20;
+        assert.position(range.start, 1, 2);
+
+        clone.end.column = 20;
+        assert.position(range.end, 3, 4);
+    },
+
+    "test: contains for multi line ranges": function() {
+        var range = new Range(1, 10, 5, 20);
+
+        assert.ok(range.contains(1, 10));
+        assert.ok(range.contains(2, 0));
+        assert.ok(range.contains(3, 100));
+        assert.ok(range.contains(5, 19));
+        assert.ok(range.contains(5, 20));
+
+        assert.notOk(range.contains(1, 9));
+        assert.notOk(range.contains(0, 0));
+        assert.notOk(range.contains(5, 21));
+    },
+
+    "test: contains for single line ranges": function() {
+        var range = new Range(1, 10, 1, 20);
+
+        assert.ok(range.contains(1, 10));
+        assert.ok(range.contains(1, 15));
+        assert.ok(range.contains(1, 20));
+
+        assert.notOk(range.contains(0, 9));
+        assert.notOk(range.contains(2, 9));
+        assert.notOk(range.contains(1, 9));
+        assert.notOk(range.contains(1, 21));
+    },
+
+    "test: extend range": function() {
+        var range = new Range(2, 10, 2, 30);
+
+        var range = range.extend(2, 5);
+        assert.range(range, 2, 5, 2, 30);
+
+        var range = range.extend(2, 35);
+        assert.range(range, 2, 5, 2, 35);
+
+        var range = range.extend(2, 15);
+        assert.range(range, 2, 5, 2, 35);
+
+        var range = range.extend(1, 4);
+        assert.range(range, 1, 4, 2, 35);
+
+        var range = range.extend(6, 10);
+        assert.range(range, 1, 4, 6, 10);
+    },
+
+    "test: collapse rows" : function() {
+        var range = new Range(0, 2, 1, 2);
+        assert.range(range.collapseRows(), 0, 0, 1, 0);
+
+        var range = new Range(2, 2, 3, 1);
+        assert.range(range.collapseRows(), 2, 0, 3, 0);
+
+        var range = new Range(2, 2, 3, 0);
+        assert.range(range.collapseRows(), 2, 0, 2, 0);
+
+        var range = new Range(2, 0, 2, 0);
+        assert.range(range.collapseRows(), 2, 0, 2, 0);
+    },
+    
+    "test: to screen range" : function() {
+        var session = new EditSession([
+            "juhu",
+            "12\t\t34",
+            "ぁぁa",
+            "\t\t34",
+        ]);
+        
+        var range = new Range(0, 0, 0, 3);
+        assert.range(range.toScreenRange(session), 0, 0, 0, 3);
+        
+        var range = new Range(1, 1, 1, 3);
+        assert.range(range.toScreenRange(session), 1, 1, 1, 4);
+        
+        var range = new Range(2, 1, 2, 2);
+        assert.range(range.toScreenRange(session), 2, 2, 2, 4);
+
+        var range = new Range(3, 0, 3, 4);
+        assert.range(range.toScreenRange(session), 3, 0, 3, 10);
+    }
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}