Directory support for the analyzer CLI (#25129).

pkg/analyzer_cli/lib/src/driver.dart

 // Copyright (c) 2015, 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 analyzer_cli.src.driver;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 15 matching lines @@
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart'
     show PerformanceTag;
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer_cli/src/analyzer_impl.dart';
+import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:analyzer_cli/src/package_analyzer.dart';
 import 'package:analyzer_cli/src/perf_report.dart';
 import 'package:analyzer_cli/starter.dart';
 import 'package:linter/src/plugin/linter_plugin.dart';
 import 'package:package_config/discovery.dart' as pkgDiscovery;
 import 'package:package_config/packages.dart' show Packages;
 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 path;
@@ skipping 36 matching lines @@
   /// If [_context] is not `null`, the [CommandLineOptions] that guided its
   /// creation.
   CommandLineOptions _previousOptions;
 
   @override
   EmbeddedResolverProvider embeddedUriResolverProvider;
 
   @override
   ResolverProvider packageResolverProvider;
 
+  /// Collected analysis statistics.
+  final AnalysisStats stats = new AnalysisStats();
+
   /// This Driver's current analysis context.
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
   void set userDefinedPlugins(List<Plugin> plugins) {
-    _userDefinedPlugins = plugins == null ? <Plugin>[] : plugins;
+    _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   @override
   void start(List<String> args) {
     int startTime = new DateTime.now().millisecondsSinceEpoch;
 
     StringUtilities.INTERNER = new MappedInterner();
 
     _processPlugins();
 
@@ skipping 45 matching lines @@
     try {
       _createAnalysisContext(options);
     } on _DriverError catch (error) {
       outSink.writeln(error.msg);
       return ErrorSeverity.ERROR;
     }
 
     // Add all the files to be analyzed en masse to the context.  Skip any
     // files that were added earlier (whether explicitly or implicitly) to
     // avoid causing those files to be unnecessarily re-read.
-    Set<Source> knownSources = _context.sources.toSet();
+    Set<Source> knownSources = context.sources.toSet();
     List<Source> sourcesToAnalyze = <Source>[];
     ChangeSet changeSet = new ChangeSet();
     for (String sourcePath in options.sourceFiles) {
       sourcePath = sourcePath.trim();
-      // Check that file exists.
-      if (!new File(sourcePath).existsSync()) {
-        errorSink.writeln('File not found: $sourcePath');
+
+      // Collect files for analysis.
+      // Note that these files will all be analyzed in the same context.
+      // This should be updated when the ContextManager re-work is complete
+      // (See: https://github.com/dart-lang/sdk/issues/24133)
+      Iterable<File> files = _collectFiles(sourcePath);
+      if (files.isEmpty) {
+        errorSink.writeln('No dart files found at: $sourcePath');
         exitCode = ErrorSeverity.ERROR.ordinal;
-        //Fail fast; don't analyze more files
         return ErrorSeverity.ERROR;
       }
-      // Check that file is Dart file.
-      if (!AnalysisEngine.isDartFileName(sourcePath)) {
-        errorSink.writeln('$sourcePath is not a Dart file');
-        exitCode = ErrorSeverity.ERROR.ordinal;
-        // Fail fast; don't analyze more files.
-        return ErrorSeverity.ERROR;
+
+      for (File file in files) {
+        Source source = _computeLibrarySource(file.absolute.path);
+        if (!knownSources.contains(source)) {
+          changeSet.addedSource(source);
+          sourcesToAnalyze.add(source);
+        }
       }
-      Source source = _computeLibrarySource(sourcePath);
-      if (!knownSources.contains(source)) {
-        changeSet.addedSource(source);
-      }
-      sourcesToAnalyze.add(source);
     }
-    _context.applyChanges(changeSet);
+    context.applyChanges(changeSet);
 
     // Analyze the libraries.
     ErrorSeverity allResult = ErrorSeverity.NONE;
     var libUris = <Uri>[];
     var parts = <Source>[];
     for (Source source in sourcesToAnalyze) {
       if (context.computeKindOf(source) == SourceKind.PART) {
         parts.add(source);
         continue;
       }
@@ skipping 11 matching lines @@
         }
       }
       if (!found) {
         errorSink.writeln("${part.fullName} is a part and cannot be analyzed.");
         errorSink.writeln("Please pass in a library that contains this part.");
         exitCode = ErrorSeverity.ERROR.ordinal;
         allResult = allResult.max(ErrorSeverity.ERROR);
       }
     }
 
+    if (!options.machineFormat) {
+      stats.print(outSink);
+    }
+
     return allResult;
   }
 
   /// Perform package analysis according to the given [options].
   ErrorSeverity _analyzePackage(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
-      return new PackageAnalyzer(options).analyze();
+      return new PackageAnalyzer(options, stats).analyze();
     });
   }
 
   /// Determine whether the context created during a previous call to
   /// [_analyzeAll] can be re-used in order to analyze using [options].
   bool _canContextBeReused(CommandLineOptions options) {
     // TODO(paulberry): add a command-line option that disables context re-use.
     if (_context == null) {
       return false;
     }
@@ skipping 205 matching lines @@
     if (packageUriResolver != null) {
       resolvers.add(packageUriResolver);
     }
 
     // Finally files.
     resolvers.add(new FileUriResolver());
 
     return new SourceFactory(resolvers, packages);
   }
 
