Support for excluded files/folders.

pkg/analysis_server/lib/src/context_manager.dart

 // Copyright (c) 2014, 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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/package_map_provider.dart';
@@ skipping 25 matching lines @@
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The context used to work with file system paths.
    */
   pathos.Context pathContext;
 
   /**
+   * A list of excluded paths - folders and files.
+   */
+  List<String> excludedPaths = <String>[];
+
+  /**
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final PackageMapProvider packageMapProvider;
 
   ContextManager(this.resourceProvider, this.packageMapProvider) {
     pathContext = resourceProvider.pathContext;
   }
 
   /**
    * Called when a new context needs to be created.
    */
   void addContext(Folder folder, Map<String, List<Folder>> packageMap);
 
   /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * Returns `true` if the given absolute [path] is in one of the current
    * root folders and is not excluded.
    */
   bool isInAnalysisRoot(String path) {
-    // TODO(scheglov) check for excluded paths
+    // check if excluded
+    if (_isExcluded(path)) {
+      return false;
+    }
+    // check if in of the roots
     for (Folder root in _contexts.keys) {
       if (root.contains(path)) {
         return true;
       }
     }
+    // no
     return false;
   }
 
   /**
    * Remove the context associated with the given [folder].
    */
   void removeContext(Folder folder);
 
   /**
    * Change the set of paths which should be used as starting points to
    * determine the context directories.
    */
   void setRoots(List<String> includedPaths, List<String> excludedPaths) {
     List<Folder> contextFolders = _contexts.keys.toList();
     // included
     Set<Folder> includedFolders = new HashSet<Folder>();
     for (int i = 0; i < includedPaths.length; i++) {
       String path = includedPaths[i];
       Resource resource = resourceProvider.getResource(path);
       if (resource is Folder) {
         includedFolders.add(resource);
       } else {
         // TODO(scheglov) implemented separate files analysis
         throw new UnimplementedError(
             '$path is not a folder. '
                 'Only support for folder analysis is implemented currently.');
       }
     }
     // excluded
-    // TODO(scheglov) remove when implemented
-    if (excludedPaths.isNotEmpty) {
-      throw new UnimplementedError('Excluded paths are not supported yet');
-    }
-    Set<Folder> excludedFolders = new HashSet<Folder>();
+    List<String> oldExcludedPaths = this.excludedPaths;
+    this.excludedPaths = excludedPaths;
     // destroy old contexts
     for (Folder contextFolder in contextFolders) {
       bool isIncluded = includedFolders.any((folder) {
-        return folder.contains(contextFolder.path);
+        return folder.isOrContains(contextFolder.path);
       });
       if (!isIncluded) {
         _destroyContext(contextFolder);
       }
     }
     // create new contexts
     for (Folder includedFolder in includedFolders) {
       bool wasIncluded = contextFolders.any((folder) {
-        return folder.contains(includedFolder.path);
+        return folder.isOrContains(includedFolder.path);
       });
       if (!wasIncluded) {
         _createContexts(includedFolder, false);
       }
     }
+    // remove newly excluded sources
+    _contexts.forEach((folder, info) {
+      // prepare excluded sources
+      Map<String, Source> excludedSources = new HashMap<String, Source>();
+      info.sources.forEach((String path, Source source) {
+        if (_isExcludedBy(excludedPaths, path) &&
+            !_isExcludedBy(oldExcludedPaths, path)) {
+          excludedSources[path] = source;
+        }
+      });
+      // apply exclusion
+      ChangeSet changeSet = new ChangeSet();
+      excludedSources.forEach((String path, Source source) {
+        info.sources.remove(path);
+        changeSet.removedSource(source);
+      });
+      applyChangesToContext(folder, changeSet);
+    });
+    // add previously excluded sources
+    _contexts.forEach((folder, info) {
+      ChangeSet changeSet = new ChangeSet();

[Brian Wilkerson, 2014/08/08 19:19:35]

Can we merge this into the loop above so that each context gets updated once? (I
suppose it's not a big deal if we can't because we won't do any wasted analysis
between the two calls, but it still seems like it would be more efficient.)

+      _addPreviouslyExcludedSources(info, changeSet, folder, oldExcludedPaths);
+      applyChangesToContext(folder, changeSet);
+    });
   }
 
   /**
    * Called when the package map for a context has changed.
    */
   void updateContextPackageMap(Folder contextFolder, Map<String,
       List<Folder>> packageMap);
 
   /**
+   * Resursively adds all Dart and HTML files to the [changeSet].
+   */
+  void _addPreviouslyExcludedSources(_ContextInfo info, ChangeSet changeSet,
+      Folder folder, List<String> oldExcludedPaths) {
+    if (info.excludesResource(folder)) {
+      return;
+    }
+    List<Resource> children = folder.getChildren();
+    for (Resource child in children) {
+      String path = child.path;
+      // ignore if wasn't previously excluded
+      bool wasExcluded =
+          _isExcludedBy(oldExcludedPaths, path) &&
+          !_isExcludedBy(excludedPaths, path);
+      if (!wasExcluded) {
+        continue;
+      }
+      // add files, recurse into folders
+      if (child is File) {
+        if (_shouldFileBeAnalyzed(child)) {
+          Source source = child.createSource();
+          changeSet.addedSource(source);
+          info.sources[path] = source;
+        }
+      } else if (child is Folder) {
+        if (child.shortName == 'packages') {

[Brian Wilkerson, 2014/08/08 19:19:35]

The string 'packages' should be a constant.

This and other occurrences (such as line 227) should be extracted into a method
so that if the condition changes we only have to change it in one place.

+          // TODO(paulberry): perhaps we should only skip packages dirs if
+          // there is a pubspec.yaml?
+          continue;
+        }
+        _addPreviouslyExcludedSources(info, changeSet, child, oldExcludedPaths);
+      }
+    }
+  }
+
+  /**
+   * Resursively adds all Dart and HTML files to the [changeSet].
+   */
+  void _addSourceFiles(ChangeSet changeSet, Folder folder, _ContextInfo info) {
+    if (info.excludesResource(folder)) {
+      return;
+    }
+    List<Resource> children = folder.getChildren();
+    for (Resource child in children) {
+      String path = child.path;
+      // ignore excluded files or folders
+      if (_isExcluded(path)) {
+        continue;
+      }
+      // add files, recurse into folders
+      if (child is File) {
+        if (_shouldFileBeAnalyzed(child)) {
+          Source source = child.createSource();
+          changeSet.addedSource(source);
+          info.sources[path] = source;
+        }
+      } else if (child is Folder) {
+        if (child.shortName == 'packages') {
+          // TODO(paulberry): perhaps we should only skip packages dirs if
+          // there is a pubspec.yaml?
+          continue;
+        }
+        _addSourceFiles(changeSet, child, info);
+      }
+    }
+  }
+
+  /**
    * Create a new empty context associated with [folder].
    */
   _ContextInfo _createContext(Folder folder, List<_ContextInfo> children) {
     _ContextInfo info = new _ContextInfo(folder, children);
     _contexts[folder] = info;
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     PackageMapInfo packageMapInfo =
         packageMapProvider.computePackageMap(folder);
@@ skipping 94 matching lines @@
       extractedSources.forEach((path, source) {
         oldInfo.sources.remove(path);
         changeSet.removedSource(source);
       });
       applyChangesToContext(oldInfo.folder, changeSet);
     }
   }
 
   void _handleWatchEvent(Folder folder, _ContextInfo info, WatchEvent event) {
     String path = event.path;
-    // maybe excluded, so other context will handle it
+    // maybe excluded globally
+    if (_isExcluded(path)) {
+      return;
+    }
+    // maybe excluded from the context, so other context will handle it
     if (info.excludes(path)) {
       return;
     }
     // handle the change
     switch (event.type) {
       case ChangeType.ADD:
         if (_isInPackagesDir(path, folder)) {
           // TODO(paulberry): perhaps we should only skip packages dirs if
           // there is a pubspec.yaml?
           break;
@@ skipping 48 matching lines @@
       // while we're rerunning "pub list", since any analysis we complete while
       // "pub list" is in progress is just going to get thrown away anyhow.
       PackageMapInfo packageMapInfo =
           packageMapProvider.computePackageMap(folder);
       info.packageMapDependencies = packageMapInfo.dependencies;
       updateContextPackageMap(folder, packageMapInfo.packageMap);
     }
   }
 
   /**
+   * Returns `true` if the given [path] is excluded by [excludedPaths].
+   */
+  bool _isExcluded(String path) {
+    return _isExcludedBy(excludedPaths, path);
+  }
+
+  /**
+   * Returns `true` if the given [path] is excluded by [excludedPaths].
+   */
+  bool _isExcludedBy(List<String> excludedPaths, String path) {
+    return excludedPaths.any((excludedPath) {
+      if (pathContext.isWithin(excludedPath, path)) {
+        return true;
+      }
+      return path == excludedPath;
+    });
+  }
+
+  /**
    * Determine if the path from [folder] to [path] contains a 'packages'
    * directory.
    */
   bool _isInPackagesDir(String path, Folder folder) {
     String relativePath = pathContext.relative(path, from: folder.path);
     List<String> pathParts = pathContext.split(relativePath);
     for (int i = 0; i < pathParts.length - 1; i++) {
       if (pathParts[i] == 'packages') {
         return true;
       }
@@ skipping 20 matching lines @@
       parentInfo.children.remove(info);
       ChangeSet changeSet = new ChangeSet();
       info.sources.forEach((path, source) {
         parentInfo.sources[path] = source;
         changeSet.addedSource(source);
       });
       applyChangesToContext(parentInfo.folder, changeSet);
     }
   }
 
-  /**
-   * Resursively adds all Dart and HTML files to the [changeSet].
-   */
-  static void _addSourceFiles(ChangeSet changeSet, Folder folder,
-      _ContextInfo info) {
-    if (info.excludesResource(folder)) {
-      return;
-    }
-    List<Resource> children = folder.getChildren();
-    for (Resource child in children) {
-      if (child is File) {
-        if (_shouldFileBeAnalyzed(child)) {
-          Source source = child.createSource();
-          changeSet.addedSource(source);
-          info.sources[child.path] = source;
-        }
-      } else if (child is Folder) {
-        if (child.shortName == 'packages') {
-          // TODO(paulberry): perhaps we should only skip packages dirs if
-          // there is a pubspec.yaml?
-          continue;
-        }
-        _addSourceFiles(changeSet, child, info);
-      }
-    }
-  }
-
   static bool _shouldFileBeAnalyzed(File file) {
     if (!(AnalysisEngine.isDartFileName(file.path) ||
         AnalysisEngine.isHtmlFileName(file.path))) {
       return false;
     }
     // Emacs creates dummy links to track the fact that a file is open for
     // editing and has unsaved changes (e.g. having unsaved changes to
     // 'foo.dart' causes a link '.#foo.dart' to be created, which points to the
     // non-existent file 'username@hostname.pid'.  To avoid these dummy links
     // causing the analyzer to thrash, just ignore links to non-existent files.
@@ skipping 71 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }