Ace definitions updated. I added more tests.

ace/ace.d.ts

@@ -240,7 +240,7 @@ module AceAjax {
          * Gives list of tokens of the row. (tokens are cached)
          * @param row The row to get tokens at
         **/
-        getTokens(row: number): any;
+        getTokens(row: number): TokenInfo[];
 
         /**
          * [Returns the state of tokenization at the end of a row.]{: #BackgroundTokenizer.getState}
@@ -531,7 +531,7 @@ module AceAjax {
          * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows.
          * @param row The row to start at
         **/
-        getTokens(row: number): any[];
+        getTokens(row: number): TokenInfo[];
 
         /**
          * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`.
@@ -1817,6 +1817,8 @@ module AceAjax {
 
         end: Position;
 
+        isEmpty(): bool;
+
         /**
          * 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 A range to check against
@@ -1994,6 +1996,7 @@ module AceAjax {
      * @param endColumn The ending column
     **/
     declare var Range: {
+        fromPoints(pos1: Position, pos2: Position): Range;
         new(startRow: number, startColumn: number, endRow: number, endColumn: number): Range;
     }    
 
@@ -2125,6 +2128,12 @@ module AceAjax {
     **/
     export interface Selection {
 
+        addEventListener(ev: string, callback: Function);
+
+        moveCursorWordLeft();
+
+        moveCursorWordRight();
+
         fromOrientedRange(range: Range);
 
         setSelectionRange(match);
@@ -2476,7 +2485,7 @@ module AceAjax {
         /**
          * Returns the current tokenized string.
         **/
-        getCurrentToken(): string;
+        getCurrentToken(): TokenInfo;
 
         /**
          * Returns the current row.
@@ -2583,10 +2592,18 @@ module AceAjax {
     **/
     export interface VirtualRenderer {
 
+        scroller: any;
+
+        characterWidth: number;
+
+        lineHeight: number;
+
+        screenToTextCoordinates(left: number, top: number);
+
         /**
          * Associates the renderer with an [[EditSession `EditSession`]].
         **/
-        setSession();
+        setSession(session: IEditSession);
 
         /**
          * Triggers a partial update of the text, from the range given by the two parameters.
@@ -2913,7 +2930,7 @@ module AceAjax {
          * @param container The root element of the editor
          * @param theme The starting theme
         **/
-        new(container: HTMLElement, theme: string): VirtualRenderer;
+        new(container: HTMLElement, theme?: string): VirtualRenderer;
     }
 }
 

ace/all-tests.ts

@@ -16,6 +16,11 @@ var JavaScriptMode = null;
 /// <reference path="tests/ace-multi_select-tests.ts" />
 /// <reference path="tests/ace-placeholder-tests.ts" />
 /// <reference path="tests/ace-range_list-tests.ts" />
+/// <reference path="tests/ace-range-tests.ts" />
+/// <reference path="tests/ace-search-tests.ts" />
+/// <reference path="tests/ace-selection-tests.ts" />
+/// <reference path="tests/ace-token_iterator-tests.ts" />
+/// <reference path="tests/ace-virtual_renderer-tests.ts" />
 
 
 

ace/tests/ace-range-tests.ts

@@ -0,0 +1,146 @@
+/// <reference path="../ace.d.ts" />
+
+exports = {
+
+    name: "ACE range.js",
+
+    "test: create range": function () {
+        var range = new AceAjax.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 = AceAjax.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 AceAjax.Range(0, 20, 100, 30).clipRows(10, 30), 10, 0, 31, 0);
+        assert.range(new AceAjax.Range(0, 20, 30, 10).clipRows(10, 30), 10, 0, 30, 10);
+
+        var range = new AceAjax.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 AceAjax.Range(1, 2, 1, 2);
+        assert.ok(range.isEmpty());
+
+        var range = new AceAjax.Range(1, 2, 1, 6);
+        assert.notOk(range.isEmpty());
+    },
+
+    "test: is multi line": function () {
+        var range = new AceAjax.Range(1, 2, 1, 6);
+        assert.notOk(range.isMultiLine());
+
+        var range = new AceAjax.Range(1, 2, 2, 6);
+        assert.ok(range.isMultiLine());
+    },
+
+    "test: clone": function () {
+        var range = new AceAjax.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 AceAjax.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 AceAjax.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 AceAjax.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 AceAjax.Range(0, 2, 1, 2);
+        assert.range(range.collapseRows(), 0, 0, 1, 0);
+
+        var range = new AceAjax.Range(2, 2, 3, 1);
+        assert.range(range.collapseRows(), 2, 0, 3, 0);
+
+        var range = new AceAjax.Range(2, 2, 3, 0);
+        assert.range(range.collapseRows(), 2, 0, 2, 0);
+
+        var range = new AceAjax.Range(2, 0, 2, 0);
+        assert.range(range.collapseRows(), 2, 0, 2, 0);
+    },
+
+    "test: to screen range": function () {
+        var session = new AceAjax.EditSession([
+            "juhu",
+            "12\t\t34",
+            "ぁぁa",
+            "\t\t34",
+        ]);
+
+        var range = new AceAjax.Range(0, 0, 0, 3);
+        assert.range(range.toScreenRange(session), 0, 0, 0, 3);
+
+        var range = new AceAjax.Range(1, 1, 1, 3);
+        assert.range(range.toScreenRange(session), 1, 1, 1, 4);
+
+        var range = new AceAjax.Range(2, 1, 2, 2);
+        assert.range(range.toScreenRange(session), 2, 2, 2, 4);
+
+        var range = new AceAjax.Range(3, 0, 3, 4);
+        assert.range(range.toScreenRange(session), 3, 0, 3, 10);
+    }
+};

ace/tests/ace-search-tests.ts

@@ -0,0 +1,416 @@
+/// <reference path="../ace.d.ts" />
+
+exports = {
+    "test: configure the search object": function () {
+        var search = new AceAjax.Search();
+        search.set({
+            needle: "juhu"
+        });
+    },
+
+    "test: find simple text in document": function () {
+        var session = new AceAjax.EditSession(["juhu kinners 123", "456"]);
+        var search = new AceAjax.Search().set({
+            needle: "kinners"
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 0, 5);
+        assert.position(range.end, 0, 12);
+    },
+
+    "test: find simple text in next line": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+        var search = new AceAjax.Search().set({
+            needle: "kinners"
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 5);
+        assert.position(range.end, 1, 12);
+    },
+
+    "test: find text starting at cursor position": function () {
+        var session = new AceAjax.EditSession(["juhu kinners", "juhu kinners 123"]);
+        session.getSelection().moveCursorTo(0, 6);
+        var search = new AceAjax.Search().set({
+            needle: "kinners"
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 5);
+        assert.position(range.end, 1, 12);
+    },
+
+    "test: wrap search is on by default": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+        session.getSelection().moveCursorTo(2, 1);
+
+        var search = new AceAjax.Search().set({
+            needle: "kinners"
+        });
+
+        assert.notEqual(search.find(session), null);
+    },
+
+    "test: wrap search should wrap at file end": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+        session.getSelection().moveCursorTo(2, 1);
+
+        var search = new AceAjax.Search().set({
+            needle: "kinners",
+            wrap: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 5);
+        assert.position(range.end, 1, 12);
+    },
+
+    "test: wrap search should find needle even if it starts inside it": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+        session.getSelection().moveCursorTo(6, 1);
+
+        var search = new AceAjax.Search().set({
+            needle: "kinners",
+            wrap: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 5);
+        assert.position(range.end, 1, 12);
+    },
+
+    "test: wrap search with no match should return 'null'": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+        session.getSelection().moveCursorTo(2, 1);
+
+        var search = new AceAjax.Search().set({
+            needle: "xyz",
+            wrap: true
+        });
+
+        assert.equal(search.find(session), null);
+    },
+
+    "test: case sensitive is by default off": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "JUHU"
+        });
+
+        assert.range(search.find(session), 1, 0, 1, 4);
+    },
+
+    "test: case sensitive search": function () {
+        var session = new AceAjax.EditSession(["abc", "juhu kinners 123", "456"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "KINNERS",
+            caseSensitive: true
+        });
+
+        var range = search.find(session);
+        assert.equal(range, null);
+    },
+
+    "test: whole word search should not match inside of words": function () {
+        var session = new AceAjax.EditSession(["juhukinners", "juhu kinners 123", "456"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "kinners",
+            wholeWord: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 5);
+        assert.position(range.end, 1, 12);
+    },
+
+    "test: find backwards": function () {
+        var session = new AceAjax.EditSession(["juhu juhu juhu juhu"]);
+        session.getSelection().moveCursorTo(0, 10);
+        var search = new AceAjax.Search().set({
+            needle: "juhu",
+            backwards: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 0, 5);
+        assert.position(range.end, 0, 9);
+    },
+
+    "test: find in selection": function () {
+        var session = new AceAjax.EditSession(["juhu", "juhu", "juhu", "juhu"]);
+        session.getSelection().setSelectionAnchor(1, 0);
+        session.getSelection().selectTo(3, 5);
+
+        var search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true,
+            range: session.getSelection().getRange()
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 0);
+        assert.position(range.end, 1, 4);
+
+        search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true,
+            range: session.getSelection().getRange()
+        });
+
+        session.getSelection().setSelectionAnchor(0, 2);
+        session.getSelection().selectTo(3, 2);
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 0);
+        assert.position(range.end, 1, 4);
+    },
+
+    "test: find backwards in selection": function () {
+        var session = new AceAjax.EditSession(["juhu", "juhu", "juhu", "juhu"]);
+
+        session.getSelection().setSelectionAnchor(0, 2);
+        session.getSelection().selectTo(3, 2);
+
+        var search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true,
+            backwards: true,
+            range: session.getSelection().getRange()
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 2, 0);
+        assert.position(range.end, 2, 4);
+
+        search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true,
+            range: session.getSelection().getRange()
+        });
+
+        session.getSelection().setSelectionAnchor(0, 2);
+        session.getSelection().selectTo(1, 2);
+
+        var range = search.find(session);
+        assert.position(range.start, 1, 0);
+        assert.position(range.end, 1, 4);
+    },
+
+    "test: edge case - match directly before the cursor": function () {
+        var session = new AceAjax.EditSession(["123", "123", "juhu"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true
+        });
+
+        session.getSelection().moveCursorTo(2, 5);
+
+        var range = search.find(session);
+        assert.position(range.start, 2, 0);
+        assert.position(range.end, 2, 4);
+    },
+
+    "test: edge case - match backwards directly after the cursor": function () {
+        var session = new AceAjax.EditSession(["123", "123", "juhu"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "juhu",
+            wrap: true,
+            backwards: true
+        });
+
+        session.getSelection().moveCursorTo(2, 0);
+
+        var range = search.find(session);
+        assert.position(range.start, 2, 0);
+        assert.position(range.end, 2, 4);
+    },
+
+    "test: find using a regular expression": function () {
+        var session = new AceAjax.EditSession(["abc123 123 cd", "abc"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "\\d+",
+            regExp: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 0, 3);
+        assert.position(range.end, 0, 6);
+    },
+
+    "test: find using a regular expression and whole word": function () {
+        var session = new AceAjax.EditSession(["abc123 123 cd", "abc"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "\\d+\\b",
+            regExp: true,
+            wholeWord: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 0, 7);
+        assert.position(range.end, 0, 10);
+    },
+
+    "test: use regular expressions with capture groups": function () {
+        var session = new AceAjax.EditSession(["  ab: 12px", "  <h1 abc"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "(\\d+)",
+            regExp: true
+        });
+
+        var range = search.find(session);
+        assert.position(range.start, 0, 6);
+        assert.position(range.end, 0, 8);
+    },
+
+    "test: find all matches in selection": function () {
+        var session = new AceAjax.EditSession(["juhu", "juhu", "juhu", "juhu"]);
+
+        session.getSelection().setSelectionAnchor(0, 2);
+        session.getSelection().selectTo(3, 2);
+
+        var search = new AceAjax.Search().set({
+            needle: "uh",
+            wrap: true,
+            range: session.getSelection().getRange()
+        });
+
+        var ranges = search.findAll(session);
+
+        assert.equal(ranges.length, 2);
+        assert.position(ranges[0].start, 1, 1);
+        assert.position(ranges[0].end, 1, 3);
+        assert.position(ranges[1].start, 2, 1);
+        assert.position(ranges[1].end, 2, 3);
+    },
+
+
+    "test: find all multiline matches": function () {
+        var session = new AceAjax.EditSession(["juhu", "juhu", "juhu", "juhu"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "hu\nju",
+            wrap: true
+        });
+
+        var ranges = search.findAll(session);
+
+        assert.equal(ranges.length, 3);
+        assert.position(ranges[0].start, 0, 2);
+        assert.position(ranges[0].end, 1, 2);
+        assert.position(ranges[1].start, 1, 2);
+        assert.position(ranges[1].end, 2, 2);
+    },
+
+    "test: replace() should return the replacement if the input matches the needle": function () {
+        var search = new AceAjax.Search().set({
+            needle: "juhu"
+        });
+
+        assert.equal(search.replace("juhu", "kinners"), "kinners");
+        assert.equal(search.replace("", "kinners"), null);
+        assert.equal(search.replace(" juhu", "kinners"), null);
+
+        // case sensitivity
+        assert.equal(search.replace("Juhu", "kinners"), "kinners");
+        search.set({ caseSensitive: true });
+        assert.equal(search.replace("Juhu", "kinners"), null);
+
+        // regexp replacement
+    },
+
+    "test: replace with a RegExp search": function () {
+        var search = new AceAjax.Search().set({
+            needle: "\\d+",
+            regExp: true
+        });
+
+        assert.equal(search.replace("123", "kinners"), "kinners");
+        assert.equal(search.replace("01234", "kinners"), "kinners");
+        assert.equal(search.replace("", "kinners"), null);
+        assert.equal(search.replace("a12", "kinners"), null);
+        assert.equal(search.replace("12a", "kinners"), null);
+    },
+
+    "test: replace with RegExp match and capture groups": function () {
+        var search = new AceAjax.Search().set({
+            needle: "ab(\\d\\d)",
+            regExp: true
+        });
+
+        assert.equal(search.replace("ab12", "cd$1"), "cd12");
+        assert.equal(search.replace("ab12", "-$&-"), "-ab12-");
+        assert.equal(search.replace("ab12", "$$"), "$");
+    },
+
+    "test: find all using regular expresion containing $": function () {
+        var session = new AceAjax.EditSession(["a", "     b", "c ", "d"]);
+
+        var search = new AceAjax.Search().set({
+            needle: "[ ]+$",
+            regExp: true,
+            wrap: true
+        });
+
+        session.getSelection().moveCursorTo(1, 2);
+        var ranges = search.findAll(session);
+
+        assert.equal(ranges.length, 1);
+        assert.position(ranges[0].start, 2, 1);
+        assert.position(ranges[0].end, 2, 2);
+    },
+
+    "test: find all matches in a line": function () {
+        var session = new AceAjax.EditSession("foo bar foo baz foobar foo");
+
+        var search = new AceAjax.Search().set({
+            needle: "foo",
+            wrap: true,
+            wholeWord: true
+        });
+
+        session.getSelection().moveCursorTo(0, 4);
+
+        var ranges = search.findAll(session);
+
+        assert.equal(ranges.length, 3);
+        assert.position(ranges[0].start, 0, 0);
+        assert.position(ranges[0].end, 0, 3);
+        assert.position(ranges[1].start, 0, 8);
+        assert.position(ranges[1].end, 0, 11);
+        assert.position(ranges[2].start, 0, 23);
+        assert.position(ranges[2].end, 0, 26);
+    },
+
+    "test: find all matches in a line backwards": function () {
+        var session = new AceAjax.EditSession("foo bar foo baz foobar foo");
+
+        var search = new AceAjax.Search().set({
+            needle: "foo",
+            wrap: true,
+            wholeWord: true,
+            backwards: true
+        });
+
+        session.getSelection().moveCursorTo(0, 13);
+
+        var ranges = search.findAll(session);
+
+        assert.equal(ranges.length, 3);
+        assert.position(ranges[2].start, 0, 23);
+        assert.position(ranges[2].end, 0, 26);
+        assert.position(ranges[1].start, 0, 8);
+        assert.position(ranges[1].end, 0, 11);
+        assert.position(ranges[0].start, 0, 0);
+        assert.position(ranges[0].end, 0, 3);
+    },
+};

ace/tests/ace-selection-tests.ts

@@ -0,0 +1,411 @@
+/// <reference path="../ace.d.ts" />
+
+exports = {
+    createSession: function (rows, cols) {
+        var line = new Array(cols + 1).join("a");
+        var text = new Array(rows).join(line + "\n") + line;
+        return new AceAjax.EditSession(text);
+    },
+
+    "test: move cursor to end of file should place the cursor on last row and column": function () {
+        var session = this.createSession(200, 10);
+        var selection = session.getSelection();
+
+        selection.moveCursorFileEnd();
+        assert.position(selection.getCursor(), 199, 10);
+    },
+
+    "test: moveCursor to start of file should place the cursor on the first row and column": function () {
+        var session = this.createSession(200, 10);
+        var selection = session.getSelection();
+
+        selection.moveCursorFileStart();
+        assert.position(selection.getCursor(), 0, 0);
+    },
+
+    "test: move selection lead to end of file": function () {
+        var session = this.createSession(200, 10);
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(100, 5);
+        selection.selectFileEnd();
+
+        var range = selection.getRange();
+
+        assert.position(range.start, 100, 5);
+        assert.position(range.end, 199, 10);
+    },
+
+    "test: move selection lead to start of file": function () {
+        var session = this.createSession(200, 10);
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(100, 5);
+        selection.selectFileStart();
+
+        var range = selection.getRange();
+
+        assert.position(range.start, 0, 0);
+        assert.position(range.end, 100, 5);
+    },
+
+    "test: move cursor word right": function () {
+        var session = new AceAjax.EditSession([
+            "ab",
+            " Juhu Kinners (abc, 12)",
+            " cde"
+        ].join("\n"));
+
+        var selection = session.getSelection();
+
+        selection.moveCursorDown();
+        assert.position(selection.getCursor(), 1, 0);
+
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 1, 5);
+
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 1, 13);
+
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 1, 18);
+
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 1, 22);
+
+        // wrap line
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 2, 4);
+
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 2, 4);
+    },
+
+    "test: select word right if cursor in word": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 2);
+        selection.moveCursorWordRight();
+
+        assert.position(selection.getCursor(), 0, 4);
+    },
+
+    "test: moveCursor word left": function () {
+        var session = new AceAjax.EditSession([
+            "ab",
+            " Juhu Kinners (abc, 12)",
+            " cde"
+        ].join("\n"));
+
+        var selection = session.getSelection();
+
+        selection.moveCursorDown();
+        selection.moveCursorLineEnd();
+        assert.position(selection.getCursor(), 1, 23);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 1, 20);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 1, 15);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 1, 6);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 1, 1);
+
+        // wrap line
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 0);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 0);
+    },
+
+    "test: moveCursor word left with umlauts": function () {
+        var session = new AceAjax.EditSession(" Fuß Füße");
+
+        var selection = session.getSelection();
+        selection.moveCursorTo(0, 9)
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 5);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 1);
+    },
+
+    "test: select word left if cursor in word": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 8);
+
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 5);
+    },
+
+    "test: select word right and select": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 0);
+        selection.selectWordRight();
+
+        var range = selection.getRange();
+
+        assert.position(range.start, 0, 0);
+        assert.position(range.end, 0, 4);
+    },
+
+    "test: select word left and select": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 3);
+        selection.selectWordLeft();
+
+        var range = selection.getRange();
+
+        assert.position(range.start, 0, 0);
+        assert.position(range.end, 0, 3);
+    },
+
+    "test: select word with cursor in word should select the word": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners 123");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 8);
+        selection.selectWord();
+
+        var range = selection.getRange();
+        assert.position(range.start, 0, 5);
+        assert.position(range.end, 0, 12);
+    },
+
+    "test: select word with cursor in word including right whitespace should select the word": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners      123");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 8);
+        selection.selectAWord();
+
+        var range = selection.getRange();
+        assert.position(range.start, 0, 5);
+        assert.position(range.end, 0, 18);
+    },
+
+    "test: select word with cursor betwen white space and word should select the word": function () {
+        var session = new AceAjax.EditSession("Juhu Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 4);
+        selection.selectWord();
+
+        var range = selection.getRange();
+        assert.position(range.start, 0, 0);
+        assert.position(range.end, 0, 4);
+
+        selection.moveCursorTo(0, 5);
+        selection.selectWord();
+
+        var range = selection.getRange();
+        assert.position(range.start, 0, 5);
+        assert.position(range.end, 0, 12);
+    },
+
+    "test: select word with cursor in white space should select white space": function () {
+        var session = new AceAjax.EditSession("Juhu  Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 5);
+        selection.selectWord();
+
+        var range = selection.getRange();
+        assert.position(range.start, 0, 4);
+        assert.position(range.end, 0, 6);
+    },
+
+    "test: moving cursor should fire a 'changeCursor' event": function () {
+        var session = new AceAjax.EditSession("Juhu  Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 5);
+
+        var called = false;
+        selection.addEventListener("changeCursor", function () {
+            called = true;
+        });
+
+        selection.moveCursorTo(0, 6);
+        assert.ok(called);
+    },
+
+    "test: calling setCursor with the same position should not fire an event": function () {
+        var session = new AceAjax.EditSession("Juhu  Kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 5);
+
+        var called = false;
+        selection.addEventListener("changeCursor", function () {
+            called = true;
+        });
+
+        selection.moveCursorTo(0, 5);
+        assert.notOk(called);
+    },
+
+    "test: moveWordright should move past || and [": function () {
+        var session = new AceAjax.EditSession("||foo[");
+        var selection = session.getSelection();
+
+        // Move behind ||foo
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 0, 5);
+
+        // Move behind [
+        selection.moveCursorWordRight();
+        assert.position(selection.getCursor(), 0, 6);
+    },
+
+    "test: moveWordLeft should move past || and [": function () {
+        var session = new AceAjax.EditSession("||foo[");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 6);
+
+        // Move behind [foo
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 2);
+
+        // Move behind ||
+        selection.moveCursorWordLeft();
+        assert.position(selection.getCursor(), 0, 0);
+    },
+
+    "test: move cursor to line start should move cursor to end of the indentation first": function () {
+        var session = new AceAjax.EditSession("12\n    Juhu\n12");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(1, 6);
+        selection.moveCursorLineStart();
+
+        assert.position(selection.getCursor(), 1, 4);
+    },
+
+    "test: move cursor to line start when the cursor is at the end of the indentation should move cursor to column 0": function () {
+        var session = new AceAjax.EditSession("12\n    Juhu\n12");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(1, 4);
+        selection.moveCursorLineStart();
+
+        assert.position(selection.getCursor(), 1, 0);
+    },
+
+    "test: move cursor to line start when the cursor is at column 0 should move cursor to the end of the indentation": function () {
+        var session = new AceAjax.EditSession("12\n    Juhu\n12");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(1, 0);
+        selection.moveCursorLineStart();
+
+        assert.position(selection.getCursor(), 1, 4);
+    },
+
+    // Eclipse style
+    "test: move cursor to line start when the cursor is before the initial indentation should move cursor to the end of the indentation": function () {
+        var session = new AceAjax.EditSession("12\n    Juhu\n12");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(1, 2);
+        selection.moveCursorLineStart();
+
+        assert.position(selection.getCursor(), 1, 4);
+    },
+
+    "test go line up when in the middle of the first line should go to document start": function () {
+        var session = new AceAjax.EditSession("juhu kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 4);
+        selection.moveCursorUp();
+
+        assert.position(selection.getCursor(), 0, 0);
+    },
+
+    "test: (wrap) go line up when in the middle of the first line should go to document start": function () {
+        var session = new AceAjax.EditSession("juhu kinners");
+        session.setWrapLimitRange(5, 5);
+        session.adjustWrapLimit(80);
+
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 4);
+        selection.moveCursorUp();
+
+        assert.position(selection.getCursor(), 0, 0);
+    },
+
+
+    "test go line down when in the middle of the last line should go to document end": function () {
+        var session = new AceAjax.EditSession("juhu kinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 4);
+        selection.moveCursorDown();
+
+        assert.position(selection.getCursor(), 0, 12);
+    },
+
+    "test (wrap) go line down when in the middle of the last line should go to document end": function () {
+        var session = new AceAjax.EditSession("juhu kinners");
+        session.setWrapLimitRange(8, 8);
+        session.adjustWrapLimit(80);
+
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 10);
+        selection.moveCursorDown();
+
+        assert.position(selection.getCursor(), 0, 12);
+    },
+
+    "test go line up twice and then once down when in the second should go back to the previous column": function () {
+        var session = new AceAjax.EditSession("juhu\nkinners");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(1, 4);
+        selection.moveCursorUp();
+        selection.moveCursorUp();
+        selection.moveCursorDown();
+
+        assert.position(selection.getCursor(), 1, 4);
+    },
+
+    "test (keyboard navigation) when curLine is not EOL and targetLine is all whitespace new column should be current column": function () {
+        var session = new AceAjax.EditSession("function (a) {\n\
+  \n\
+}");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(2, 0);
+        selection.moveCursorUp();
+
+        assert.position(selection.getCursor(), 1, 0);
+    },
+
+    "test (keyboard navigation) when curLine is EOL and targetLine is shorter dan current column, new column should be targetLine's EOL": function () {
+        var session = new AceAjax.EditSession("function (a) {\n\
+  \n\
+}");
+        var selection = session.getSelection();
+
+        selection.moveCursorTo(0, 14);
+        selection.moveCursorDown();
+
+        assert.position(selection.getCursor(), 1, 4);
+    }
+};

ace/tests/ace-token_iterator-tests.ts

@@ -0,0 +1,166 @@
+/// <reference path="../ace.d.ts" />
+
+exports = {
+    "test: token iterator initialization in JavaScript document": function () {
+        var lines = [
+            "function foo(items) {",
+            "    for (var i=0; i<items.length; i++) {",
+            "        alert(items[i] + \"juhu\");",
+            "    } // Real Tab.",
+            "}"
+        ];
+        var session = new AceAjax.EditSession(lines.join("\n"), new JavaScriptMode());
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 0);
+        assert.equal(iterator.getCurrentToken().value, "function");
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        iterator.stepForward();
+        assert.equal(iterator.getCurrentToken().value, " ");
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 8);
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 4);
+        assert.equal(iterator.getCurrentToken().value, "function");
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        iterator.stepForward();
+        assert.equal(iterator.getCurrentToken().value, " ");
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 8);
+
+        var iterator = new AceAjax.TokenIterator(session, 2, 18);
+        assert.equal(iterator.getCurrentToken().value, "items");
+        assert.equal(iterator.getCurrentTokenRow(), 2);
+        assert.equal(iterator.getCurrentTokenColumn(), 14);
+
+        iterator.stepForward();
+        assert.equal(iterator.getCurrentToken().value, "[");
+        assert.equal(iterator.getCurrentTokenRow(), 2);
+        assert.equal(iterator.getCurrentTokenColumn(), 19);
+
+        var iterator = new AceAjax.TokenIterator(session, 4, 0);
+        assert.equal(iterator.getCurrentToken().value, "}");
+        assert.equal(iterator.getCurrentTokenRow(), 4);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        iterator.stepBackward();
+        assert.equal(iterator.getCurrentToken().value, "// Real Tab.");
+        assert.equal(iterator.getCurrentTokenRow(), 3);
+        assert.equal(iterator.getCurrentTokenColumn(), 6);
+
+        var iterator = new AceAjax.TokenIterator(session, 5, 0);
+        assert.equal(iterator.getCurrentToken(), null);
+    },
+
+    "test: token iterator initialization in text document": function () {
+        var lines = [
+            "Lorem ipsum dolor sit amet, consectetur adipisicing elit,",
+            "sed do eiusmod tempor incididunt ut labore et dolore magna",
+            "aliqua. Ut enim ad minim veniam, quis nostrud exercitation",
+            "ullamco laboris nisi ut aliquip ex ea commodo consequat."
+        ];
+        var session = new AceAjax.EditSession(lines.join("\n"));
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 0);
+        assert.equal(iterator.getCurrentToken().value, lines[0]);
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 4);
+        assert.equal(iterator.getCurrentToken().value, lines[0]);
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        var iterator = new AceAjax.TokenIterator(session, 2, 18);
+        assert.equal(iterator.getCurrentToken().value, lines[2]);
+        assert.equal(iterator.getCurrentTokenRow(), 2);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        var iterator = new AceAjax.TokenIterator(session, 3, lines[3].length - 1);
+        assert.equal(iterator.getCurrentToken().value, lines[3]);
+        assert.equal(iterator.getCurrentTokenRow(), 3);
+        assert.equal(iterator.getCurrentTokenColumn(), 0);
+
+        var iterator = new AceAjax.TokenIterator(session, 4, 0);
+        assert.equal(iterator.getCurrentToken(), null);
+    },
+
+    "test: token iterator step forward in JavaScript document": function () {
+        var lines = [
+            "function foo(items) {",
+            "    for (var i=0; i<items.length; i++) {",
+            "        alert(items[i] + \"juhu\");",
+            "    } // Real Tab.",
+            "}"
+        ];
+        var session = new AceAjax.EditSession(lines.join("\n"), new JavaScriptMode());
+
+        var tokens = [];
+        var len = session.getLength();
+        for (var i = 0; i < len; i++)
+            tokens = tokens.concat(session.getTokens(i));
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 0);
+        for (var i = 1; i < tokens.length; i++)
+            assert.equal(iterator.stepForward(), tokens[i]);
+        assert.equal(iterator.stepForward(), null);
+        assert.equal(iterator.getCurrentToken(), null);
+    },
+
+    "test: token iterator step backward in JavaScript document": function () {
+        var lines = [
+            "function foo(items) {",
+            "     for (var i=0; i<items.length; i++) {",
+            "         alert(items[i] + \"juhu\");",
+            "     } // Real Tab.",
+            "}"
+        ];
+        var session = new AceAjax.EditSession(lines.join("\n"), new JavaScriptMode());
+
+        var tokens = [];
+        var len = session.getLength();
+        for (var i = 0; i < len; i++)
+            tokens = tokens.concat(session.getTokens(i));
+
+        var iterator = new AceAjax.TokenIterator(session, 4, 0);
+        for (var i = tokens.length - 2; i >= 0; i--)
+            assert.equal(iterator.stepBackward(), tokens[i]);
+        assert.equal(iterator.stepBackward(), null);
+        assert.equal(iterator.getCurrentToken(), null);
+    },
+
+    "test: token iterator reports correct row and column": function () {
+        var lines = [
+            "function foo(items) {",
+            "    for (var i=0; i<items.length; i++) {",
+            "        alert(items[i] + \"juhu\");",
+            "    } // Real Tab.",
+            "}"
+        ];
+        var session = new AceAjax.EditSession(lines.join("\n"), new JavaScriptMode());
+
+        var iterator = new AceAjax.TokenIterator(session, 0, 0);
+
+        iterator.stepForward();
+        iterator.stepForward();
+
+        assert.equal(iterator.getCurrentToken().value, "foo");
+        assert.equal(iterator.getCurrentTokenRow(), 0);
+        assert.equal(iterator.getCurrentTokenColumn(), 9);
+
+        iterator.stepForward();
+        iterator.stepForward();
+        iterator.stepForward();
+        iterator.stepForward();
+        iterator.stepForward();
+        iterator.stepForward();
+        iterator.stepForward();
+
+        assert.equal(iterator.getCurrentToken().value, "for");
+        assert.equal(iterator.getCurrentTokenRow(), 1);
+        assert.equal(iterator.getCurrentTokenColumn(), 4);
+    }
+};

ace/tests/ace-virtual_renderer-tests.ts

@@ -0,0 +1,40 @@
+/// <reference path="../ace.d.ts" />
+
+exports = {
+    "test: screen2text the column should be rounded to the next character edge": function () {
+        var el = document.createElement("div");
+
+        if (!el.getBoundingClientRect) {
+            console.log("Skipping test: This test only runs in the browser");
+            return;
+        }
+
+        el.style.left = "20px";
+        el.style.top = "30px";
+        el.style.width = "300px";
+        el.style.height = "100px";
+        document.body.appendChild(el);
+
+        var renderer = new AceAjax.VirtualRenderer(el);
+        renderer.setPadding(0);
+        renderer.setSession(new AceAjax.EditSession("1234"));
+
+        var r = renderer.scroller.getBoundingClientRect();
+        function testPixelToText(x, y, row, column) {
+            assert.position(renderer.screenToTextCoordinates(x + r.left, y + r.top), row, column);
+        }
+
+        renderer.characterWidth = 10;
+        renderer.lineHeight = 15;
+
+        testPixelToText(4, 0, 0, 0);
+        testPixelToText(5, 0, 0, 1);
+        testPixelToText(9, 0, 0, 1);
+        testPixelToText(10, 0, 0, 1);
+        testPixelToText(14, 0, 0, 1);
+        testPixelToText(15, 0, 0, 2);
+        document.body.removeChild(el);
+    }
+
+    // change tab size after setDocument (for text layer)
+};