Add a PathFilter to each context in analysis_server

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 'dart:core' hide Resource;
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/source/optimizing_pub_package_map_provider.dart';
 import 'package:analysis_server/uri/resolver_provider.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
+import 'package:analyzer/source/path_filter.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
@@ skipping 129 matching lines @@
     return contexts;
   }
 
   /**
    * We have finished computing the package map.
    */
   void endComputePackageMap() {
     // Do nothing.
   }
 
+  // Sets the [ignorePatterns] for the context [folder].
+  void setIgnorePatternsForContext(Folder folder, List<String> ignorePatterns) {
+    _ContextInfo info = _contexts[folder];
+    if (info == null) {
+      return;
+    }
+    var pathFilter = info.pathFilter;
+    pathFilter.setIgnorePatterns(ignorePatterns);
+  }
+
   @override
   bool isInAnalysisRoot(String path) {
     // 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;
@@ skipping 135 matching lines @@
     List<Resource> children;
     try {
       children = folder.getChildren();
     } on FileSystemException {
       // The folder no longer exists, or cannot be read, to there's nothing to
       // do.
       return;
     }
     for (Resource child in children) {
       String path = child.path;
+      // Path is being ignored.
+      if (info.ignored(path)) {
+        continue;
+      }
       // add files, recurse into folders
       if (child is File) {
         // ignore if should not be analyzed at all
         if (!shouldFileBeAnalyzed(child)) {
           continue;
         }
         // ignore if was not excluded
         bool wasExcluded = _isExcludedBy(oldExcludedPaths, path) &&
             !_isExcludedBy(excludedPaths, path);
         if (!wasExcluded) {
@@ skipping 23 matching lines @@
     try {
       children = folder.getChildren();
     } on FileSystemException {
       // The directory either doesn't exist or cannot be read. Either way, there
       // are no children that need to be added.
       return;
     }
     for (Resource child in children) {
       String path = child.path;
       // ignore excluded files or folders
-      if (_isExcluded(path) || info.excludes(path)) {
+      if (_isExcluded(path) || info.excludes(path) || info.ignored(path)) {
         continue;
       }
       // add files, recurse into folders
       if (child is File) {
         if (shouldFileBeAnalyzed(child)) {
           Source source = createSourceInContext(info.context, child);
           changeSet.addedSource(source);
           info.sources[path] = source;
         }
       } else if (child is Folder) {
@@ skipping 224 matching lines @@
         folder.path, event.path, event.type.toString());
     String path = event.path;
     // maybe excluded globally
     if (_isExcluded(path)) {
       return;
     }
     // maybe excluded from the context, so other context will handle it
     if (info.excludes(path)) {
       return;
     }
+    if (info.ignored(path)) {
+      return;
+    }
     // handle the change
     switch (event.type) {
       case ChangeType.ADD:
         if (_isInPackagesDir(path, folder)) {
           return;
         }
         Resource resource = resourceProvider.getResource(path);
         // pubspec was added in a sub-folder, extract a new context
         if (_isPubspec(path) && info.isRoot && !info.isPubspec(path)) {
           _extractContext(info, resource);
@@ skipping 233 matching lines @@
 
 /**
  * Information tracked by the [ContextManager] for each context.
  */
 class _ContextInfo {
   /**
    * The [Folder] for which this information object is created.
    */
   final Folder folder;
 
+  /// The [PathFilter] used to filter sources from being analyzed.
+  final PathFilter pathFilter;
+
   /**
    * The enclosed pubspec-based contexts.
    */
   final List<_ContextInfo> children;
 
   /**
    * The package root for this context, or null if there is no package root.
    */
   String packageRoot;
 
@@ skipping 31 matching lines @@
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   /**
    * Info returned by the last call to
    * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
    * package map hasn't been computed for this context yet.
    */
   OptimizingPubPackageMapInfo packageMapInfo;
 
-  _ContextInfo(this.folder, File pubspecFile, this.children, this.packageRoot) {
+  _ContextInfo(Folder folder, File pubspecFile, this.children, this.packageRoot)
+      : folder = folder,
+        pathFilter = new PathFilter(folder.path, null) {
     pubspecPath = pubspecFile.path;
     for (_ContextInfo child in children) {
       child.parent = this;
     }
   }
 
   /**
    * Returns `true` if this context is root folder based.
    */
   bool get isRoot => parent == null;
 
   /**
    * Returns `true` if [path] is excluded, as it is in one of the children.
    */
   bool excludes(String path) {
     return children.any((child) {
       return child.folder.contains(path);
     });
   }
 
+  /// Returns `true` if  [path] should be ignored.
+  bool ignored(String path) => pathFilter.ignored(path);
+
   /**
    * Returns `true` if [resource] is excluded, as it is in one of the children.
    */
   bool excludesResource(Resource resource) {
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }