pollypost 0.0.2

data/vendor/assets/ace-1.1.8/placeholder.js

@@ -0,0 +1,274 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Distributed under the BSD license:
+ *
+ * Copyright (c) 2010, Ajax.org B.V.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Ajax.org B.V. nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+define(function(require, exports, module) {
+"use strict";
+
+var Range = require("./range").Range;
+var EventEmitter = require("./lib/event_emitter").EventEmitter;
+var oop = require("./lib/oop");
+
+/**
+ * @class PlaceHolder
+ *
+ **/
+
+/**
+ * - session (Document): The document to associate with the anchor
+ * - length (Number): The starting row position
+ * - pos (Number): The starting column position
+ * - others (String):
+ * - mainClass (String):
+ * - othersClass (String):
+ * 
+ * @constructor
+ **/
+
+var PlaceHolder = function(session, length, pos, others, mainClass, othersClass) {
+    var _self = this;
+    this.length = length;
+    this.session = session;
+    this.doc = session.getDocument();
+    this.mainClass = mainClass;
+    this.othersClass = othersClass;
+    this.$onUpdate = this.onUpdate.bind(this);
+    this.doc.on("change", this.$onUpdate);
+    this.$others = others;
+    
+    this.$onCursorChange = function() {
+        setTimeout(function() {
+            _self.onCursorChange();
+        });
+    };
+    
+    this.$pos = pos;
+    // Used for reset
+    var undoStack = session.getUndoManager().$undoStack || session.getUndoManager().$undostack || {length: -1};
+    this.$undoStackDepth =  undoStack.length;
+    this.setup();
+
+    session.selection.on("changeCursor", this.$onCursorChange);
+};
+
+(function() {
+
+    oop.implement(this, EventEmitter);
+
+    /**
+     * PlaceHolder.setup()
+     *
+     * TODO
+     *
+     **/
+    this.setup = function() {
+        var _self = this;
+        var doc = this.doc;
+        var session = this.session;
+        var pos = this.$pos;
+        
+        this.selectionBefore = session.selection.toJSON();
+        if (session.selection.inMultiSelectMode)
+            session.selection.toSingleRange();
+
+        this.pos = doc.createAnchor(pos.row, pos.column);
+        this.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column + this.length), this.mainClass, null, false);
+        this.pos.on("change", function(event) {
+            session.removeMarker(_self.markerId);
+            _self.markerId = session.addMarker(new Range(event.value.row, event.value.column, event.value.row, event.value.column+_self.length), _self.mainClass, null, false);
+        });
+        this.others = [];
+        this.$others.forEach(function(other) {
+            var anchor = doc.createAnchor(other.row, other.column);
+            _self.others.push(anchor);
+        });
+        session.setUndoSelect(false);
+    };
+    
+    /**
+     * PlaceHolder.showOtherMarkers()
+     *
+     * TODO
+     *
+     **/
+    this.showOtherMarkers = function() {
+        if(this.othersActive) return;
+        var session = this.session;
+        var _self = this;
+        this.othersActive = true;
+        this.others.forEach(function(anchor) {
+            anchor.markerId = session.addMarker(new Range(anchor.row, anchor.column, anchor.row, anchor.column+_self.length), _self.othersClass, null, false);
+            anchor.on("change", function(event) {
+                session.removeMarker(anchor.markerId);
+                anchor.markerId = session.addMarker(new Range(event.value.row, event.value.column, event.value.row, event.value.column+_self.length), _self.othersClass, null, false);
+            });
+        });
+    };
+    
+    /**
+     * PlaceHolder.hideOtherMarkers()
+     *
+     * Hides all over markers in the [[EditSession `EditSession`]] that are not the currently selected one.
+     *
+     **/
+    this.hideOtherMarkers = function() {
+        if(!this.othersActive) return;
+        this.othersActive = false;
+        for (var i = 0; i < this.others.length; i++) {
+            this.session.removeMarker(this.others[i].markerId);
+        }
+    };
+
+    /**
+     * PlaceHolder@onUpdate(e)
+     * 
+     * Emitted when the place holder updates.
+     *
+     **/
+    this.onUpdate = function(event) {
+        var delta = event.data;
+        var range = delta.range;
+        if(range.start.row !== range.end.row) return;
+        if(range.start.row !== this.pos.row) return;
+        if (this.$updating) return;
+        this.$updating = true;
+        var lengthDiff = delta.action === "insertText" ? range.end.column - range.start.column : range.start.column - range.end.column;
+        
+        if(range.start.column >= this.pos.column && range.start.column <= this.pos.column + this.length + 1) {
+            var distanceFromStart = range.start.column - this.pos.column;
+            this.length += lengthDiff;
+            if(!this.session.$fromUndo) {
+                if(delta.action === "insertText") {
+                    for (var i = this.others.length - 1; i >= 0; i--) {
+                        var otherPos = this.others[i];
+                        var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart};
+                        if(otherPos.row === range.start.row && range.start.column < otherPos.column)
+                            newPos.column += lengthDiff;
+                        this.doc.insert(newPos, delta.text);
+                    }
+                } else if(delta.action === "removeText") {
+                    for (var i = this.others.length - 1; i >= 0; i--) {
+                        var otherPos = this.others[i];
+                        var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart};
+                        if(otherPos.row === range.start.row && range.start.column < otherPos.column)
+                            newPos.column += lengthDiff;
+                        this.doc.remove(new Range(newPos.row, newPos.column, newPos.row, newPos.column - lengthDiff));
+                    }
+                }
+                // Special case: insert in beginning
+                if(range.start.column === this.pos.column && delta.action === "insertText") {
+                    setTimeout(function() {
+                        this.pos.setPosition(this.pos.row, this.pos.column - lengthDiff);
+                        for (var i = 0; i < this.others.length; i++) {
+                            var other = this.others[i];
+                            var newPos = {row: other.row, column: other.column - lengthDiff};
+                            if(other.row === range.start.row && range.start.column < other.column)
+                                newPos.column += lengthDiff;
+                            other.setPosition(newPos.row, newPos.column);
+                        }
+                    }.bind(this), 0);
+                }
+                else if(range.start.column === this.pos.column && delta.action === "removeText") {
+                    setTimeout(function() {
+                        for (var i = 0; i < this.others.length; i++) {
+                            var other = this.others[i];
+                            if(other.row === range.start.row && range.start.column < other.column) {
+                                other.setPosition(other.row, other.column - lengthDiff);
+                            }
+                        }
+                    }.bind(this), 0);
+                }
+            }
+            this.pos._emit("change", {value: this.pos});
+            for (var i = 0; i < this.others.length; i++) {
+                this.others[i]._emit("change", {value: this.others[i]});
+            }
+        }
+        this.$updating = false;
+    };
+    
+    /**
+     * PlaceHolder@onCursorChange(e)
+     * 
+     * Emitted when the cursor changes.
+     *
+     **/
+
+    this.onCursorChange = function(event) {
+        if (this.$updating || !this.session) return;
+        var pos = this.session.selection.getCursor();
+        if (pos.row === this.pos.row && pos.column >= this.pos.column && pos.column <= this.pos.column + this.length) {
+            this.showOtherMarkers();
+            this._emit("cursorEnter", event);
+        } else {
+            this.hideOtherMarkers();
+            this._emit("cursorLeave", event);
+        }
+    };
+    
+    /**
+     * PlaceHolder.detach()
+     * 
+     * TODO
+     *
+     **/    
+    this.detach = function() {
+        this.session.removeMarker(this.markerId);
+        this.hideOtherMarkers();
+        this.doc.removeEventListener("change", this.$onUpdate);
+        this.session.selection.removeEventListener("changeCursor", this.$onCursorChange);
+        this.pos.detach();
+        for (var i = 0; i < this.others.length; i++) {
+            this.others[i].detach();
+        }
+        this.session.setUndoSelect(true);
+        this.session = null;
+    };
+    
+    /**
+     * PlaceHolder.cancel()
+     * 
+     * TODO
+     *
+     **/
+    this.cancel = function() {
+        if(this.$undoStackDepth === -1)
+            throw Error("Canceling placeholders only supported with undo manager attached to session.");
+        var undoManager = this.session.getUndoManager();
+        var undosRequired = (undoManager.$undoStack || undoManager.$undostack).length - this.$undoStackDepth;
+        for (var i = 0; i < undosRequired; i++) {
+            undoManager.undo(true);
+        }
+        if (this.selectionBefore)
+            this.session.selection.fromJSON(this.selectionBefore);
+    };
+}).call(PlaceHolder.prototype);
+
+
+exports.PlaceHolder = PlaceHolder;
+});

