Move shouldFileBeAnalyzed into ContextManager

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:convert';
 import 'dart:core' hide Resource;
@@ skipping 13 matching lines @@
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_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:analyzer/src/task/options.dart';
 import 'package:analyzer/src/util/absolute_path.dart';
+import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer/src/util/yaml.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 import 'package:yaml/yaml.dart';
 
 /**
  * Information tracked by the [ContextManager] for each context.
@@ skipping 285 matching lines @@
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * Remove the context associated with the given [folder].  [flushedFiles] is
    * a list of the files which will be "orphaned" by removing this context
    * (they will no longer be analyzed by any context).
    */
   void removeContext(Folder folder, List<String> flushedFiles);
 
   /**
-   * Return `true` if the given [file] should be analyzed.
-   */
-  bool shouldFileBeAnalyzed(File file);
-
-  /**
    * Called when the disposition for a context has changed.
    */
   void updateContextPackageUriResolver(
       Folder contextFolder, FolderDisposition disposition);
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
@@ skipping 81 matching lines @@
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final PubPackageMapProvider _packageMapProvider;
 
   /// Provider of analysis options.
   AnalysisOptionsProvider analysisOptionsProvider =
       new AnalysisOptionsProvider();
 
   /**
+   * A list of the globs used to determine which files should be analyzed.
+   */
+  final List<Glob> analyzedFilesGlobs;
+
+  /**
+   * The default options used to create new analysis contexts.
+   */
+  final AnalysisOptionsImpl defaultContextOptions;
+
+  /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
-  /**
-   * The default options used to create new analysis contexts.
-   */
-  final AnalysisOptionsImpl defaultContextOptions;
-
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
   final ContextInfo rootInfo = new ContextInfo._root();
 
   /**
    * The controller that is notified when we are starting or ending the
    * computation of a package map.
    */
   StreamController<bool> _onComputingPackageMapController;
 
   /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(
       this.resourceProvider,
       this.packageResolverProvider,
       this.embeddedUriResolverProvider,
       this._packageMapProvider,
+      this.analyzedFilesGlobs,
       this._instrumentationService,
       this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
     _onComputingPackageMapController = new StreamController.broadcast();
   }
 
   @override
   Stream<bool> get onComputingPackageMap {
     return _onComputingPackageMapController.stream;
@@ skipping 289 matching lines @@
     }
     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 (!callbacks.shouldFileBeAnalyzed(child)) {
+        if (!_shouldFileBeAnalyzed(child)) {
           continue;
         }
         // ignore if was not excluded
         bool wasExcluded = _isExcludedBy(oldExcludedPaths, path) &&
             !_isExcludedBy(excludedPaths, path);
         if (!wasExcluded) {
           continue;
         }
         // do add the file
         Source source = createSourceInContext(info.context, child);
@@ skipping 26 matching lines @@
       return;
     }
     for (Resource child in children) {
       String path = child.path;
       // ignore excluded files or folders
       if (_isExcluded(path) || info.excludes(path) || info.ignored(path)) {
         continue;
       }
       // add files, recurse into folders
       if (child is File) {
-        if (callbacks.shouldFileBeAnalyzed(child)) {
+        if (_shouldFileBeAnalyzed(child)) {
           Source source = createSourceInContext(info.context, child);
           changeSet.addedSource(source);
           info.sources[path] = source;
         }
       } else if (child is Folder) {
         String shortName = child.shortName;
         if (shortName == PACKAGES_NAME) {
           continue;
         }
         _addSourceFiles(changeSet, child, info);
@@ skipping 453 matching lines @@
               }
             }
           }
         }
 
         // If the file went away and was replaced by a folder before we
         // had a chance to process the event, resource might be a Folder.  In
         // that case don't add it.
         if (resource is File) {
           File file = resource;
-          if (callbacks.shouldFileBeAnalyzed(file)) {
+          if (_shouldFileBeAnalyzed(file)) {
             ChangeSet changeSet = new ChangeSet();
             Source source = createSourceInContext(info.context, file);
             changeSet.addedSource(source);
             callbacks.applyChangesToContext(info.folder, changeSet);
             info.sources[path] = source;
           }
         }
         break;
       case ChangeType.REMOVE:
 
@@ skipping 163 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.
     List<String> dependencies = <String>[];
     FolderDisposition disposition = _computeFolderDisposition(
         info.folder, dependencies.add, _findPackageSpecFile(info.folder));
     info.setDependencies(dependencies);
     callbacks.updateContextPackageUriResolver(info.folder, disposition);
   }
 
   /**
+   * Return `true` if the given [file] should be analyzed.
+   */
+  bool _shouldFileBeAnalyzed(File file) {
+    for (Glob glob in analyzedFilesGlobs) {
+      if (glob.matches(file.path)) {
+        // 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.
+        return file.exists;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Create and return a source representing the given [file] within the given
    * [context].
    */
   static Source createSourceInContext(AnalysisContext context, File file) {
     // TODO(brianwilkerson) Optimize this, by allowing support for source
     // factories to restore URI's from a file path rather than a source.
     Source source = file.createSource();
     if (context == null) {
       return source;
     }
@@ skipping 174 matching lines @@
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }