Specialize Glob for the often case of suffix matching.

pkg/analyzer/lib/src/util/glob.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.util.glob;
 
 /**
  * A pattern that matches against filesystem path-like strings with wildcards.
  *
  * The pattern matches strings as follows:
@@ skipping 10 matching lines @@
    * as defined here: http://ecma-international.org/ecma-262/5.1/#sec-15.10
    */
   static final RegExp _specialChars =
       new RegExp(r'([\\\^\$\.\|\+\[\]\(\)\{\}])');
 
   /**
    * The path separator used to separate components in file paths.
    */
   final String _separator;
 
-  final String pattern;
-  final RegExp _regex;
+  /**
+   * The pattern string.
+   */
+  final String _pattern;
 
-  Glob(this._separator, String pattern)
-      : pattern = pattern,
-        _regex = _regexpFromGlobPattern(pattern);
+  String _suffix;
+  RegExp _regex;
+
+  Glob(this._separator, this._pattern) {
+    if (_hasJustPrefix(_pattern, '**/*')) {
+      _suffix = _pattern.substring(4);

[Brian Wilkerson, 2015/11/17 14:54:07]

Probably ought to use toLowerCase() for later matching.

+    } else if (_hasJustPrefix(_pattern, '**')) {
+      _suffix = _pattern.substring(2);
+    } else {
+      _regex = _regexpFromGlobPattern(_pattern);
+    }
+  }
 
   @override
-  int get hashCode => pattern.hashCode;
+  int get hashCode => _pattern.hashCode;
 
-  bool operator ==(other) => other is Glob && pattern == other.pattern;
+  bool operator ==(other) => other is Glob && _pattern == other._pattern;
 
   /**
    * Return `true` if the given [path] matches this glob.
    * The given [path] must use the same [_separator] as the glob.
    */
   bool matches(String path) {
     String posixPath = _toPosixPath(path);
+    if (_suffix != null) {
+      return posixPath.toLowerCase().endsWith(_suffix);
+    }
     return _regex.matchAsPrefix(posixPath) != null;
   }
 
   @override
-  String toString() => pattern;
+  String toString() => _pattern;
 
   /**
    * Return the Posix version of the given [path].
    */
   String _toPosixPath(String path) {
     if (_separator == '/') {
       return path;
     }
     return path.replaceAll(_separator, '/');
   }
 
+  /**
+   * Return `true` if the [pattern] start with the given [prefix] and does
+   * not have `*` or `?` characters.
+   */
+  static bool _hasJustPrefix(String pattern, String prefix) {
+    if (pattern.startsWith(prefix)) {
+      int prefixLength = prefix.length;
+      return pattern.indexOf('*', prefixLength) == -1 &&
+          pattern.indexOf('?', prefixLength) == -1;
+    }
+    return false;
+  }
+
   static RegExp _regexpFromGlobPattern(String pattern) {
     StringBuffer sb = new StringBuffer();
     sb.write('^');
     List<String> chars = pattern.split('');
     for (int i = 0; i < chars.length; i++) {
       String c = chars[i];
       if (_specialChars.hasMatch(c)) {
         sb.write(r'\');
         sb.write(c);
       } else if (c == '*') {
         if (i + 1 < chars.length && chars[i + 1] == '*') {
           sb.write('.*');
           i++;
         } else {
           sb.write('[^/]*');
         }
       } else if (c == '?') {
         sb.write('[^/]');
       } else {
         sb.write(c);
       }
     }
     sb.write(r'$');
     return new RegExp(sb.toString(), caseSensitive: false);
   }
 }