data/vendor/assets/ace-1.1.8/placeholder_test.js

@@ -0,0 +1,156 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Distributed under the BSD license:
+ *
+ * Copyright (c) 2010, Ajax.org B.V.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Ajax.org B.V. nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+if (typeof process !== "undefined") {
+    require("amd-loader");
+    require("./test/mockdom");
+}
+
+define(function(require, exports, module) {
+"use strict";
+
+var EditSession = require("./edit_session").EditSession;
+var Editor = require("./editor").Editor;
+var MockRenderer = require("./test/mockrenderer").MockRenderer;
+var assert = require("./test/assertions");
+var JavaScriptMode = require("./mode/javascript").Mode;
+var PlaceHolder = require("./placeholder").PlaceHolder;
+var UndoManager = require("./undomanager").UndoManager;
+
+module.exports = {
+
+   "test: simple at the end appending of text" : function() {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);", new JavaScriptMode());
+        var editor = new Editor(new MockRenderer(), session);
+        
+        new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        
+        editor.moveCursorTo(0, 5);
+        editor.insert('b');
+        assert.equal(session.doc.getValue(), "var ab = 10;\nconsole.log(ab, ab);");
+        editor.insert('cd');
+        assert.equal(session.doc.getValue(), "var abcd = 10;\nconsole.log(abcd, abcd);");
+        editor.remove('left');
+        editor.remove('left');
+        editor.remove('left');
+        assert.equal(session.doc.getValue(), "var a = 10;\nconsole.log(a, a);");
+    },
+
+    "test: inserting text outside placeholder" : function() {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);\n", new JavaScriptMode());
+        var editor = new Editor(new MockRenderer(), session);
+        
+        new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        
+        editor.moveCursorTo(2, 0);
+        editor.insert('b');
+        assert.equal(session.doc.getValue(), "var a = 10;\nconsole.log(a, a);\nb");
+    },
+    
+   "test: insertion at the beginning" : function(next) {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);", new JavaScriptMode());
+        var editor = new Editor(new MockRenderer(), session);
+        
+        var p = new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        
+        editor.moveCursorTo(0, 4);
+        editor.insert('$');
+        assert.equal(session.doc.getValue(), "var $a = 10;\nconsole.log($a, $a);");
+        editor.moveCursorTo(0, 4);
+        // Have to put this in a setTimeout because the anchor is only fixed later.
+        setTimeout(function() {
+            editor.insert('v');
+            assert.equal(session.doc.getValue(), "var v$a = 10;\nconsole.log(v$a, v$a);");
+            next();
+        }, 10);
+    },
+
+   "test: detaching placeholder" : function() {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);", new JavaScriptMode());
+        var editor = new Editor(new MockRenderer(), session);
+        
+        var p = new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        
+        editor.moveCursorTo(0, 5);
+        editor.insert('b');
+        assert.equal(session.doc.getValue(), "var ab = 10;\nconsole.log(ab, ab);");
+        p.detach();
+        editor.insert('cd');
+        assert.equal(session.doc.getValue(), "var abcd = 10;\nconsole.log(ab, ab);");
+    },
+
+   "test: events" : function() {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);", new JavaScriptMode());
+        var editor = new Editor(new MockRenderer(), session);
+        
+        var p = new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        var entered = false;
+        var left = false;
+        p.on("cursorEnter", function() {
+            entered = true;
+        });
+        p.on("cursorLeave", function() {
+            left = true;
+        });
+        
+        editor.moveCursorTo(0, 0);
+        editor.moveCursorTo(0, 4);
+        p.onCursorChange(); // Have to do this by hand because moveCursorTo doesn't trigger the event
+        assert.ok(entered);
+        editor.moveCursorTo(1, 0);
+        p.onCursorChange(); // Have to do this by hand because moveCursorTo doesn't trigger the event
+        assert.ok(left);
+    },
+    
+    "test: cancel": function(next) {
+        var session = new EditSession("var a = 10;\nconsole.log(a, a);", new JavaScriptMode());
+        session.setUndoManager(new UndoManager());
+        var editor = new Editor(new MockRenderer(), session);
+        var p = new PlaceHolder(session, 1, {row: 0, column: 4}, [{row: 1, column: 12}, {row: 1, column: 15}]);
+        
+        editor.moveCursorTo(0, 5);
+        editor.insert('b');
+        editor.insert('cd');
+        editor.remove('left');
+        assert.equal(session.doc.getValue(), "var abc = 10;\nconsole.log(abc, abc);");
+        // Wait a little for the changes to enter the undo stack
+        setTimeout(function() {
+            p.cancel();
+            assert.equal(session.doc.getValue(), "var a = 10;\nconsole.log(a, a);");
+            next();
+        }, 80);
+    }
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}

data/vendor/assets/ace-1.1.8/range.js

@@ -0,0 +1,549 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Distributed under the BSD license:
+ *
+ * Copyright (c) 2010, Ajax.org B.V.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Ajax.org B.V. nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+"use strict";
+var comparePoints = function(p1, p2) {
+    return p1.row - p2.row || p1.column - p2.column;
+};
+/**
+ * This object is used in various places to indicate a region within the editor. To better visualize how this works, imagine a rectangle. Each quadrant of the rectangle is analogus to a range, as ranges contain a starting row and starting column, and an ending row, and ending column.
+ * @class Range
+ **/
+
+/**
+ * Creates a new `Range` object with the given starting and ending row and column points.
+ * @param {Number} startRow The starting row
+ * @param {Number} startColumn The starting column
+ * @param {Number} endRow The ending row
+ * @param {Number} endColumn The ending column
+ *
+ * @constructor
+ **/
+var Range = function(startRow, startColumn, endRow, endColumn) {
+    this.start = {
+        row: startRow,
+        column: startColumn
+    };
+
+    this.end = {
+        row: endRow,
+        column: endColumn
+    };
+};
+
+(function() {
+    /**
+     * Returns `true` if and only if the starting row and column, and ending row and column, are equivalent to those given by `range`.
+     * @param {Range} range A range to check against
+     *
+     * @return {Boolean}
+     **/
+    this.isEqual = function(range) {
+        return this.start.row === range.start.row &&
+            this.end.row === range.end.row &&
+            this.start.column === range.start.column &&
+            this.end.column === range.end.column;
+    };
+
+    /**
+     *
+     * Returns a string containing the range's row and column information, given like this:
+     * ```
+     *    [start.row/start.column] -> [end.row/end.column]
+     * ```
+     * @return {String}
+     **/
+    this.toString = function() {
+        return ("Range: [" + this.start.row + "/" + this.start.column +
+            "] -> [" + this.end.row + "/" + this.end.column + "]");
+    };
+
+    /**
+     *
+     * Returns `true` if the `row` and `column` provided are within the given range. This can better be expressed as returning `true` if:
+     * ```javascript
+     *    this.start.row <= row <= this.end.row &&
+     *    this.start.column <= column <= this.end.column
+     * ```
+     * @param {Number} row A row to check for
+     * @param {Number} column A column to check for
+     * @returns {Boolean}
+     * @related Range.compare
+     **/
+
+    this.contains = function(row, column) {
+        return this.compare(row, column) == 0;
+    };
+
+    /**
+     * Compares `this` range (A) with another range (B).
+     * @param {Range} range A range to compare with
+     *
+     * @related Range.compare
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * <br/>
+     * * `-2`: (B) is in front of (A), and doesn't intersect with (A)<br/>
+     * * `-1`: (B) begins before (A) but ends inside of (A)<br/>
+     * * `0`: (B) is completely inside of (A) OR (A) is completely inside of (B)<br/>
+     * * `+1`: (B) begins inside of (A) but ends outside of (A)<br/>
+     * * `+2`: (B) is after (A) and doesn't intersect with (A)<br/>
+     * * `42`: FTW state: (B) ends in (A) but starts outside of (A)
+     **/
+    this.compareRange = function(range) {
+        var cmp,
+            end = range.end,
+            start = range.start;
+
+        cmp = this.compare(end.row, end.column);
+        if (cmp == 1) {
+            cmp = this.compare(start.row, start.column);
+            if (cmp == 1) {
+                return 2;
+            } else if (cmp == 0) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else if (cmp == -1) {
+            return -2;
+        } else {
+            cmp = this.compare(start.row, start.column);
+            if (cmp == -1) {
+                return -1;
+            } else if (cmp == 1) {
+                return 42;
+            } else {
+                return 0;
+            }
+        }
+    };
+
+    /**
+     * Checks the row and column points of `p` with the row and column points of the calling range.
+     *
+     * @param {Range} p A point to compare with
+     *
+     * @related Range.compare
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * * `0` if the two points are exactly equal<br/>
+     * * `-1` if `p.row` is less then the calling range<br/>
+     * * `1` if `p.row` is greater than the calling range<br/>
+     * <br/>
+     * If the starting row of the calling range is equal to `p.row`, and:<br/>
+     * * `p.column` is greater than or equal to the calling range's starting column, this returns `0`<br/>
+     * * Otherwise, it returns -1<br/>
+     *<br/>
+     * If the ending row of the calling range is equal to `p.row`, and:<br/>
+     * * `p.column` is less than or equal to the calling range's ending column, this returns `0`<br/>
+     * * Otherwise, it returns 1<br/>
+     **/
+    this.comparePoint = function(p) {
+        return this.compare(p.row, p.column);
+    };
+
+    /**
+     * Checks the start and end points of `range` and compares them to the calling range. Returns `true` if the `range` is contained within the caller's range.
+     * @param {Range} range A range to compare with
+     *
+     * @returns {Boolean}
+     * @related Range.comparePoint
+     **/
+    this.containsRange = function(range) {
+        return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
+    };
+
+    /**
+     * Returns `true` if passed in `range` intersects with the one calling this method.
+     * @param {Range} range A range to compare with
+     *
+     * @returns {Boolean}
+     **/
+    this.intersects = function(range) {
+        var cmp = this.compareRange(range);
+        return (cmp == -1 || cmp == 0 || cmp == 1);
+    };
+
+    /**
+     * Returns `true` if the caller's ending row point is the same as `row`, and if the caller's ending column is the same as `column`.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     * @returns {Boolean}
+     **/
+    this.isEnd = function(row, column) {
+        return this.end.row == row && this.end.column == column;
+    };
+
+    /**
+     * Returns `true` if the caller's starting row point is the same as `row`, and if the caller's starting column is the same as `column`.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     * @returns {Boolean}
+     **/
+    this.isStart = function(row, column) {
+        return this.start.row == row && this.start.column == column;
+    };
+
+    /**
+     * Sets the starting row and column for the range.
+     * @param {Number} row A row point to set
+     * @param {Number} column A column point to set
+     *
+     **/
+    this.setStart = function(row, column) {
+        if (typeof row == "object") {
+            this.start.column = row.column;
+            this.start.row = row.row;
+        } else {
+            this.start.row = row;
+            this.start.column = column;
+        }
+    };
+
+    /**
+     * Sets the starting row and column for the range.
+     * @param {Number} row A row point to set
+     * @param {Number} column A column point to set
+     *
+     **/
+    this.setEnd = function(row, column) {
+        if (typeof row == "object") {
+            this.end.column = row.column;
+            this.end.row = row.row;
+        } else {
+            this.end.row = row;
+            this.end.column = column;
+        }
+    };
+
+    /**
+     * Returns `true` if the `row` and `column` are within the given range.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     *
+     * @returns {Boolean}
+     * @related Range.compare
+     **/
+    this.inside = function(row, column) {
+        if (this.compare(row, column) == 0) {
+            if (this.isEnd(row, column) || this.isStart(row, column)) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    /**
+     * Returns `true` if the `row` and `column` are within the given range's starting points.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     * @returns {Boolean}
+     * @related Range.compare
+     **/
+    this.insideStart = function(row, column) {
+        if (this.compare(row, column) == 0) {
+            if (this.isEnd(row, column)) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    /**
+     * Returns `true` if the `row` and `column` are within the given range's ending points.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     * @returns {Boolean}
+     * @related Range.compare
+     *
+     **/
+    this.insideEnd = function(row, column) {
+        if (this.compare(row, column) == 0) {
+            if (this.isStart(row, column)) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    /**
+     * Checks the row and column points with the row and column points of the calling range.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     *
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * `0` if the two points are exactly equal <br/>
+     * `-1` if `p.row` is less then the calling range <br/>
+     * `1` if `p.row` is greater than the calling range <br/>
+     *  <br/>
+     * If the starting row of the calling range is equal to `p.row`, and: <br/>
+     * `p.column` is greater than or equal to the calling range's starting column, this returns `0`<br/>
+     * Otherwise, it returns -1<br/>
+     * <br/>
+     * If the ending row of the calling range is equal to `p.row`, and: <br/>
+     * `p.column` is less than or equal to the calling range's ending column, this returns `0` <br/>
+     * Otherwise, it returns 1
+     **/
+    this.compare = function(row, column) {
+        if (!this.isMultiLine()) {
+            if (row === this.start.row) {
+                return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
+            };
+        }
+
+        if (row < this.start.row)
+            return -1;
+
+        if (row > this.end.row)
+            return 1;
+
+        if (this.start.row === row)
+            return column >= this.start.column ? 0 : -1;
+
+        if (this.end.row === row)
+            return column <= this.end.column ? 0 : 1;
+
+        return 0;
+    };
+
+    /**
+     * Checks the row and column points with the row and column points of the calling range.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * <br/>
+     * `0` if the two points are exactly equal<br/>
+     * `-1` if `p.row` is less then the calling range<br/>
+     * `1` if `p.row` is greater than the calling range, or if `isStart` is `true`.<br/>
+     * <br/>
+     * If the starting row of the calling range is equal to `p.row`, and:<br/>
+     * `p.column` is greater than or equal to the calling range's starting column, this returns `0`<br/>
+     * Otherwise, it returns -1<br/>
+     * <br/>
+     * If the ending row of the calling range is equal to `p.row`, and:<br/>
+     * `p.column` is less than or equal to the calling range's ending column, this returns `0`<br/>
+     * Otherwise, it returns 1
+     *
+     **/
+    this.compareStart = function(row, column) {
+        if (this.start.row == row && this.start.column == column) {
+            return -1;
+        } else {
+            return this.compare(row, column);
+        }
+    };
+
+    /**
+     * Checks the row and column points with the row and column points of the calling range.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     *
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * `0` if the two points are exactly equal<br/>
+     * `-1` if `p.row` is less then the calling range<br/>
+     * `1` if `p.row` is greater than the calling range, or if `isEnd` is `true.<br/>
+     * <br/>
+     * If the starting row of the calling range is equal to `p.row`, and:<br/>
+     * `p.column` is greater than or equal to the calling range's starting column, this returns `0`<br/>
+     * Otherwise, it returns -1<br/>
+     *<br/>
+     * If the ending row of the calling range is equal to `p.row`, and:<br/>
+     * `p.column` is less than or equal to the calling range's ending column, this returns `0`<br/>
+     * Otherwise, it returns 1
+     */
+    this.compareEnd = function(row, column) {
+        if (this.end.row == row && this.end.column == column) {
+            return 1;
+        } else {
+            return this.compare(row, column);
+        }
+    };
+
+    /**
+     * Checks the row and column points with the row and column points of the calling range.
+     * @param {Number} row A row point to compare with
+     * @param {Number} column A column point to compare with
+     *
+     *
+     * @returns {Number} This method returns one of the following numbers:<br/>
+     * * `1` if the ending row of the calling range is equal to `row`, and the ending column of the calling range is equal to `column`<br/>
+     * * `-1` if the starting row of the calling range is equal to `row`, and the starting column of the calling range is equal to `column`<br/>
+     * <br/>
+     * Otherwise, it returns the value after calling [[Range.compare `compare()`]].
+     *
+     **/
+    this.compareInside = function(row, column) {
+        if (this.end.row == row && this.end.column == column) {
+            return 1;
+        } else if (this.start.row == row && this.start.column == column) {
+            return -1;
+        } else {
+            return this.compare(row, column);
+        }
+    };
+
+    /**
+     * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object.
+     * @param {Number} firstRow The starting row
+     * @param {Number} lastRow The ending row
+     *
+     *
+     * @returns {Range}
+    **/
+    this.clipRows = function(firstRow, lastRow) {
+        if (this.end.row > lastRow)
+            var end = {row: lastRow + 1, column: 0};
+        else if (this.end.row < firstRow)
+            var end = {row: firstRow, column: 0};
+
+        if (this.start.row > lastRow)
+            var start = {row: lastRow + 1, column: 0};
+        else if (this.start.row < firstRow)
+            var start = {row: firstRow, column: 0};
+
+        return Range.fromPoints(start || this.start, end || this.end);
+    };
+
+    /**
+     * Changes the row and column points for the calling range for both the starting and ending points.
+     * @param {Number} row A new row to extend to
+     * @param {Number} column A new column to extend to
+     *
+     *
+     * @returns {Range} The original range with the new row
+    **/
+    this.extend = function(row, column) {
+        var cmp = this.compare(row, column);
+
+        if (cmp == 0)
+            return this;
+        else if (cmp == -1)
+            var start = {row: row, column: column};
+        else
+            var end = {row: row, column: column};
+
+        return Range.fromPoints(start || this.start, end || this.end);
+    };
+
+    this.isEmpty = function() {
+        return (this.start.row === this.end.row && this.start.column === this.end.column);
+    };
+
+    /**
+     *
+     * Returns `true` if the range spans across multiple lines.
+     * @returns {Boolean}
+    **/
+    this.isMultiLine = function() {
+        return (this.start.row !== this.end.row);
+    };
+
+    /**
+     *
+     * Returns a duplicate of the calling range.
+     * @returns {Range}
+    **/
+    this.clone = function() {
+        return Range.fromPoints(this.start, this.end);
+    };
+
+    /**
+     *
+     * Returns a range containing the starting and ending rows of the original range, but with a column value of `0`.
+     * @returns {Range}
+    **/
+    this.collapseRows = function() {
+        if (this.end.column == 0)
+            return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0)
+        else
+            return new Range(this.start.row, 0, this.end.row, 0)
+    };
+
+    /**
+     * Given the current `Range`, this function converts those starting and ending points into screen positions, and then returns a new `Range` object.
+     * @param {EditSession} session The `EditSession` to retrieve coordinates from
+     *
+     *
+     * @returns {Range}
+    **/
+    this.toScreenRange = function(session) {
+        var screenPosStart = session.documentToScreenPosition(this.start);
+        var screenPosEnd = session.documentToScreenPosition(this.end);
+
+        return new Range(
+            screenPosStart.row, screenPosStart.column,
+            screenPosEnd.row, screenPosEnd.column
+        );
+    };
+    
+    
+    /* experimental */
+    this.moveBy = function(row, column) {
+        this.start.row += row;
+        this.start.column += column;
+        this.end.row += row;
+        this.end.column += column;
+    };
+
+}).call(Range.prototype);
+
+/**
+ * Creates and returns a new `Range` based on the row and column of the given parameters.
+ * @param {Range} start A starting point to use
+ * @param {Range} end An ending point to use
+ *
+ * @returns {Range}
+**/
+Range.fromPoints = function(start, end) {
+    return new Range(start.row, start.column, end.row, end.column);
+};
+Range.comparePoints = comparePoints;
+
+Range.comparePoints = function(p1, p2) {
+    return p1.row - p2.row || p1.column - p2.column;
+};
+
+
+exports.Range = Range;
+});