DevTools: [CodeMirror] Implement "select next occurrence" functionality

Source/devtools/front_end/CodeMirrorTextEditor.js

 /*
  * Copyright (C) 2012 Google Inc. 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
@@ skipping 71 matching lines @@
         "End": "goLineEnd",
         "Home": "goLineStartSmart",
         "PageUp": "goPageUp",
         "PageDown": "goPageDown",
         "Delete": "delCharAfter",
         "Backspace": "delCharBefore",
         "Tab": "defaultTab",
         "Shift-Tab": "indentLess",
         "Enter": "smartNewlineAndIndent",
         "Ctrl-Space": "autocomplete",
+        "Ctrl-D": "selectNextOccurence",

[apavlov, 2014/04/01 08:24:58]

ditto for this file

         "Esc": "dismissMultipleSelections"
     };
 
     CodeMirror.keyMap["devtools-pc"] = {
         "Ctrl-A": "selectAll",
         "Ctrl-Z": "undoAndReveal",
         "Shift-Ctrl-Z": "redoAndReveal",
         "Ctrl-Y": "redo",
         "Ctrl-Home": "goDocStart",
         "Ctrl-Up": "goDocStart",
@@ skipping 34 matching lines @@
     this._codeMirror.setOption("keyMap", WebInspector.isMac() ? "devtools-mac" : "devtools-pc");
     this._codeMirror.setOption("flattenSpans", false);
 
     this._codeMirror.setOption("maxHighlightLength", WebInspector.CodeMirrorTextEditor.maxHighlightLength);
     this._codeMirror.setOption("mode", null);
     this._codeMirror.setOption("crudeMeasuringFrom", 1000);
 
     this._shouldClearHistory = true;
     this._lineSeparator = "\n";
 
-    this._tokenHighlighter = new WebInspector.CodeMirrorTextEditor.TokenHighlighter(this._codeMirror);
+    this._tokenHighlighter = new WebInspector.CodeMirrorTextEditor.TokenHighlighter(this, this._codeMirror);
     this._blockIndentController = new WebInspector.CodeMirrorTextEditor.BlockIndentController(this._codeMirror);
     this._fixWordMovement = new WebInspector.CodeMirrorTextEditor.FixWordMovement(this._codeMirror);
     this._autocompleteController = new WebInspector.CodeMirrorTextEditor.AutocompleteController(this, this._codeMirror);
+    this._selectNextOccurenceController = new WebInspector.CodeMirrorTextEditor.SelectNextOccurenceController(this, this._codeMirror);
 
     this._codeMirror.on("changes", this._changes.bind(this));
     this._codeMirror.on("beforeChange", this._beforeChange.bind(this));
     this._codeMirror.on("gutterClick", this._gutterClick.bind(this));
     this._codeMirror.on("cursorActivity", this._cursorActivity.bind(this));
     this._codeMirror.on("beforeSelectionChange", this._beforeSelectionChange.bind(this));
     this._codeMirror.on("scroll", this._scroll.bind(this));
     this._codeMirror.on("focus", this._focus.bind(this));
     this._codeMirror.on("blur", this._blur.bind(this));
     this.element.addEventListener("contextmenu", this._contextMenu.bind(this), false);
@@ skipping 22 matching lines @@
 }
 
 /** @typedef {{canceled: boolean, from: CodeMirror.Pos, to: CodeMirror.Pos, text: string, origin: string, cancel: function()}} */
 WebInspector.CodeMirrorTextEditor.BeforeChangeObject;
 
 /** @typedef {{from: CodeMirror.Pos, to: CodeMirror.Pos, origin: string, text: !Array.<string>, removed: !Array.<string>}} */
 WebInspector.CodeMirrorTextEditor.ChangeObject;
 
 WebInspector.CodeMirrorTextEditor.maxHighlightLength = 1000;
 
+/**
+ * @param {!CodeMirror} codeMirror
+ */
 WebInspector.CodeMirrorTextEditor.autocompleteCommand = function(codeMirror)
 {
     codeMirror._codeMirrorTextEditor._autocompleteController.autocomplete();
 }
 CodeMirror.commands.autocomplete = WebInspector.CodeMirrorTextEditor.autocompleteCommand;
 
+/**
+ * @param {!CodeMirror} codeMirror
+ */
+WebInspector.CodeMirrorTextEditor.selectNextOccurenceCommand = function(codeMirror)
+{
+    codeMirror._codeMirrorTextEditor._selectNextOccurenceController.selectNextOccurence();
+}
+CodeMirror.commands.selectNextOccurence = WebInspector.CodeMirrorTextEditor.selectNextOccurenceCommand;
+
+/**
+ * @param {!CodeMirror} codeMirror
+ */
 CodeMirror.commands.smartNewlineAndIndent = function(codeMirror)
 {
     codeMirror.operation(innerSmartNewlineAndIndent.bind(null, codeMirror));
 
     function countIndent(line)
     {
         for (var i = 0; i < line.length; ++i) {
             if (!WebInspector.TextUtils.isSpaceChar(line[i]))
                 return i;
         }
@@ skipping 698 matching lines @@
         var newRange = this._toRange(pos.start, this._codeMirror.posFromIndex(this._codeMirror.indexFromPos(pos.start) + text.length));
         this._delegate.onTextChanged(range, newRange);
         if (WebInspector.settings.textEditorAutoDetectIndent.get())
             this._updateEditorIndentation();
         return newRange;
     },
 
     /**
      * @param {number} lineNumber
      * @param {number} column
-     * @param {boolean=} prefixOnly
      * @return {?WebInspector.TextRange}
      */
-    _wordRangeForCursorPosition: function(lineNumber, column, prefixOnly)
+    _wordRangeForCursorPosition: function(lineNumber, column)
     {
         var line = this.line(lineNumber);
-        if (column === 0 || !WebInspector.TextUtils.isWordChar(line.charAt(column - 1)))
-            return null;
-        var wordStart = column - 1;
-        while (wordStart > 0 && WebInspector.TextUtils.isWordChar(line.charAt(wordStart - 1)))
-            --wordStart;
-        if (prefixOnly)
-            return new WebInspector.TextRange(lineNumber, wordStart, lineNumber, column);
+        var wordStart = column;
+        if (column !== 0 && WebInspector.TextUtils.isWordChar(line.charAt(column - 1))) {
+            wordStart = column - 1;
+            while (wordStart > 0 && WebInspector.TextUtils.isWordChar(line.charAt(wordStart - 1)))
+                --wordStart;
+        }
         var wordEnd = column;
         while (wordEnd < line.length && WebInspector.TextUtils.isWordChar(line.charAt(wordEnd)))
             ++wordEnd;
         return new WebInspector.TextRange(lineNumber, wordStart, lineNumber, wordEnd);
     },
 
     /**
      * @param {!CodeMirror} codeMirror
      * @param {!WebInspector.CodeMirrorTextEditor.BeforeChangeObject} changeObject
      */
@@ skipping 74 matching lines @@
         if (!this._tokenHighlighter.highlightedRegex())
             this._codeMirror.operation(this._tokenHighlighter.highlightSelectedTokens.bind(this._tokenHighlighter));
     },
 
     /**
      * @param {!CodeMirror} codeMirror
      * @param {{ranges: !Array.<{head: !CodeMirror.Pos, anchor: !CodeMirror.Pos}>}} selection
      */
     _beforeSelectionChange: function(codeMirror, selection)
     {
+        this._selectNextOccurenceController.selectionWillChange();
         if (!this._isHandlingMouseDownEvent)
             return;
         if (!selection.ranges.length)
             return;
         var primarySelection = selection.ranges[0];
         this._reportJump(this.selection(), this._toRange(primarySelection.anchor, primarySelection.head));
     },
 
     /**
      * @param {?WebInspector.TextRange} from
@@ skipping 56 matching lines @@
      */
     selection: function()
     {
         var start = this._codeMirror.getCursor("anchor");
         var end = this._codeMirror.getCursor("head");
 
         return this._toRange(start, end);
     },
 
     /**
+     * @return {!Array.<!WebInspector.TextRange>}
+     */
+    selections: function()
+    {
+        var selectionList = this._codeMirror.listSelections();
+        var result = [];
+        for (var i = 0; i < selectionList.length; ++i) {
+            var selection = selectionList[i];
+            result.push(this._toRange(selection.anchor, selection.head));
+        }
+        return result;
+    },
+
+    /**
      * @return {?WebInspector.TextRange}
      */
     lastSelection: function()
     {
         return this._lastSelection;
     },
 
     /**
      * @param {!WebInspector.TextRange} textRange
      */
     setSelection: function(textRange)
     {
         this._lastSelection = textRange;
         var pos = this._toPos(textRange);
         this._codeMirror.setSelection(pos.start, pos.end);
     },
 
     /**
+     * @param {!Array.<!WebInspector.TextRange>} ranges
+     */
+    setSelections: function(ranges)
+    {
+        var selections = [];
+        for (var i = 0; i < ranges.length; ++i) {
+            var selection = this._toPos(ranges[i]);
+            selections.push({
+                anchor: selection.start,
+                head: selection.end
+            });
+        }
+        this._codeMirror.setSelections(selections);
+    },
+
+    /**
      * @param {string} text
      */
     _detectLineSeparator: function(text)
     {
         this._lineSeparator = text.indexOf("\r\n") >= 0 ? "\r\n" : "\n";
     },
 
     /**
      * @param {string} text
      */
@@ skipping 153 matching lines @@
      * @return {boolean}
      */
     equal: function(positionHandle)
     {
         return positionHandle._lineHandle === this._lineHandle && positionHandle._columnNumber == this._columnNumber && positionHandle._codeMirror === this._codeMirror;
     }
 }
 
 /**
  * @constructor
+ * @param {!WebInspector.CodeMirrorTextEditor} textEditor
  * @param {!CodeMirror} codeMirror
  */
-WebInspector.CodeMirrorTextEditor.TokenHighlighter = function(codeMirror)
+WebInspector.CodeMirrorTextEditor.TokenHighlighter = function(textEditor, codeMirror)
 {
+    this._textEditor = textEditor;
     this._codeMirror = codeMirror;
 }
 
 WebInspector.CodeMirrorTextEditor.TokenHighlighter.prototype = {
     /**
      * @param {!RegExp} regex
      * @param {?WebInspector.TextRange} range
      */
     highlightSearchResults: function(regex, range)
     {
@@ skipping 24 matching lines @@
     },
 
     /**
      * @return {!RegExp|undefined}
      */
     highlightedRegex: function()
     {
         return this._highlightRegex;
     },
 
+    /**
+     * @param {!Array.<string>} selections
+     */
+    _validateSelections: function(selections)
+    {
+        var mainText = selections[0];
+        for (var i = 1; i < selections.length; ++i) {
+            if (selections[i] !== mainText)
+                return false;
+        }
+        return true;
+    },
+
     highlightSelectedTokens: function()
     {
         delete this._highlightRegex;
         delete this._highlightRange;
 
         if (this._highlightDescriptor && this._highlightDescriptor.selectionStart)
             this._codeMirror.removeLineClass(this._highlightDescriptor.selectionStart.line, "wrap", "cm-line-with-selection");
         this._removeHighlight();
         var selectionStart = this._codeMirror.getCursor("start");
         var selectionEnd = this._codeMirror.getCursor("end");
         if (selectionStart.line !== selectionEnd.line)
             return;
         if (selectionStart.ch === selectionEnd.ch)
             return;
 
         var selections = this._codeMirror.getSelections();
-        if (selections.length !== 1)
+        if (!this._validateSelections(selections))
             return;
         var selectedText = selections[0];
         if (this._isWord(selectedText, selectionStart.line, selectionStart.ch, selectionEnd.ch)) {
             if (selectionStart)
                 this._codeMirror.addLineClass(selectionStart.line, "wrap", "cm-line-with-selection")
             this._setHighlighter(this._tokenHighlighter.bind(this, selectedText, selectionStart), selectionStart);
         }
     },
 
     /**
@@ skipping 213 matching lines @@
 WebInspector.CodeMirrorTextEditor.AutocompleteController.prototype = {
     /**
      * @param {!WebInspector.TextRange} mainSelection
      * @param {!Array.<!{head: !CodeMirror.Pos, anchor: !CodeMirror.Pos}>} selections
      * @return {boolean}
      */
     _validateSelectionsContexts: function(mainSelection, selections)
     {
         var mainSelectionContext = this._textEditor.copyRange(mainSelection);
         for (var i = 0; i < selections.length; ++i) {
-            var wordRange = this._textEditor._wordRangeForCursorPosition(selections[i].head.line, selections[i].head.ch, false);
+            var wordRange = this._textEditor._wordRangeForCursorPosition(selections[i].head.line, selections[i].head.ch);
             if (!wordRange)
                 return false;
             var context = this._textEditor.copyRange(wordRange);
             if (context !== mainSelectionContext)
                 return false;
         }
         return true;
     },
 
     autocomplete: function()
     {
         var dictionary = this._textEditor._dictionary;
         if (!dictionary || this._codeMirror.somethingSelected()) {
             this.finishAutocomplete();
             return;
         }
 
         var selections = this._codeMirror.listSelections().slice();
         var topSelection = selections.shift();
         var cursor = topSelection.head;
-        var substituteRange = this._textEditor._wordRangeForCursorPosition(cursor.line, cursor.ch, false);
+        var substituteRange = this._textEditor._wordRangeForCursorPosition(cursor.line, cursor.ch);
         if (!substituteRange || substituteRange.startColumn === cursor.ch || !this._validateSelectionsContexts(substituteRange, selections)) {
             this.finishAutocomplete();
             return;
         }
 
         var prefixRange = substituteRange.clone();
         prefixRange.endColumn = cursor.ch;
 
         var substituteWord = this._textEditor.copyRange(substituteRange);
         var hasPrefixInDictionary = dictionary.hasWord(substituteWord);
@@ skipping 104 matching lines @@
      * @return {?AnchorBox}
      */
     _anchorBoxForPosition: function(line, column)
     {
         var metrics = this._textEditor.cursorPositionToCoordinates(line, column);
         return metrics ? new AnchorBox(metrics.x, metrics.y, 0, metrics.height) : null;
     },
 }
 
 /**
+ * @constructor
+ * @param {!WebInspector.CodeMirrorTextEditor} textEditor
+ * @param {!CodeMirror} codeMirror
+ */
+WebInspector.CodeMirrorTextEditor.SelectNextOccurenceController = function(textEditor, codeMirror)
+{
+    this._textEditor = textEditor;
+    this._codeMirror = codeMirror;
+}
+
+WebInspector.CodeMirrorTextEditor.SelectNextOccurenceController.prototype = {
+    selectionWillChange: function()
+    {
+        if (!this._muteSelectionListener)
+            delete this._fullWordSelection;
+    },
+
+    /**
+     * @param {!Array.<!WebInspector.TextRange>} selections
+     * @param {!WebInspector.TextRange} range
+     * @return {boolean}
+     */
+    _findRange: function(selections, range)
+    {
+        for (var i = 0; i < selections.length; ++i) {
+            if (range.equal(selections[i]))
+                return true;
+        }
+        return false;
+    },
+
+    selectNextOccurence: function()
+    {
+        var selections = this._textEditor.selections();
+        var anyEmptySelection = false;
+        for (var i = 0; i < selections.length; ++i) {
+            var selection = selections[i];
+            anyEmptySelection = anyEmptySelection || selection.isEmpty();
+            if (selection.startLine !== selection.endLine)
+                return;
+        }
+        if (anyEmptySelection) {
+            this._expandSelectionsToWords(selections);
+            return;
+        }
+
+        var last = selections[selections.length - 1];
+        var next = last;
+        do {
+            next = this._findNextOccurence(next, !!this._fullWordSelection);
+        } while (next && this._findRange(selections, next) && !next.equal(last));
+
+        if (!next)
+            return;
+        selections.push(next);
+
+        this._muteSelectionListener = true;
+        this._textEditor.setSelections(selections);
+        delete this._muteSelectionListener;
+
+        this._textEditor._revealLine(next.startLine);
+    },
+
+    /**
+     * @param {!Array.<!WebInspector.TextRange>} selections
+     */
+    _expandSelectionsToWords: function(selections)
+    {
+        var newSelections = [];
+        for (var i = 0; i < selections.length; ++i) {
+            var selection = selections[i];
+            var startRangeWord = this._textEditor._wordRangeForCursorPosition(selection.startLine, selection.startColumn)
+                || WebInspector.TextRange.createFromLocation(selection.startLine, selection.startColumn);
+            var endRangeWord = this._textEditor._wordRangeForCursorPosition(selection.endLine, selection.endColumn)
+                || WebInspector.TextRange.createFromLocation(selection.endLine, selection.endColumn);
+            var newSelection = new WebInspector.TextRange(startRangeWord.startLine, startRangeWord.startColumn, endRangeWord.endLine, endRangeWord.endColumn);
+            newSelections.push(newSelection);
+        }
+        this._textEditor.setSelections(newSelections);
+        this._fullWordSelection = true;
+    },
+
+    /**
+     * @param {!WebInspector.TextRange} range
+     * @param {boolean} fullWord
+     * @return {?WebInspector.TextRange}
+     */
+    _findNextOccurence: function(range, fullWord)
+    {
+        range = range.normalize();
+        var matchedLineNumber;
+        var matchedColumnNumber;
+        var textToFind = this._textEditor.copyRange(range);
+        function findWordInLine(wordRegex, lineNumber, lineText, from, to)
+        {
+            if (typeof matchedLineNumber === "number")
+                return true;
+            wordRegex.lastIndex = from;
+            var result = wordRegex.exec(lineText);
+            if (!result || result.index + textToFind.length > to)
+                return false;
+            matchedLineNumber = lineNumber;
+            matchedColumnNumber = result.index;
+            return true;
+        }
+
+        var iteratedLineNumber;
+        function lineIterator(regex, lineHandle)
+        {
+            if (findWordInLine(regex, iteratedLineNumber++, lineHandle.text, 0, lineHandle.text.length))
+                return true;
+        }
+
+        var regexSource = textToFind.escapeForRegExp();
+        if (fullWord)
+            regexSource = "\\b" + regexSource + "\\b";
+        var wordRegex = new RegExp(regexSource, "gi");
+        var currentLineText = this._codeMirror.getLine(range.startLine);
+
+        findWordInLine(wordRegex, range.startLine, currentLineText, range.endColumn, currentLineText.length);
+        iteratedLineNumber = range.startLine + 1;
+        this._codeMirror.eachLine(range.startLine + 1, this._codeMirror.lineCount(), lineIterator.bind(null, wordRegex));
+        iteratedLineNumber = 0;
+        this._codeMirror.eachLine(0, range.startLine, lineIterator.bind(null, wordRegex));
+        findWordInLine(wordRegex, range.startLine, currentLineText, 0, range.startColumn);
+
+        if (typeof matchedLineNumber !== "number")
+            return null;
+        return new WebInspector.TextRange(matchedLineNumber, matchedColumnNumber, matchedLineNumber, matchedColumnNumber + textToFind.length);
+    }
+}
+
+/**
  * @param {string} modeName
  * @param {string} tokenPrefix
  */
 WebInspector.CodeMirrorTextEditor._overrideModeWithPrefixedTokens = function(modeName, tokenPrefix)
 {
     var oldModeName = modeName + "-old";
     if (CodeMirror.modes[oldModeName])
         return;
 
     CodeMirror.defineMode(oldModeName, CodeMirror.modes[modeName]);
@@ skipping 27 matching lines @@
     var backgroundColorRule = backgroundColor ? ".CodeMirror .CodeMirror-selected { background-color: " + backgroundColor + ";}" : "";
     var foregroundColor = InspectorFrontendHost.getSelectionForegroundColor();
     var foregroundColorRule = foregroundColor ? ".CodeMirror .CodeMirror-selectedtext:not(.CodeMirror-persist-highlight) { color: " + foregroundColor + "!important;}" : "";
     if (!foregroundColorRule && !backgroundColorRule)
         return;
 
     var style = document.createElement("style");
     style.textContent = backgroundColorRule + foregroundColorRule;
     document.head.appendChild(style);
 })();