+  /// Collect all analyzable files at [filePath], recursively if it's a
+  /// directory, ignoring links.
+  Iterable<File> _collectFiles(String filePath) {
+    List<File> files = <File>[];
+    File file = new File(filePath);
+    if (file.existsSync()) {
+      files.add(file);
+    } else {
+      Directory directory = new Directory(filePath);
+      if (directory.existsSync()) {
+        for (FileSystemEntity entry
+            in directory.listSync(recursive: true, followLinks: false)) {
+          String relative = path.relative(entry.path, from: directory.path);
+          if (AnalysisEngine.isDartFileName(entry.path) &&
+              !_isInHiddenDir(relative)) {
+            files.add(entry);
+          }
+        }
+      }
+    }
+    return files;
+  }
+
   /// Convert the given [sourcePath] (which may be relative to the current
   /// working directory) to a [Source] object that can be fed to the analysis
   /// context.
   Source _computeLibrarySource(String sourcePath) {
     sourcePath = _normalizeSourcePath(sourcePath);
     JavaFile sourceFile = new JavaFile(sourcePath);
     Source source = sdk.fromFileUri(sourceFile.toURI());
     if (source != null) {
       return source;
     }
@@ skipping 54 matching lines @@
     Map<String, List<fileSystem.Folder>> folderMap =
         new Map<String, List<fileSystem.Folder>>();
     packages.asMap().forEach((String packagePath, Uri uri) {
       folderMap[packagePath] = [
         PhysicalResourceProvider.INSTANCE.getFolder(path.fromUri(uri))
       ];
     });
     return folderMap;
   }
 
+  /// Returns `true` if this relative path is a hidden directory.
+  bool _isInHiddenDir(String relative) =>
+      path.split(relative).any((part) => part.startsWith("."));

[Brian Wilkerson, 2016/03/16 20:42:52]

Does this need to worry about having ".." as a part? (The word "relative"
suggests that it might.)

[pquitslund, 2016/03/16 20:55:41]

Good eye.  In general maybe, but I think we're safe in this case since all of
the paths are coming from the directory listing and we should always be
recursing down and never up.

+
   void _processPlugins() {
     List<Plugin> plugins = <Plugin>[];
     plugins.addAll(AnalysisEngine.instance.requiredPlugins);
     plugins.add(AnalysisEngine.instance.commandLinePlugin);
     plugins.add(AnalysisEngine.instance.optionsPlugin);
     plugins.add(linterPlugin);
     plugins.addAll(_userDefinedPlugins);
 
     ExtensionManager manager = new ExtensionManager();
     manager.processPlugins(plugins);
   }
 
   /// Analyze a single source.
   ErrorSeverity _runAnalyzer(Source source, CommandLineOptions options) {
     int startTime = currentTimeMillis();
     AnalyzerImpl analyzer =
-        new AnalyzerImpl(_context, source, options, startTime);
+        new AnalyzerImpl(_context, source, options, stats, startTime);
     var errorSeverity = analyzer.analyzeSync();
     if (errorSeverity == ErrorSeverity.ERROR) {
       exitCode = errorSeverity.ordinal;
     }
     if (options.warningsAreFatal && errorSeverity == ErrorSeverity.WARNING) {
       exitCode = errorSeverity.ordinal;
     }
     return errorSeverity;
   }
 
@@ skipping 187 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }