gollum 3.1.2 → 3.1.3

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/incremental_search_test.js

@@ -0,0 +1,213 @@
+/* ***** 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");
+}
+
+define(function(require, exports, module) {
+"use strict";
+
+var emacs = require('./keyboard/emacs');
+var EditSession = require("./edit_session").EditSession;
+var Editor = require("./editor").Editor;
+var MockRenderer = require("./test/mockrenderer").MockRenderer;
+var Range = require("./range").Range;
+var MultiSelect = require("./multi_select").MultiSelect;
+var assert = require("./test/assertions");
+var IncrementalSearch = require("./incremental_search").IncrementalSearch;
+
+require("./multi_select");
+
+var editor, iSearch;
+function testRanges(str, ranges) {
+    ranges = ranges || editor.selection.getAllRanges();
+    assert.equal(ranges + "", str + "");
+}
+
+// force "rerender"
+function callHighlighterUpdate() {
+    var session = editor.session,
+        ranges = [],
+        mockMarkerLayer = {
+            drawSingleLineMarker: function(_, markerRanges) {
+                ranges = ranges.concat(markerRanges);
+            }
+        }
+    session.$isearchHighlight.update([], mockMarkerLayer, session, {
+        firstRow: 0, lastRow: session.getRowLength()});
+    return ranges;
+}
+
+module.exports = {
+
+    name: "ACE incremental_search.js",
+
+    setUp: function() {
+        var session = new EditSession(["abc123", "xyz124"]);
+        editor = new Editor(new MockRenderer(), session);
+        new MultiSelect(editor);
+        iSearch = new IncrementalSearch();
+    },
+
+    "test: keyboard handler setup" : function() {
+        iSearch.activate(editor);
+        assert.equal(editor.getKeyboardHandler(), iSearch.$keyboardHandler);
+        iSearch.deactivate();
+        assert.notEqual(editor.getKeyboardHandler(), iSearch.$keyboardHandler);
+    },
+
+    "test: isearch highlight setup" : function() {
+        var sess = editor.session;
+        iSearch.activate(editor);
+        iSearch.highlight('foo');
+        var highl = sess.$isearchHighlight.id;
+        assert.ok(sess.$isearchHighlight, 'session has no isearch highlighter');
+        assert.equal(sess.getMarkers()[highl.id], highl.id, 'isearch highlight not in markers');
+        iSearch.deactivate();
+        iSearch.activate(editor);
+        iSearch.highlight('bar');
+        var highl2 = sess.$isearchHighlight.id;
+        assert.equal(highl2, highl, 'multiple isearch highlights');
+    },
+
+    "test: find simple text incrementally" : function() {
+        iSearch.activate(editor);
+        var range = iSearch.addString('1'), // "1"
+            highlightRanges = callHighlighterUpdate(editor.session);
+        testRanges("Range: [0/3] -> [0/4]", [range], "range");
+        testRanges("Range: [0/3] -> [0/4],Range: [1/3] -> [1/4]", highlightRanges, "highlight");
+
+        range = iSearch.addString('2'); // "12"
+        highlightRanges = callHighlighterUpdate(editor.session);
+        testRanges("Range: [0/3] -> [0/5]", [range], "range");
+        testRanges("Range: [0/3] -> [0/5],Range: [1/3] -> [1/5]", highlightRanges, "highlight");
+
+        range = iSearch.addString('3'); // "123"
+        highlightRanges = callHighlighterUpdate(editor.session);
+        testRanges("Range: [0/3] -> [0/6]", [range], "range");
+        testRanges("Range: [0/3] -> [0/6]", highlightRanges, "highlight");
+
+        range = iSearch.removeChar(); // "12"
+        highlightRanges = callHighlighterUpdate(editor.session);
+        testRanges("Range: [0/3] -> [0/5]", [range], "range");
+        testRanges("Range: [0/3] -> [0/5],Range: [1/3] -> [1/5]", highlightRanges, "highlight");
+    },
+
+    "test: forward / backward" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');
+        var range = iSearch.next();
+        testRanges("Range: [1/3] -> [1/5]", [range], "range");
+
+        range = iSearch.next(); // nothing to find
+        testRanges("", [range], "range");
+
+        range = iSearch.next({backwards: true}); // backwards
+        testRanges("Range: [1/5] -> [1/3]", [range], "range");
+    },
+
+    "test: cancelSearch" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');
+        var range = iSearch.cancelSearch(true);
+        testRanges("Range: [0/0] -> [0/0]", [range], "range");
+
+        iSearch.addString('1'); range = iSearch.addString('2');
+        testRanges("Range: [0/3] -> [0/5]", [range], "range");
+    },
+
+    "test: failing search keeps pos" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');
+        var range = iSearch.addString('x');
+        testRanges("", [range], "range");
+        assert.position(editor.getCursorPosition(), 0, 5);
+    },
+
+    "test: backwards search" : function() {
+        editor.moveCursorTo(1,0);
+        iSearch.activate(editor, true);
+        iSearch.addString('1'); var range = iSearch.addString('2');;
+        testRanges("Range: [0/5] -> [0/3]", [range], "range");
+        assert.position(editor.getCursorPosition(), 0, 3);
+    },
+
+    "test: forwards then backwards, same result, reoriented range" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); var range = iSearch.addString('2');;
+        testRanges("Range: [0/3] -> [0/5]", [range], "range");
+        assert.position(editor.getCursorPosition(), 0, 5);
+
+        range = iSearch.next({backwards: true});
+        testRanges("Range: [0/5] -> [0/3]", [range], "range");
+        assert.position(editor.getCursorPosition(), 0, 3);
+    },
+
+    "test: reuse prev search via option" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');;
+        assert.position(editor.getCursorPosition(), 0, 5);
+        iSearch.deactivate();
+
+        iSearch.activate(editor);
+        iSearch.next({backwards: false, useCurrentOrPrevSearch: true});
+        assert.position(editor.getCursorPosition(), 1, 5);
+    },
+
+    "test: don't extend selection range if selection is empty" : function() {
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');;
+        testRanges("Range: [0/5] -> [0/5]", [editor.getSelectionRange()], "sel range");
+    },
+
+    "test: extend selection range if selection exists" : function() {
+        iSearch.activate(editor);
+        editor.selection.selectTo(0, 1);
+        iSearch.addString('1'); iSearch.addString('2');;
+        testRanges("Range: [0/0] -> [0/5]", [editor.getSelectionRange()], "sel range");
+    },
+
+    "test: extend selection in emacs mark mode" : function() {
+        var emacs = require('./keyboard/emacs');
+        editor.keyBinding.addKeyboardHandler(emacs.handler);
+        emacs.handler.commands.setMark.exec(editor);
+        iSearch.activate(editor);
+        iSearch.addString('1'); iSearch.addString('2');
+        testRanges("Range: [0/0] -> [0/5]", [editor.getSelectionRange()], "sel range");
+    }
+
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/keyboard/emacs.js

@@ -3,7 +3,7 @@
  *
  * 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
@@ -14,7 +14,7 @@
  *     * 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
@@ -32,15 +32,18 @@ define(function(require, exports, module) {
 "use strict";
 
 var dom = require("../lib/dom");
+require("../incremental_search");
+var iSearchCommandModule = require("../commands/incremental_search_commands");
 
-var screenToTextBlockCoordinates = function(pageX, pageY) {
+
+var screenToTextBlockCoordinates = function(x, y) {
     var canvasPos = this.scroller.getBoundingClientRect();
 
     var col = Math.floor(
-        (pageX + this.scrollLeft - canvasPos.left - this.$padding - dom.getPageScrollLeft()) / this.characterWidth
+        (x + this.scrollLeft - canvasPos.left - this.$padding) / this.characterWidth
     );
     var row = Math.floor(
-        (pageY + this.scrollTop - canvasPos.top - dom.getPageScrollTop()) / this.lineHeight
+        (y + this.scrollTop - canvasPos.top) / this.lineHeight
     );
 
     return this.session.screenToDocumentPosition(row, col);
@@ -49,20 +52,26 @@ var screenToTextBlockCoordinates = function(pageX, pageY) {
 var HashHandler = require("./hash_handler").HashHandler;
 exports.handler = new HashHandler();
 
+exports.handler.isEmacs = true;
+exports.handler.$id = "ace/keyboard/emacs";
+
 var initialized = false;
+var $formerLongWords;
+var $formerLineStart;
+
 exports.handler.attach = function(editor) {
     if (!initialized) {
         initialized = true;
         dom.importCssString('\
             .emacs-mode .ace_cursor{\
-                border: 2px rgba(50,250,50,0.8) solid!important;\
+                border: 1px rgba(50,250,50,0.8) solid!important;\
                 -moz-box-sizing: border-box!important;\
                 -webkit-box-sizing: border-box!important;\
                 box-sizing: border-box!important;\
                 background-color: rgba(0,250,0,0.9);\
                 opacity: 0.5;\
             }\
-            .emacs-mode .ace_cursor.ace_hidden{\
+            .emacs-mode .ace_hidden-cursors .ace_cursor{\
                 opacity: 1;\
                 background-color: transparent;\
             }\
@@ -79,110 +88,268 @@ exports.handler.attach = function(editor) {
             }', 'emacsMode'
         );
     }
+    // in emacs, gotowordleft/right should not count a space as a word..
+    $formerLongWords = editor.session.$selectLongWords;
+    editor.session.$selectLongWords = true;
+    // CTRL-A should go to actual beginning of line
+    $formerLineStart = editor.session.$useEmacsStyleLineStart;
+    editor.session.$useEmacsStyleLineStart = true;
+
+    editor.session.$emacsMark = null; // the active mark
+    editor.session.$emacsMarkRing = editor.session.$emacsMarkRing || [];
+
+    editor.emacsMark = function() {
+        return this.session.$emacsMark;
+    };
+
+    editor.setEmacsMark = function(p) {
+        // to deactivate pass in a falsy value
+        this.session.$emacsMark = p;
+    };
+
+    editor.pushEmacsMark = function(p, activate) {
+        var prevMark = this.session.$emacsMark;
+        if (prevMark)
+            this.session.$emacsMarkRing.push(prevMark);
+        if (!p || activate) this.setEmacsMark(p);
+        else this.session.$emacsMarkRing.push(p);
+    };
+
+    editor.popEmacsMark = function() {
+        var mark = this.emacsMark();
+        if (mark) { this.setEmacsMark(null); return mark; }
+        return this.session.$emacsMarkRing.pop();
+    };
+
+    editor.getLastEmacsMark = function(p) {
+        return this.session.$emacsMark || this.session.$emacsMarkRing.slice(-1)[0];
+    };
+
+    editor.emacsMarkForSelection = function(replacement) {
+        // find the mark in $emacsMarkRing corresponding to the current
+        // selection
+        var sel = this.selection,
+            multiRangeLength = this.multiSelect ?
+                this.multiSelect.getAllRanges().length : 1,
+            selIndex = sel.index || 0,
+            markRing = this.session.$emacsMarkRing,
+            markIndex = markRing.length - (multiRangeLength - selIndex),
+            lastMark = markRing[markIndex] || sel.anchor;
+        if (replacement) {
+            markRing.splice(markIndex, 1,
+                "row" in replacement && "column" in replacement ?
+                    replacement : undefined);
+        }
+        return lastMark;
+    }
 
+    editor.on("click", $resetMarkMode);
+    editor.on("changeSession", $kbSessionChange);
     editor.renderer.screenToTextCoordinates = screenToTextBlockCoordinates;
     editor.setStyle("emacs-mode");
+    editor.commands.addCommands(commands);
+    exports.handler.platform = editor.commands.platform;
+    editor.$emacsModeHandler = this;
+    editor.addEventListener('copy', this.onCopy);
+    editor.addEventListener('paste', this.onPaste);
 };
 
 exports.handler.detach = function(editor) {
     delete editor.renderer.screenToTextCoordinates;
+    editor.session.$selectLongWords = $formerLongWords;
+    editor.session.$useEmacsStyleLineStart = $formerLineStart;
+    editor.removeEventListener("click", $resetMarkMode);
+    editor.removeEventListener("changeSession", $kbSessionChange);
     editor.unsetStyle("emacs-mode");
+    editor.commands.removeCommands(commands);
+    editor.removeEventListener('copy', this.onCopy);
+    editor.removeEventListener('paste', this.onPaste);
+    editor.$emacsModeHandler = null;
+};
+
+var $kbSessionChange = function(e) {
+    if (e.oldSession) {
+        e.oldSession.$selectLongWords = $formerLongWords;
+        e.oldSession.$useEmacsStyleLineStart = $formerLineStart;
+    }
+
+    $formerLongWords = e.session.$selectLongWords;
+    e.session.$selectLongWords = true;
+    $formerLineStart = e.session.$useEmacsStyleLineStart;
+    e.session.$useEmacsStyleLineStart = true;
+
+    if (!e.session.hasOwnProperty('$emacsMark'))
+        e.session.$emacsMark = null;
+    if (!e.session.hasOwnProperty('$emacsMarkRing'))
+        e.session.$emacsMarkRing = [];
 };
 
+var $resetMarkMode = function(e) {
+    e.editor.session.$emacsMark = null;
+};
 
 var keys = require("../lib/keys").KEY_MODS;
-var eMods = {
-    C: "ctrl", S: "shift", M: "alt"
-};
-["S-C-M", "S-C", "S-M", "C-M", "S", "C", "M"].forEach(function(c) {
+var eMods = {C: "ctrl", S: "shift", M: "alt", CMD: "command"};
+var combinations = ["C-S-M-CMD",
+                    "S-M-CMD", "C-M-CMD", "C-S-CMD", "C-S-M",
+                    "M-CMD", "S-CMD", "S-M", "C-CMD", "C-M", "C-S",
+                    "CMD", "M", "S", "C"];
+combinations.forEach(function(c) {
     var hashId = 0;
-    c.split("-").forEach(function(c){
+    c.split("-").forEach(function(c) {
         hashId = hashId | keys[eMods[c]];
     });
     eMods[hashId] = c.toLowerCase() + "-";
 });
 
+exports.handler.onCopy = function(e, editor) {
+    if (editor.$handlesEmacsOnCopy) return;
+    editor.$handlesEmacsOnCopy = true;
+    exports.handler.commands.killRingSave.exec(editor);
+    editor.$handlesEmacsOnCopy = false;
+};
+
+exports.handler.onPaste = function(e, editor) {
+    editor.pushEmacsMark(editor.getCursorPosition());
+};
+
 exports.handler.bindKey = function(key, command) {
+    if (typeof key == "object")
+        key = key[this.platform];
     if (!key)
         return;
 
-    var ckb = this.commmandKeyBinding;
+    var ckb = this.commandKeyBinding;
     key.split("|").forEach(function(keyPart) {
         keyPart = keyPart.toLowerCase();
         ckb[keyPart] = command;
-        keyPart = keyPart.split(" ")[0];
-        if (!ckb[keyPart])
-            ckb[keyPart] = "null";
+        // register all partial key combos as null commands
+        // to be able to activate key combos with arbitrary length
+        // Example: if keyPart is "C-c C-l t" then "C-c C-l t" will
+        // get command assigned and "C-c" and "C-c C-l" will get
+        // a null command assigned in this.commandKeyBinding. For
+        // the lookup logic see handleKeyboard()
+        var keyParts = keyPart.split(" ").slice(0,-1);
+        keyParts.reduce(function(keyMapKeys, keyPart, i) {
+            var prefix = keyMapKeys[i-1] ? keyMapKeys[i-1] + ' ' : '';
+            return keyMapKeys.concat([prefix + keyPart]);
+        }, []).forEach(function(keyPart) {
+            if (!ckb[keyPart]) ckb[keyPart] = "null";
+        });
     }, this);
 };
 
+exports.handler.getStatusText = function(editor, data) {
+  var str = "";
+  if (data.count)
+    str += data.count;
+  if (data.keyChain)
+    str += " " + data.keyChain
+  return str;
+};
 
 exports.handler.handleKeyboard = function(data, hashId, key, keyCode) {
+    // if keyCode == -1 a non-printable key was pressed, such as just
+    // control. Handling those is currently not supported in this handler
+    if (keyCode === -1) return undefined;
+
+    var editor = data.editor;
+    editor._signal("changeStatus");
+    // insertstring data.count times
     if (hashId == -1) {
+        editor.pushEmacsMark();
         if (data.count) {
-            var str = Array(data.count + 1).join(key);
+            var str = new Array(data.count + 1).join(key);
             data.count = null;
             return {command: "insertstring", args: str};
         }
     }
 
-    if (key == "\x00")
-        return;
-
     var modifier = eMods[hashId];
-    if (modifier == "c-" || data.universalArgument) {
+
+    // CTRL + number / universalArgument for setting data.count
+    if (modifier == "c-" || data.count) {
         var count = parseInt(key[key.length - 1]);
-        if (count) {
-            data.count = count;
+        if (typeof count === 'number' && !isNaN(count)) {
+            data.count = Math.max(data.count, 0) || 0;
+            data.count = 10 * data.count + count;
             return {command: "null"};
         }
     }
-    data.universalArgument = false;
 
-    if (modifier)
-        key = modifier + key;
+    // this.commandKeyBinding maps key specs like "c-p" (for CTRL + P) to
+    // command objects, for lookup key needs to include the modifier
+    if (modifier) key = modifier + key;
 
-    if (data.keyChain)
-        key = data.keyChain += " " + key;
+    // Key combos like CTRL+X H build up the data.keyChain
+    if (data.keyChain) key = data.keyChain += " " + key;
 
-    var command = this.commmandKeyBinding[key];
+    // Key combo prefixes get stored as "null" (String!) in this
+    // this.commandKeyBinding. When encountered no command is invoked but we
+    // buld up data.keyChain
+    var command = this.commandKeyBinding[key];
     data.keyChain = command == "null" ? key : "";
 
-    if (!command)
-        return;
+    // there really is no command
+    if (!command) return undefined;
 
-    if (command == "null")
-        return {command: "null"};
+    // we pass b/c of key combo or universalArgument
+    if (command === "null") return {command: "null"};
 
-    if (command == "universalArgument") {
-        data.universalArgument = true;
+    if (command === "universalArgument") {
+        // if no number pressed emacs repeats action 4 times.
+        // minus sign is needed to allow next keypress to replace it
+        data.count = -4;
         return {command: "null"};
     }
 
-    if (typeof command != "string") {
-        var args = command.args;
-        command = command.command;
+    // lookup command
+    // TODO extract special handling of markmode
+    // TODO special case command.command is really unnecessary, remove
+    var args;
+    if (typeof command !== "string") {
+        args = command.args;
+        if (command.command) command = command.command;
+        if (command === "goorselect") {
+            command = editor.emacsMark() ? args[1] : args[0];
+            args = null;
+        }
     }
 
-    if (typeof command == "string") {
-        command = this.commands[command] || data.editor.commands.commands[command];
+    if (typeof command === "string") {
+        if (command === "insertstring" ||
+            command === "splitline" ||
+            command === "togglecomment") {
+            editor.pushEmacsMark();
+        }
+        command = this.commands[command] || editor.commands.commands[command];
+        if (!command) return undefined;
     }
 
-    if (!command.readonly && !command.isYank)
+    if (!command.readOnly && !command.isYank)
         data.lastCommand = null;
 
+    if (!command.readOnly && editor.emacsMark())
+        editor.setEmacsMark(null)
+        
     if (data.count) {
         var count = data.count;
         data.count = 0;
-        return {
-            args: args,
-            command: {
-                exec: function(editor, args) {
-                    for (var i = 0; i < count; i++)
-                        command.exec(editor, args);
+        if (!command || !command.handlesCount) {
+            return {
+                args: args,
+                command: {
+                    exec: function(editor, args) {
+                        for (var i = 0; i < count; i++)
+                            command.exec(editor, args);
+                    },
+                    multiSelectAction: command.multiSelectAction
                 }
-            }
-        };
+            };
+        } else {
+            if (!args) args = {};
+            if (typeof args === 'object') args.count = count;
+        }
     }
 
     return {command: command, args: args};
@@ -190,16 +357,16 @@ exports.handler.handleKeyboard = function(data, hashId, key, keyCode) {
 
 exports.emacsKeys = {
     // movement
-    "Up|C-p"      : "golineup",
-    "Down|C-n"    : "golinedown",
-    "Left|C-b"    : "gotoleft",
-    "Right|C-f"   : "gotoright",
-    "C-Left|M-b"  : "gotowordleft",
-    "C-Right|M-f" : "gotowordright",
-    "Home|C-a"    : "gotolinestart",
-    "End|C-e"     : "gotolineend",
-    "C-Home|S-M-,": "gotostart",
-    "C-End|S-M-." : "gotoend",
+    "Up|C-p"      : {command: "goorselect", args: ["golineup","selectup"]},
+    "Down|C-n"    : {command: "goorselect", args: ["golinedown","selectdown"]},
+    "Left|C-b"    : {command: "goorselect", args: ["gotoleft","selectleft"]},
+    "Right|C-f"   : {command: "goorselect", args: ["gotoright","selectright"]},
+    "C-Left|M-b"  : {command: "goorselect", args: ["gotowordleft","selectwordleft"]},
+    "C-Right|M-f" : {command: "goorselect", args: ["gotowordright","selectwordright"]},
+    "Home|C-a"    : {command: "goorselect", args: ["gotolinestart","selecttolinestart"]},
+    "End|C-e"     : {command: "goorselect", args: ["gotolineend","selecttolineend"]},
+    "C-Home|S-M-,": {command: "goorselect", args: ["gotostart","selecttostart"]},
+    "C-End|S-M-." : {command: "goorselect", args: ["gotoend","selecttoend"]},
 
     // selection
     "S-Up|S-C-p"      : "selectup",
@@ -219,14 +386,16 @@ exports.emacsKeys = {
     "C-x C-p": "selectall",
 
     // todo fix these
-    "C-Down": "gotopagedown",
-    "C-Up": "gotopageup",
-    "PageDown|C-v": "gotopagedown",
-    "PageUp|M-v": "gotopageup",
+    "C-Down": {command: "goorselect", args: ["gotopagedown","selectpagedown"]},
+    "C-Up": {command: "goorselect", args: ["gotopageup","selectpageup"]},
+    "PageDown|C-v": {command: "goorselect", args: ["gotopagedown","selectpagedown"]},
+    "PageUp|M-v": {command: "goorselect", args: ["gotopageup","selectpageup"]},
     "S-C-Down": "selectpagedown",
     "S-C-Up": "selectpageup",
-    "C-s": "findnext",
-    "C-r": "findprevious",
+
+    "C-s": "iSearch",
+    "C-r": "iSearchBackwards",
+
     "M-C-s": "findnext",
     "M-C-r": "findprevious",
     "S-M-5": "replace",
@@ -245,27 +414,26 @@ exports.emacsKeys = {
     "M-y": "yankRotate",
     "C-g": "keyboardQuit",
 
-    "C-w": "killRegion",
+    "C-w|C-S-W": "killRegion",
     "M-w": "killRingSave",
-
     "C-Space": "setMark",
     "C-x C-x": "exchangePointAndMark",
 
     "C-t": "transposeletters",
-
-    "M-u": "touppercase",
+    "M-u": "touppercase",    // Doesn't work
     "M-l": "tolowercase",
-    "M-/": "autocomplete",
+    "M-/": "autocomplete",   // Doesn't work
     "C-u": "universalArgument",
+
     "M-;": "togglecomment",
 
     "C-/|C-x u|S-C--|C-z": "undo",
     "S-C-/|S-C-x u|C--|S-C-z": "redo", //infinite undo?
     // vertical editing
-    "C-x r":  "selectRectangularRegion"
-
+    "C-x r":  "selectRectangularRegion",
+    "M-x": {command: "focusCommandLine", args: "M-x "}
     // todo
-    // "M-x" "C-x C-t" "M-t" "M-c" "F11" "C-M- "M-q"
+    // "C-x C-t" "M-t" "M-c" "F11" "C-M- "M-q"
 };
 
 
@@ -275,7 +443,7 @@ exports.handler.addCommands({
     recenterTopBottom: function(editor) {
         var renderer = editor.renderer;
         var pos = renderer.$cursorLayer.getPixelPosition();
-        var h = renderer.$size.scrollerHeight - renderer.lineHeight;       
+        var h = renderer.$size.scrollerHeight - renderer.lineHeight;
         var scrollTop = renderer.scrollTop;
         if (Math.abs(pos.top - scrollTop) < 2) {
             scrollTop = pos.top - h;
@@ -289,15 +457,74 @@ exports.handler.addCommands({
     selectRectangularRegion:  function(editor) {
         editor.multiSelect.toggleBlockSelection();
     },
-    setMark:  function() {
+    setMark:  {
+        exec: function(editor, args) {
+            // Sets mark-mode and clears current selection.
+            // When mark is set, keyboard cursor movement commands become
+            // selection modification commands. That is,
+            // "goto" commands become "select" commands.
+            // Any insertion or mouse click resets mark-mode.
+            // setMark twice in a row at the same place resets markmode.
+            // in multi select mode, ea selection is handled individually
+
+            if (args && args.count) {
+                if (editor.inMultiSelectMode) editor.forEachSelection(moveToMark);
+                else moveToMark();
+                moveToMark();
+                return;
+            }
+
+            var mark = editor.emacsMark(),
+                ranges = editor.selection.getAllRanges(),
+                rangePositions = ranges.map(function(r) { return {row: r.start.row, column: r.start.column}; }),
+                transientMarkModeActive = true,
+                hasNoSelection = ranges.every(function(range) { return range.isEmpty(); });
+            // if transientMarkModeActive then mark behavior is a little
+            // different. Deactivate the mark when setMark is run with active
+            // mark
+            if (transientMarkModeActive && (mark || !hasNoSelection)) {
+                if (editor.inMultiSelectMode) editor.forEachSelection({exec: editor.clearSelection.bind(editor)})
+                else editor.clearSelection();
+                if (mark) editor.pushEmacsMark(null);
+                return;
+            }
+
+            if (!mark) {
+                rangePositions.forEach(function(pos) { editor.pushEmacsMark(pos); });
+                editor.setEmacsMark(rangePositions[rangePositions.length-1]);
+                return;
+            }
+
+            // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+            function moveToMark() {
+                var mark = editor.popEmacsMark();
+                mark && editor.moveCursorToPosition(mark);
+            }
+
+        },
+        readOnly: true,
+        handlesCount: true
     },
     exchangePointAndMark: {
-        exec: function(editor) {
-            var range = editor.selection.getRange();
-            editor.selection.setSelectionRange(range, !editor.selection.isBackwards());
+        exec: function exchangePointAndMark$exec(editor, args) {
+            var sel = editor.selection;
+            if (!args.count && !sel.isEmpty()) { // just invert selection
+                sel.setSelectionRange(sel.getRange(), !sel.isBackwards());
+                return;
+            }
+
+            if (args.count) { // replace mark and point
+                var pos = {row: sel.lead.row, column: sel.lead.column};
+                sel.clearSelection();
+                sel.moveCursorToPosition(editor.emacsMarkForSelection(pos));
+            } else { // create selection to last mark
+                sel.selectToPosition(editor.emacsMarkForSelection());
+            }
         },
-        readonly: true,
-        multiselectAction: "forEach"
+        readOnly: true,
+        handlesCount: true,
+        multiSelectAction: "forEach"
     },
     killWord: {
         exec: function(editor, dir) {
@@ -314,10 +541,23 @@ exports.handler.addCommands({
             editor.session.remove(range);
             editor.clearSelection();
         },
-        multiselectAction: "forEach"
+        multiSelectAction: "forEach"
     },
     killLine: function(editor) {
-        editor.selection.selectLine();
+        editor.pushEmacsMark(null);
+        var pos = editor.getCursorPosition();
+        if (pos.column === 0 &&
+            editor.session.doc.getLine(pos.row).length === 0) {
+            // If an already empty line is killed, remove
+            // the line entirely
+            editor.selection.selectLine();
+        } else {
+            // otherwise just remove from the current cursor position
+            // to the end (but don't delete the selection if it's before
+            // the cursor)
+            editor.clearSelection();
+            editor.selection.selectLineEnd();
+        }
         var range = editor.getSelectionRange();
         var text = editor.session.getTextRange(range);
         exports.killRing.add(text);
@@ -326,26 +566,63 @@ exports.handler.addCommands({
         editor.clearSelection();
     },
     yank: function(editor) {
-        editor.onPaste(exports.killRing.get());
+        editor.onPaste(exports.killRing.get() || '');
         editor.keyBinding.$data.lastCommand = "yank";
     },
     yankRotate: function(editor) {
         if (editor.keyBinding.$data.lastCommand != "yank")
             return;
-
         editor.undo();
+        editor.session.$emacsMarkRing.pop(); // also undo recording mark
         editor.onPaste(exports.killRing.rotate());
         editor.keyBinding.$data.lastCommand = "yank";
     },
-    killRegion: function(editor) {
-        exports.killRing.add(editor.getCopyText());
-        editor.commands.byName.cut.exec(editor);
+    killRegion: {
+        exec: function(editor) {
+            exports.killRing.add(editor.getCopyText());
+            editor.commands.byName.cut.exec(editor);
+        },
+        readOnly: true,
+        multiSelectAction: "forEach"
     },
-    killRingSave: function(editor) {
-        exports.killRing.add(editor.getCopyText());
+    killRingSave: {
+        exec: function(editor) {
+            // copy text and deselect. will save marks for starts of the
+            // selection(s)
+
+            editor.$handlesEmacsOnCopy = true;
+            var marks = editor.session.$emacsMarkRing.slice(),
+                deselectedMarks = [];
+            exports.killRing.add(editor.getCopyText());
+
+            setTimeout(function() {
+                function deselect() {
+                    var sel = editor.selection, range = sel.getRange(),
+                        pos = sel.isBackwards() ? range.end : range.start;
+                    deselectedMarks.push({row: pos.row, column: pos.column});
+                    sel.clearSelection();
+                }
+                editor.$handlesEmacsOnCopy = false;
+                if (editor.inMultiSelectMode) editor.forEachSelection({exec: deselect});
+                else deselect();
+                editor.session.$emacsMarkRing = marks.concat(deselectedMarks.reverse());
+            }, 0);
+        },
+        readOnly: true
+    },
+    keyboardQuit: function(editor) {
+        editor.selection.clearSelection();
+        editor.setEmacsMark(null);
+        editor.keyBinding.$data.count = null;
+    },
+    focusCommandLine: function(editor, arg) {
+        if (editor.showCommandLine)
+            editor.showCommandLine(arg);
     }
 });
 
+exports.handler.addCommands(iSearchCommandModule.iSearchStartCommands);
+
 var commands = exports.handler.commands;
 commands.yank.isYank = true;
 commands.yankRotate.isYank = true;
@@ -357,8 +634,9 @@ exports.killRing = {
         if (this.$data.length > 30)
             this.$data.shift();
     },
-    get: function() {
-        return this.$data[this.$data.length - 1] || "";
+    get: function(n) {
+        n = n || 1;
+        return this.$data.slice(this.$data.length-n, this.$data.length).reverse().join('\n');
     },
     pop: function() {
         if (this.$data.length > 1)
@@ -371,5 +649,4 @@ exports.killRing = {
     }
 };
 
-
 });