DevTools: Support regex search and case sensitive search in sources panel

Source/devtools/front_end/source_frame/SourceFrame.js

 /*
  * Copyright (C) 2011 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 64 matching lines @@
     // First try creating regex if user knows the / / hint.
     try {
         if (/^\/.+\/$/.test(query)) {
             regex = new RegExp(query.substring(1, query.length - 1), modifiers);
             regex.__fromRegExpQuery = true;
         }
     } catch (e) {
         // Silent catch.
     }
 
-    // Otherwise just do case-insensitive search.
+    // Otherwise just do a plain text search.
     if (!regex)
-        regex = createPlainTextSearchRegex(query, "i" + modifiers);
+        regex = createPlainTextSearchRegex(query, modifiers);
 
     return regex;
 }
 
 WebInspector.SourceFrame.Events = {
     ScrollChanged: "ScrollChanged",
     SelectionChanged: "SelectionChanged",
     JumpHappened: "JumpHappened"
 }
 
@@ skipping 292 matching lines @@
     _setTextEditorDecorations: function()
     {
         this._rowMessageBuckets = {};
 
         this._textEditor.beginUpdates();
         this._addExistingMessagesToSource();
         this._textEditor.endUpdates();
     },
 
     /**
-     * @param {string} query
+     * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
      * @param {boolean} shouldJump
      * @param {boolean} jumpBackwards
      * @param {function(!WebInspector.View, number)} callback
      * @param {function(number)} currentMatchChangedCallback
      * @param {function()} searchResultsChangedCallback
      */
-    performSearch: function(query, shouldJump, jumpBackwards, callback, currentMatchChangedCallback, searchResultsChangedCallback)
+    performSearch: function(searchConfig, shouldJump, jumpBackwards, callback, currentMatchChangedCallback, searchResultsChangedCallback)
     {
         /**
-         * @param {string} query
          * @this {WebInspector.SourceFrame}
          */
-        function doFindSearchMatches(query)
+        function doFindSearchMatches()

[lushnikov, 2014/10/20 13:09:19]

In order to simplify reading, can we have this method extracted to the class
method?

         {
             this._currentSearchResultIndex = -1;
             this._searchResults = [];
 
-            var regex = WebInspector.SourceFrame.createSearchRegex(query);
+            var modifiers = searchConfig.caseSensitive ? "" : "i";
+            var query = searchConfig.isRegex ? "/" + searchConfig.query + "/" : searchConfig.query;
+            var regex = WebInspector.SourceFrame.createSearchRegex(query, modifiers);
             this._searchRegex = regex;
             this._searchResults = this._collectRegexMatches(regex);
             if (!this._searchResults.length)
                 this._textEditor.cancelSearchResultsHighlight();
             else if (shouldJump && jumpBackwards)
                 this.jumpToPreviousSearchResult();
             else if (shouldJump)
                 this.jumpToNextSearchResult();
             else
                 this._textEditor.highlightSearchResults(regex, null);
             callback(this, this._searchResults.length);
         }
 
         this._resetSearch();
         this._currentSearchMatchChangedCallback = currentMatchChangedCallback;
         this._searchResultsChangedCallback = searchResultsChangedCallback;
         if (this.loaded)
-            doFindSearchMatches.call(this, query);
+            doFindSearchMatches.call(this);
         else
-            this._delayedFindSearchMatches = doFindSearchMatches.bind(this, query);
+            this._delayedFindSearchMatches = doFindSearchMatches.bind(this);
 
         this._ensureContentLoaded();
     },
 
     _editorFocused: function()
     {
         this._resetCurrentSearchResultIndex();
     },
 
     _resetCurrentSearchResultIndex: function()
@@ skipping 91 matching lines @@
     {
         if (!this.loaded || !this._searchResults.length)
             return;
         this._currentSearchResultIndex = (index + this._searchResults.length) % this._searchResults.length;
         if (this._currentSearchMatchChangedCallback)
             this._currentSearchMatchChangedCallback(this._currentSearchResultIndex);
         this._textEditor.highlightSearchResults(this._searchRegex, this._searchResults[this._currentSearchResultIndex]);
     },
 
     /**
-     * @param {string} text
+     * @param {string} replacement
      */
-    replaceSelectionWith: function(text)
+    replaceSelectionWith: function(replacement)
     {
         var range = this._searchResults[this._currentSearchResultIndex];
         if (!range)
             return;
         this._textEditor.highlightSearchResults(this._searchRegex, null);
-        var newRange = this._textEditor.editRange(range, text);
+        var newRange = this._textEditor.editRange(range, replacement);
         this._textEditor.setSelection(newRange.collapseToEnd());
     },
 
     /**
-     * @param {string} query
+     * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
      * @param {string} replacement
      */
-    replaceAllWith: function(query, replacement)
+    replaceAllWith: function(searchConfig, replacement)
     {
         this._resetCurrentSearchResultIndex();
 
         var text = this._textEditor.text();
         var range = this._textEditor.range();
-        var regex = WebInspector.SourceFrame.createSearchRegex(query, "g");
+
+        var modifiers = searchConfig.caseSensitive ? "" : "i";
+        var query = searchConfig.isRegex ? "/" + searchConfig.query + "/" : searchConfig.query;
+        var regex = WebInspector.SourceFrame.createSearchRegex(query, "g" + modifiers);
         if (regex.__fromRegExpQuery)
             text = text.replace(regex, replacement);
         else
             text = text.replace(regex, function() { return replacement; });
 
         var ranges = this._collectRegexMatches(regex);
         if (!ranges.length)
             return;
 
         // Calculate the position of the end of the last range to be edited.
@@ skipping 14 matching lines @@
 
     _collectRegexMatches: function(regexObject)
     {
         var ranges = [];
         for (var i = 0; i < this._textEditor.linesCount; ++i) {
             var line = this._textEditor.line(i);
             var offset = 0;
             do {
                 var match = regexObject.exec(line);
                 if (match) {
+                    var matchEndIndex = match.index + Math.max(match[0].length, 1);
                     if (match[0].length)
-                        ranges.push(new WebInspector.TextRange(i, offset + match.index, i, offset + match.index + match[0].length));
-                    offset += match.index + 1;
-                    line = line.substring(match.index + 1);
+                        ranges.push(new WebInspector.TextRange(i, offset + match.index, i, offset + matchEndIndex));
+                    offset += matchEndIndex;
+                    line = line.substring(matchEndIndex);
                 }
             } while (match && line);
         }
         return ranges;
     },
 
     _addExistingMessagesToSource: function()
     {
         var length = this._messages.length;
         for (var i = 0; i < length; ++i)
@@ skipping 385 matching lines @@
 
     /**
      * @param {?WebInspector.TextRange} from
      * @param {?WebInspector.TextRange} to
      */
     onJumpToPosition: function(from, to)
     {
         this._sourceFrame.onJumpToPosition(from, to);
     }
 }