Make analysis_server use ignore patterns from .analysis_options file

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/analysis_options_provider.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';
+import 'package:yaml/yaml.dart';
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class AbstractContextManager implements ContextManager {
   /**
    * The name of the `lib` directory.
    */
   static const String LIB_DIR_NAME = 'lib';
@@ skipping 53 matching lines @@
    * to the standard URI resolver.
    */
   final ResolverProvider packageResolverProvider;
 
   /**
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final OptimizingPubPackageMapProvider _packageMapProvider;
 
+  /// Provider of analysis options.
+  AnalysisOptionsProvider analysisOptionsProvider =
+      new AnalysisOptionsProvider();
+
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
-  AbstractContextManager(this.resourceProvider, this.packageResolverProvider,
+  AbstractContextManager(this.resourceProvider,this.packageResolverProvider,
       this._packageMapProvider, this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
   }
 
   /**
    * Create and return a new analysis context.
    */
   AnalysisContext addContext(Folder folder, UriResolver packageUriResolver);
 
   /**
@@ skipping 44 matching lines @@
     return contexts;
   }
 
   /**
    * We have finished computing the package map.
    */
   void endComputePackageMap() {
     // Do nothing.
   }
 
-  // Sets the [ignorePatterns] for the context [folder].
+  /// 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);
   }
 
+  /// Process [options] for the context [folder].
+  void processOptionsForContext(Folder folder, Map<String, YamlNode> options) {
+    _ContextInfo info = _contexts[folder];
+    if (info == null) {
+      return;
+    }
+    YamlMap analyzer = options['analyzer'];
+    if (analyzer == null) {
+      // No options for analyzer.
+      return;
+    }
+
+    // Set ignore patterns.
+    YamlList ignore = analyzer['ignore'];

[Brian Wilkerson, 2015/07/17 21:03:22]

"ignore" --> "exclude"

[Cutch, 2015/07/17 21:09:40]

Done.

+    if (ignore != null) {
+      setIgnorePatternsForContext(folder, ignore);
+    }
+  }
+
   @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 296 matching lines @@
   }
 
   /**
    * Create a new empty context associated with [folder].
    */
   _ContextInfo _createContext(
       Folder folder, File pubspecFile, List<_ContextInfo> children) {
     _ContextInfo info = new _ContextInfo(
         folder, pubspecFile, children, normalizedPackageRoots[folder.path]);
     _contexts[folder] = info;
+    try {
+      var options = analysisOptionsProvider.getOptions(folder);
+      processOptionsForContext(folder, options);
+    } catch (_) {
+      rethrow;

[Brian Wilkerson, 2015/07/17 21:03:22]

Is there a reason to catch the exception if we're just rethrowing it?

[Cutch, 2015/07/17 21:09:41]

The analyzer tells me I need to have a catch or finally block after a try block.

[Brian Wilkerson, 2015/07/17 21:11:53]

Ok. I'll re-phrase. Why do you want a try block here?

[Cutch, 2015/07/17 21:13:16]

Sorry, I was being dense. I now understand your original question. I've landed
this already though....

[Brian Wilkerson, 2015/07/17 21:14:25]

No problem. A follow-up CL will work.

+    }
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     try {
       UriResolver packageUriResolver = _computePackageUriResolver(folder, info);
       info.context = addContext(folder, packageUriResolver);
       info.context.name = folder.path;
     } catch (_) {
       info.changeSubscription.cancel();
       rethrow;
@@ skipping 461 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }