Further improve isWithin() performance.

lib/src/context.dart

 // Copyright (c) 2013, 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 path.context;
 
 import 'characters.dart' as chars;
 import 'internal_style.dart';
 import 'style.dart';
 import 'parsed_path.dart';
@@ skipping 598 matching lines @@
 
       // Ignore multiple separators in a row.
       if (parentIsSeparator && style.isSeparator(lastCodeUnit)) {
         parentIndex++;
         continue;
       } else if (childIsSeparator && style.isSeparator(lastCodeUnit)) {
         childIndex++;
         continue;
       }
 
-      // If a dot comes after a separator or another dot, it may be a
-      // directory traversal operator. Otherwise, it's just a normal
-      // non-matching character.
-      //
-      //     isWithin("foo/./bar", "foo/bar/baz") //=> true
-      //     isWithin("foo/bar/../baz", "foo/bar/.foo") //=> false
-      //
-      // We could stay on the fast path for "/./", but that adds a lot of
-      // complexity and isn't likely to come up much in practice.
-      if ((parentCodeUnit == chars.PERIOD || childCodeUnit == chars.PERIOD) &&
-          (style.isSeparator(lastCodeUnit) || lastCodeUnit == chars.PERIOD)) {
-        return null;
+      if (parentCodeUnit == chars.PERIOD) {
+        // If a dot comes after a separator, it may be a directory traversal
+        // operator. To check that, we need to know if it's followed by either
+        // "/" or "./". Otherwise, it's just a normal non-matching character.
+        //
+        //     isWithin("foo/./bar", "foo/bar/baz") //=> true
+        //     isWithin("foo/bar/../baz", "foo/bar/.foo") //=> false
+        if (style.isSeparator(lastCodeUnit)) {
+          parentIndex++;
+
+          // We've hit "/." at the end of the parent path, which we can ignore,
+          // since the paths were equivalent up to this point.
+          if (parentIndex == parent.length) break;
+          parentCodeUnit = parentCodeUnits[parentIndex];
+
+          // We've hit "/./", which we can ignore.
+          if (style.isSeparator(parentCodeUnit)) {
+            parentIndex++;
+            continue;
+          }
+
+          // We've hit "/..", which may be a directory traversal operator that
+          // we can't handle on the fast track.
+          if (parentCodeUnit == chars.PERIOD) {
+            parentIndex++;
+            if (parentIndex == parent.length ||
+                style.isSeparator(parentCodeUnits[parentIndex])) {
+              return null;
+            }
+          }
+        }
+
+        // If this isn't a directory traversal, fall through so we hit the
+        // normal handling for mismatched paths.
+      }
+
+      // This is the same logic as above, but for the child path instead of the
+      // parent.
+      if (childCodeUnit == chars.PERIOD) {
+        if (style.isSeparator(lastCodeUnit)) {
+          childIndex++;
+          if (childIndex == child.length) break;
+          childCodeUnit = childCodeUnits[childIndex];
+
+          if (style.isSeparator(childCodeUnit)) {
+            childIndex++;
+            continue;
+          }
+
+          if (childCodeUnit == chars.PERIOD) {
+            childIndex++;
+            if (childIndex == child.length ||
+                style.isSeparator(childCodeUnits[childIndex])) {
+              return null;
+            }
+          }
+        }
       }
 
       // If we're here, we've hit two non-matching, non-significant characters.
       // As long as the remainders of the two paths don't have any unresolved
       // ".." components, we can be confident that [child] is not within
       // [parent].
       var childDirection = _pathDirection(childCodeUnits, childIndex);
       if (childDirection != _PathDirection.belowRoot) return null;
       var parentDirection = _pathDirection(parentCodeUnits, parentIndex);
       if (parentDirection != _PathDirection.belowRoot) return null;
@@ skipping 259 matching lines @@
 
   /// The path never reaches to or above its original root.
   static const belowRoot = const _PathDirection("below root");
 
   final String name;
 
   const _PathDirection(this.name);
 
   String toString() => name;
 }