// Copyright 2015 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. import 'dart:async'; import 'package:args/args.dart'; import 'package:yaml/yaml.dart' as yaml; import '../base/common.dart'; import '../base/file_system.dart'; import '../base/utils.dart'; import '../cache.dart'; import '../globals.dart'; /// Common behavior for `flutter analyze` and `flutter analyze --watch` abstract class AnalyzeBase { AnalyzeBase(this.argResults); /// The parsed argument results for execution. final ArgResults argResults; /// Called by [AnalyzeCommand] to start the analysis process. Future<void> analyze(); void dumpErrors(Iterable<String> errors) { if (argResults['write'] != null) { try { final RandomAccessFile resultsFile = fs.file(argResults['write']).openSync(mode: FileMode.write); try { resultsFile.lockSync(); resultsFile.writeStringSync(errors.join('\n')); } finally { resultsFile.close(); } } catch (e) { printError('Failed to save output to "${argResults['write']}": $e'); } } } void writeBenchmark(Stopwatch stopwatch, int errorCount, int membersMissingDocumentation) { const String benchmarkOut = 'analysis_benchmark.json'; final Map<String, dynamic> data = <String, dynamic>{ 'time': stopwatch.elapsedMilliseconds / 1000.0, 'issues': errorCount, 'missingDartDocs': membersMissingDocumentation, }; fs.file(benchmarkOut).writeAsStringSync(toPrettyJson(data)); printStatus('Analysis benchmark written to $benchmarkOut ($data).'); } bool get isBenchmarking => argResults['benchmark']; } /// Return true if [fileList] contains a path that resides inside the Flutter repository. /// If [fileList] is empty, then return true if the current directory resides inside the Flutter repository. bool inRepo(List<String> fileList) { if (fileList == null || fileList.isEmpty) { fileList = <String>[fs.path.current]; } final String root = fs.path.normalize(fs.path.absolute(Cache.flutterRoot)); final String prefix = root + fs.path.separator; for (String file in fileList) { file = fs.path.normalize(fs.path.absolute(file)); if (file == root || file.startsWith(prefix)) { return true; } } return false; } class PackageDependency { // This is a map from dependency targets (lib directories) to a list // of places that ask for that target (.packages or pubspec.yaml files) Map<String, List<String>> values = <String, List<String>>{}; String canonicalSource; void addCanonicalCase(String packagePath, String pubSpecYamlPath) { assert(canonicalSource == null); add(packagePath, pubSpecYamlPath); canonicalSource = pubSpecYamlPath; } void add(String packagePath, String sourcePath) { values.putIfAbsent(packagePath, () => <String>[]).add(sourcePath); } bool get hasConflict => values.length > 1; bool get hasConflictAffectingFlutterRepo { assert(fs.path.isAbsolute(Cache.flutterRoot)); for (List<String> targetSources in values.values) { for (String source in targetSources) { assert(fs.path.isAbsolute(source)); if (fs.path.isWithin(Cache.flutterRoot, source)) { return true; } } } return false; } void describeConflict(StringBuffer result) { assert(hasConflict); final List<String> targets = values.keys.toList(); targets.sort((String a, String b) => values[b].length.compareTo(values[a].length)); for (String target in targets) { final int count = values[target].length; result.writeln(' $count ${count == 1 ? 'source wants' : 'sources want'} "$target":'); bool canonical = false; for (String source in values[target]) { result.writeln(' $source'); if (source == canonicalSource) { canonical = true; } } if (canonical) { result.writeln(' (This is the actual package definition, so it is considered the canonical "right answer".)'); } } } String get target => values.keys.single; } class PackageDependencyTracker { /// Packages whose source is defined in the vended SDK. static const List<String> _vendedSdkPackages = <String>['analyzer', 'front_end', 'kernel']; // This is a map from package names to objects that track the paths // involved (sources and targets). Map<String, PackageDependency> packages = <String, PackageDependency>{}; PackageDependency getPackageDependency(String packageName) { return packages.putIfAbsent(packageName, () => PackageDependency()); } /// Read the .packages file in [directory] and add referenced packages to [dependencies]. void addDependenciesFromPackagesFileIn(Directory directory) { final String dotPackagesPath = fs.path.join(directory.path, '.packages'); final File dotPackages = fs.file(dotPackagesPath); if (dotPackages.existsSync()) { // this directory has opinions about what we should be using final Iterable<String> lines = dotPackages .readAsStringSync() .split('\n') .where((String line) => !line.startsWith(RegExp(r'^ *#'))); for (String line in lines) { final int colon = line.indexOf(':'); if (colon > 0) { final String packageName = line.substring(0, colon); final String packagePath = fs.path.fromUri(line.substring(colon+1)); // Ensure that we only add `analyzer` and dependent packages defined in the vended SDK (and referred to with a local // fs.path. directive). Analyzer package versions reached via transitive dependencies (e.g., via `test`) are ignored // since they would produce spurious conflicts. if (!_vendedSdkPackages.contains(packageName) || packagePath.startsWith('..')) { add(packageName, fs.path.normalize(fs.path.absolute(directory.path, packagePath)), dotPackagesPath); } } } } } void addCanonicalCase(String packageName, String packagePath, String pubSpecYamlPath) { getPackageDependency(packageName).addCanonicalCase(packagePath, pubSpecYamlPath); } void add(String packageName, String packagePath, String dotPackagesPath) { getPackageDependency(packageName).add(packagePath, dotPackagesPath); } void checkForConflictingDependencies(Iterable<Directory> pubSpecDirectories, PackageDependencyTracker dependencies) { for (Directory directory in pubSpecDirectories) { final String pubSpecYamlPath = fs.path.join(directory.path, 'pubspec.yaml'); final File pubSpecYamlFile = fs.file(pubSpecYamlPath); if (pubSpecYamlFile.existsSync()) { // we are analyzing the actual canonical source for this package; // make sure we remember that, in case all the packages are actually // pointing elsewhere somehow. final yaml.YamlMap pubSpecYaml = yaml.loadYaml(fs.file(pubSpecYamlPath).readAsStringSync()); final String packageName = pubSpecYaml['name']; final String packagePath = fs.path.normalize(fs.path.absolute(fs.path.join(directory.path, 'lib'))); dependencies.addCanonicalCase(packageName, packagePath, pubSpecYamlPath); } dependencies.addDependenciesFromPackagesFileIn(directory); } // prepare a union of all the .packages files if (dependencies.hasConflicts) { final StringBuffer message = StringBuffer(); message.writeln(dependencies.generateConflictReport()); message.writeln('Make sure you have run "pub upgrade" in all the directories mentioned above.'); if (dependencies.hasConflictsAffectingFlutterRepo) { message.writeln( 'For packages in the flutter repository, try using "flutter update-packages" to do all of them at once.\n' 'If you need to actually upgrade them, consider "flutter update-packages --force-upgrade". ' '(This will update your pubspec.yaml files as well, so you may wish to do this on a separate branch.)' ); } message.write( 'If this does not help, to track down the conflict you can use ' '"pub deps --style=list" and "pub upgrade --verbosity=solver" in the affected directories.' ); throwToolExit(message.toString()); } } bool get hasConflicts { return packages.values.any((PackageDependency dependency) => dependency.hasConflict); } bool get hasConflictsAffectingFlutterRepo { return packages.values.any((PackageDependency dependency) => dependency.hasConflictAffectingFlutterRepo); } String generateConflictReport() { assert(hasConflicts); final StringBuffer result = StringBuffer(); for (String package in packages.keys.where((String package) => packages[package].hasConflict)) { result.writeln('Package "$package" has conflicts:'); packages[package].describeConflict(result); } return result.toString(); } Map<String, String> asPackageMap() { final Map<String, String> result = <String, String>{}; for (String package in packages.keys) { result[package] = packages[package].target; } return result; } }