third_party/WebKit/Source/devtools/front_end/workspace/SearchConfig.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @constructor
   7  * @implements {WebInspector.ProjectSearchConfig}
   8  * @param {string} query
   9  * @param {boolean} ignoreCase
  10  * @param {boolean} isRegex
  11  */
  12 WebInspector.SearchConfig = function(query, ignoreCase, isRegex)
  13 {
  14     this._query = query;
  15     this._ignoreCase = ignoreCase;
  16     this._isRegex = isRegex;
  17     this._parse();
  18 }
  19
  20 /** @typedef {!{regex: !RegExp, isNegative: boolean}} */
  21 WebInspector.SearchConfig.RegexQuery;
  22
  23 /**
  24  * @param {{query: string, ignoreCase: boolean, isRegex: boolean}} object
  25  * @return {!WebInspector.SearchConfig}
  26  */
  27 WebInspector.SearchConfig.fromPlainObject = function(object)
  28 {
  29     return new WebInspector.SearchConfig(object.query, object.ignoreCase, object.isRegex);
  30 }
  31
  32 WebInspector.SearchConfig.prototype = {
  33     /**
  34      * @override
  35      * @return {string}
  36      */
  37     query: function()
  38     {
  39         return this._query;
  40     },
  41
  42     /**
  43      * @override
  44      * @return {boolean}
  45      */
  46     ignoreCase: function()
  47     {
  48         return this._ignoreCase;
  49     },
  50
  51     /**
  52      * @override
  53      * @return {boolean}
  54      */
  55     isRegex: function()
  56     {
  57         return this._isRegex;
  58     },
  59
  60     /**
  61      * @return {{query: string, ignoreCase: boolean, isRegex: boolean}}
  62      */
  63     toPlainObject: function()
  64     {
  65         return { query: this.query(), ignoreCase: this.ignoreCase(), isRegex: this.isRegex() };
  66     },
  67
  68     _parse: function()
  69     {
  70         var filePattern = "-?f(ile)?:(([^\\\\ ]|\\\\.)+)"; // After file: prefix: any symbol except space and backslash or any symbol escaped with a backslash.
  71         var quotedPattern = "\"(([^\\\\\"]|\\\\.)+)\""; // Inside double quotes: any symbol except double quote and backslash or any symbol escaped with a backslash.
  72
  73         // A word is a sequence of any symbols except space and backslash or any symbols escaped with a backslash, that does not start with file:.
  74         var unquotedWordPattern = "((?!-?f(ile)?:)[^\\\\ ]|\\\\.)+";
  75         var unquotedPattern = unquotedWordPattern + "( +" + unquotedWordPattern + ")*"; // A word or several words separated by space(s).
  76
  77         var pattern = "(" + filePattern + ")|(" + quotedPattern + ")|(" + unquotedPattern + ")";
  78         var regexp = new RegExp(pattern, "g");
  79         var queryParts = this._query.match(regexp) || [];
  80
  81         /**
  82          * @type {!Array.<!WebInspector.SearchConfig.QueryTerm>}
  83          */
  84         this._fileQueries = [];
  85
  86         /**
  87          * @type {!Array.<string>}
  88          */
  89         this._queries = [];
  90
  91         for (var i = 0; i < queryParts.length; ++i) {
  92             var queryPart = queryParts[i];
  93             if (!queryPart)
  94                 continue;
  95             var fileQuery = this._parseFileQuery(queryPart);
  96             if (fileQuery) {
  97                 this._fileQueries.push(fileQuery);
  98                 /** @type {!Array.<!WebInspector.SearchConfig.RegexQuery>} */
  99                 this._fileRegexQueries = this._fileRegexQueries || [];
 100                 this._fileRegexQueries.push({ regex: new RegExp(fileQuery.text, this.ignoreCase ? "i" : ""), isNegative: fileQuery.isNegative });
 101                 continue;
 102             }
 103             if (queryPart.startsWith("\"")) {
 104                 if (!queryPart.endsWith("\""))
 105                     continue;
 106                 this._queries.push(this._parseQuotedQuery(queryPart));
 107                 continue;
 108             }
 109             this._queries.push(this._parseUnquotedQuery(queryPart));
 110         }
 111     },
 112
 113     /**
 114      * @override
 115      * @param {string} filePath
 116      * @return {boolean}
 117      */
 118     filePathMatchesFileQuery: function(filePath)
 119     {
 120         if (!this._fileRegexQueries)
 121             return true;
 122         for (var i = 0; i < this._fileRegexQueries.length; ++i) {
 123             if (!!filePath.match(this._fileRegexQueries[i].regex) === this._fileRegexQueries[i].isNegative)
 124                 return false;
 125         }
 126         return true;
 127     },
 128
 129     /**
 130      * @override
 131      * @return {!Array.<string>}
 132      */
 133     queries: function()
 134     {
 135         return this._queries;
 136     },
 137
 138     _parseUnquotedQuery: function(query)
 139     {
 140         return query.replace(/\\(.)/g, "$1");
 141     },
 142
 143     _parseQuotedQuery: function(query)
 144     {
 145         return query.substring(1, query.length - 1).replace(/\\(.)/g, "$1");
 146     },
 147
 148     /**
 149      * @param {string} query
 150      * @return {?WebInspector.SearchConfig.QueryTerm}
 151      */
 152     _parseFileQuery: function(query)
 153     {
 154         var match = query.match(/^(-)?f(ile)?:/);
 155         if (!match)
 156             return null;
 157         var isNegative = !!match[1];
 158         query = query.substr(match[0].length);
 159         var result = "";
 160         for (var i = 0; i < query.length; ++i) {
 161             var char = query[i];
 162             if (char === "*") {
 163                 result += ".*";
 164             } else if (char === "\\") {
 165                 ++i;
 166                 var nextChar = query[i];
 167                 if (nextChar === " ")
 168                     result += " ";
 169             } else {
 170                 if (String.regexSpecialCharacters().indexOf(query.charAt(i)) !== -1)
 171                     result += "\\";
 172                 result += query.charAt(i);
 173             }
 174         }
 175         return new WebInspector.SearchConfig.QueryTerm(result, isNegative);
 176     }
 177 }
 178
 179 /**
 180  * @constructor
 181  * @param {string} text
 182  * @param {boolean} isNegative
 183  */
 184 WebInspector.SearchConfig.QueryTerm = function(text, isNegative)
 185 {
 186     this.text = text;
 187     this.isNegative = isNegative;
 188 }