packages/flutter_tools/lib/src/commands/analyze_continuously.dart - mirrors/flutter - Git at Google

 // 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 'dart:convert';

 import 'package:args/args.dart';

 import '../base/common.dart';
 import '../base/file_system.dart';
 import '../base/io.dart';
 import '../base/logger.dart';
 import '../base/process_manager.dart';
 import '../base/utils.dart';
 import '../cache.dart';
 import '../dart/sdk.dart';
 import '../globals.dart';
 import 'analyze_base.dart';

 class AnalyzeContinuously extends AnalyzeBase {
   final List<Directory> repoAnalysisEntryPoints;

   AnalyzeContinuously(ArgResults argResults, this.repoAnalysisEntryPoints) : super(argResults);

   String analysisTarget;
   bool firstAnalysis = true;
   Set<String> analyzedPaths = new Set<String>();
   Map<String, List<AnalysisError>> analysisErrors = <String, List<AnalysisError>>{};
   Stopwatch analysisTimer;
   int lastErrorCount = 0;
   Status analysisStatus;

   @override
   Future<Null> analyze() async {
     List<String> directories;

     if (argResults['flutter-repo']) {
       directories = repoAnalysisEntryPoints.map((Directory dir) => dir.path).toList();
       analysisTarget = 'Flutter repository';
       printTrace('Analyzing Flutter repository:');
       for (String projectPath in directories)
         printTrace('  ${fs.path.relative(projectPath)}');
     } else {
       directories = <String>[fs.currentDirectory.path];
       analysisTarget = fs.currentDirectory.path;
     }

     final AnalysisServer server = new AnalysisServer(dartSdkPath, directories);
     server.onAnalyzing.listen((bool isAnalyzing) => _handleAnalysisStatus(server, isAnalyzing));
     server.onErrors.listen(_handleAnalysisErrors);

     Cache.releaseLockEarly();

     await server.start();
     final int exitCode = await server.onExit;

     final String message = 'Analysis server exited with code $exitCode.';
     if (exitCode != 0)
       throwToolExit(message, exitCode: exitCode);
     printStatus(message);
   }

   void _handleAnalysisStatus(AnalysisServer server, bool isAnalyzing) {
     if (isAnalyzing) {
       analysisStatus?.cancel();
       if (!firstAnalysis)
         printStatus('\n');
       analysisStatus = logger.startProgress('Analyzing $analysisTarget...');
       analyzedPaths.clear();
       analysisTimer = new Stopwatch()..start();
     } else {
       analysisStatus?.stop();
       analysisTimer.stop();

       logger.printStatus(terminal.clearScreen(), newline: false);

       // Remove errors for deleted files, sort, and print errors.
       final List<AnalysisError> errors = <AnalysisError>[];
       for (String path in analysisErrors.keys.toList()) {
         if (fs.isFileSync(path)) {
           errors.addAll(analysisErrors[path]);
         } else {
           analysisErrors.remove(path);
         }
       }

       errors.sort();

       for (AnalysisError error in errors) {
         printStatus(error.toString());
         if (error.code != null)
           printTrace('error code: ${error.code}');
       }

       dumpErrors(errors.map<String>((AnalysisError error) => error.toLegacyString()));

       // Print an analysis summary.
       String errorsMessage;

       final int issueCount = errors.length;
       final int issueDiff = issueCount - lastErrorCount;
       lastErrorCount = issueCount;

       if (firstAnalysis)
         errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found';
       else if (issueDiff > 0)
         errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found ($issueDiff new)';
       else if (issueDiff < 0)
         errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found (${-issueDiff} fixed)';
       else if (issueCount != 0)
         errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found';
       else
         errorsMessage = 'no issues found';

       final String files = '${analyzedPaths.length} ${pluralize('file', analyzedPaths.length)}';
       final String seconds = (analysisTimer.elapsedMilliseconds / 1000.0).toStringAsFixed(2);
       printStatus('$errorsMessage • analyzed $files, $seconds seconds');

       if (firstAnalysis && isBenchmarking) {
         writeBenchmark(analysisTimer, issueCount, -1); // TODO(ianh): track members missing dartdocs instead of saying -1
         server.dispose().whenComplete(() { exit(issueCount > 0 ? 1 : 0); });
       }

       firstAnalysis = false;
     }
   }

   bool _filterError(AnalysisError error) {
     // TODO(devoncarew): Also filter the regex items from `analyzeOnce()`.

     if (error.type == 'TODO')
       return true;

     return false;
   }

   void _handleAnalysisErrors(FileAnalysisErrors fileErrors) {
     fileErrors.errors.removeWhere(_filterError);

     analyzedPaths.add(fileErrors.file);
     analysisErrors[fileErrors.file] = fileErrors.errors;
   }
 }

 class AnalysisServer {
   AnalysisServer(this.sdk, this.directories);

   final String sdk;
   final List<String> directories;

   Process _process;
   StreamController<bool> _analyzingController = new StreamController<bool>.broadcast();
   StreamController<FileAnalysisErrors> _errorsController = new StreamController<FileAnalysisErrors>.broadcast();

   int _id = 0;

   Future<Null> start() async {
     final String snapshot = fs.path.join(sdk, 'bin/snapshots/analysis_server.dart.snapshot');
     final List<String> command = <String>[
       fs.path.join(dartSdkPath, 'bin', 'dart'),
       snapshot,
       '--sdk',
       sdk,
     ];

     printTrace('dart ${command.skip(1).join(' ')}');
     _process = await processManager.start(command);
     _process.exitCode.whenComplete(() => _process = null);

     final Stream<String> errorStream = _process.stderr.transform(UTF8.decoder).transform(const LineSplitter());
     errorStream.listen(printError);

     final Stream<String> inStream = _process.stdout.transform(UTF8.decoder).transform(const LineSplitter());
     inStream.listen(_handleServerResponse);

     // Available options (many of these are obsolete):
     //   enableAsync, enableDeferredLoading, enableEnums, enableNullAwareOperators,
     //   enableSuperMixins, generateDart2jsHints, generateHints, generateLints
     _sendCommand('analysis.updateOptions', <String, dynamic>{
       'options': <String, dynamic>{
         'enableSuperMixins': true
       }
     });

     _sendCommand('server.setSubscriptions', <String, dynamic>{
       'subscriptions': <String>['STATUS']
     });

     _sendCommand('analysis.setAnalysisRoots', <String, dynamic>{
       'included': directories,
       'excluded': <String>[]
     });
   }

   Stream<bool> get onAnalyzing => _analyzingController.stream;
   Stream<FileAnalysisErrors> get onErrors => _errorsController.stream;

   Future<int> get onExit => _process.exitCode;

   void _sendCommand(String method, Map<String, dynamic> params) {
     final String message = JSON.encode(<String, dynamic> {
       'id': (++_id).toString(),
       'method': method,
       'params': params
     });
     _process.stdin.writeln(message);
     printTrace('==> $message');
   }

   void _handleServerResponse(String line) {
     printTrace('<== $line');

     final dynamic response = JSON.decode(line);

     if (response is Map<dynamic, dynamic>) {
       if (response['event'] != null) {
         final String event = response['event'];
         final dynamic params = response['params'];

         if (params is Map<dynamic, dynamic>) {
           if (event == 'server.status')
             _handleStatus(response['params']);
           else if (event == 'analysis.errors')
             _handleAnalysisIssues(response['params']);
           else if (event == 'server.error')
             _handleServerError(response['params']);
         }
       } else if (response['error'] != null) {
         // Fields are 'code', 'message', and 'stackTrace'.
         final Map<String, dynamic> error = response['error'];
         printError('Error response from the server: ${error['code']} ${error['message']}');
         if (error['stackTrace'] != null)
           printError(error['stackTrace']);
       }
     }
   }

   void _handleStatus(Map<String, dynamic> statusInfo) {
     // {"event":"server.status","params":{"analysis":{"isAnalyzing":true}}}
     if (statusInfo['analysis'] != null && !_analyzingController.isClosed) {
       final bool isAnalyzing = statusInfo['analysis']['isAnalyzing'];
       _analyzingController.add(isAnalyzing);
     }
   }

   void _handleServerError(Map<String, dynamic> error) {
     // Fields are 'isFatal', 'message', and 'stackTrace'.
     printError('Error from the analysis server: ${error['message']}');
     if (error['stackTrace'] != null)
       printError(error['stackTrace']);
   }

   void _handleAnalysisIssues(Map<String, dynamic> issueInfo) {
     // {"event":"analysis.errors","params":{"file":"/Users/.../lib/main.dart","errors":[]}}
     final String file = issueInfo['file'];
     final List<AnalysisError> errors = issueInfo['errors'].map((Map<String, dynamic> json) => new AnalysisError(json)).toList();
     if (!_errorsController.isClosed)
       _errorsController.add(new FileAnalysisErrors(file, errors));
   }

   Future<bool> dispose() async {
     await _analyzingController.close();
     await _errorsController.close();
     return _process?.kill();
   }
 }

 class AnalysisError implements Comparable<AnalysisError> {
   AnalysisError(this.json);

   static final Map<String, int> _severityMap = <String, int> {
     'ERROR': 3,
     'WARNING': 2,
     'INFO': 1
   };

   // "severity":"INFO","type":"TODO","location":{
   //   "file":"/Users/.../lib/test.dart","offset":362,"length":72,"startLine":15,"startColumn":4
   // },"message":"...","hasFix":false}
   Map<String, dynamic> json;

   String get severity => json['severity'];
   int get severityLevel => _severityMap[severity] ?? 0;
   String get type => json['type'];
   String get message => json['message'];
   String get code => json['code'];

   String get file => json['location']['file'];
   int get startLine => json['location']['startLine'];
   int get startColumn => json['location']['startColumn'];
   int get offset => json['location']['offset'];

   @override
   int compareTo(AnalysisError other) {
     // Sort in order of file path, error location, severity, and message.
     if (file != other.file)
       return file.compareTo(other.file);

     if (offset != other.offset)
       return offset - other.offset;

     final int diff = other.severityLevel - severityLevel;
     if (diff != 0)
       return diff;

     return message.compareTo(other.message);
   }

   @override
   String toString() {
     final String relativePath = fs.path.relative(file);
     return '${severity.toLowerCase().padLeft(7)} • $message • $relativePath:$startLine:$startColumn';
   }

   String toLegacyString() {
     return '[${severity.toLowerCase()}] $message ($file:$startLine:$startColumn)';
   }
 }

 class FileAnalysisErrors {
   FileAnalysisErrors(this.file, this.errors);

   final String file;
   final List<AnalysisError> errors;
 }
	// 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 'dart:convert';

	import 'package:args/args.dart';

	import '../base/common.dart';
	import '../base/file_system.dart';
	import '../base/io.dart';
	import '../base/logger.dart';
	import '../base/process_manager.dart';
	import '../base/utils.dart';
	import '../cache.dart';
	import '../dart/sdk.dart';
	import '../globals.dart';
	import 'analyze_base.dart';

	class AnalyzeContinuously extends AnalyzeBase {
	final List<Directory> repoAnalysisEntryPoints;

	AnalyzeContinuously(ArgResults argResults, this.repoAnalysisEntryPoints) : super(argResults);

	String analysisTarget;
	bool firstAnalysis = true;
	Set<String> analyzedPaths = new Set<String>();
	Map<String, List<AnalysisError>> analysisErrors = <String, List<AnalysisError>>{};
	Stopwatch analysisTimer;
	int lastErrorCount = 0;
	Status analysisStatus;

	@override
	Future<Null> analyze() async {
	List<String> directories;

	if (argResults['flutter-repo']) {
	directories = repoAnalysisEntryPoints.map((Directory dir) => dir.path).toList();
	analysisTarget = 'Flutter repository';
	printTrace('Analyzing Flutter repository:');
	for (String projectPath in directories)
	printTrace(' ${fs.path.relative(projectPath)}');
	} else {
	directories = <String>[fs.currentDirectory.path];
	analysisTarget = fs.currentDirectory.path;
	}

	final AnalysisServer server = new AnalysisServer(dartSdkPath, directories);
	server.onAnalyzing.listen((bool isAnalyzing) => _handleAnalysisStatus(server, isAnalyzing));
	server.onErrors.listen(_handleAnalysisErrors);

	Cache.releaseLockEarly();

	await server.start();
	final int exitCode = await server.onExit;

	final String message = 'Analysis server exited with code $exitCode.';
	if (exitCode != 0)
	throwToolExit(message, exitCode: exitCode);
	printStatus(message);
	}

	void _handleAnalysisStatus(AnalysisServer server, bool isAnalyzing) {
	if (isAnalyzing) {
	analysisStatus?.cancel();
	if (!firstAnalysis)
	printStatus('\n');
	analysisStatus = logger.startProgress('Analyzing $analysisTarget...');
	analyzedPaths.clear();
	analysisTimer = new Stopwatch()..start();
	} else {
	analysisStatus?.stop();
	analysisTimer.stop();

	logger.printStatus(terminal.clearScreen(), newline: false);

	// Remove errors for deleted files, sort, and print errors.
	final List<AnalysisError> errors = <AnalysisError>[];
	for (String path in analysisErrors.keys.toList()) {
	if (fs.isFileSync(path)) {
	errors.addAll(analysisErrors[path]);
	} else {
	analysisErrors.remove(path);
	}
	}

	errors.sort();

	for (AnalysisError error in errors) {
	printStatus(error.toString());
	if (error.code != null)
	printTrace('error code: ${error.code}');
	}

	dumpErrors(errors.map<String>((AnalysisError error) => error.toLegacyString()));

	// Print an analysis summary.
	String errorsMessage;

	final int issueCount = errors.length;
	final int issueDiff = issueCount - lastErrorCount;
	lastErrorCount = issueCount;

	if (firstAnalysis)
	errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found';
	else if (issueDiff > 0)
	errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found ($issueDiff new)';
	else if (issueDiff < 0)
	errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found (${-issueDiff} fixed)';
	else if (issueCount != 0)
	errorsMessage = '$issueCount ${pluralize('issue', issueCount)} found';
	else
	errorsMessage = 'no issues found';

	final String files = '${analyzedPaths.length} ${pluralize('file', analyzedPaths.length)}';
	final String seconds = (analysisTimer.elapsedMilliseconds / 1000.0).toStringAsFixed(2);
	printStatus('$errorsMessage • analyzed $files, $seconds seconds');

	if (firstAnalysis && isBenchmarking) {
	writeBenchmark(analysisTimer, issueCount, -1); // TODO(ianh): track members missing dartdocs instead of saying -1
	server.dispose().whenComplete(() { exit(issueCount > 0 ? 1 : 0); });
	}

	firstAnalysis = false;
	}
	}

	bool _filterError(AnalysisError error) {
	// TODO(devoncarew): Also filter the regex items from `analyzeOnce()`.

	if (error.type == 'TODO')
	return true;

	return false;
	}

	void _handleAnalysisErrors(FileAnalysisErrors fileErrors) {
	fileErrors.errors.removeWhere(_filterError);

	analyzedPaths.add(fileErrors.file);
	analysisErrors[fileErrors.file] = fileErrors.errors;
	}
	}

	class AnalysisServer {
	AnalysisServer(this.sdk, this.directories);

	final String sdk;
	final List<String> directories;

	Process _process;
	StreamController<bool> _analyzingController = new StreamController<bool>.broadcast();
	StreamController<FileAnalysisErrors> _errorsController = new StreamController<FileAnalysisErrors>.broadcast();

	int _id = 0;

	Future<Null> start() async {
	final String snapshot = fs.path.join(sdk, 'bin/snapshots/analysis_server.dart.snapshot');
	final List<String> command = <String>[
	fs.path.join(dartSdkPath, 'bin', 'dart'),
	snapshot,
	'--sdk',
	sdk,
	];

	printTrace('dart ${command.skip(1).join(' ')}');
	_process = await processManager.start(command);
	_process.exitCode.whenComplete(() => _process = null);

	final Stream<String> errorStream = _process.stderr.transform(UTF8.decoder).transform(const LineSplitter());
	errorStream.listen(printError);

	final Stream<String> inStream = _process.stdout.transform(UTF8.decoder).transform(const LineSplitter());
	inStream.listen(_handleServerResponse);

	// Available options (many of these are obsolete):
	// enableAsync, enableDeferredLoading, enableEnums, enableNullAwareOperators,
	// enableSuperMixins, generateDart2jsHints, generateHints, generateLints
	_sendCommand('analysis.updateOptions', <String, dynamic>{
	'options': <String, dynamic>{
	'enableSuperMixins': true
	}
	});

	_sendCommand('server.setSubscriptions', <String, dynamic>{
	'subscriptions': <String>['STATUS']
	});

	_sendCommand('analysis.setAnalysisRoots', <String, dynamic>{
	'included': directories,
	'excluded': <String>[]
	});
	}

	Stream<bool> get onAnalyzing => _analyzingController.stream;
	Stream<FileAnalysisErrors> get onErrors => _errorsController.stream;

	Future<int> get onExit => _process.exitCode;

	void _sendCommand(String method, Map<String, dynamic> params) {
	final String message = JSON.encode(<String, dynamic> {
	'id': (++_id).toString(),
	'method': method,
	'params': params
	});
	_process.stdin.writeln(message);
	printTrace('==> $message');
	}

	void _handleServerResponse(String line) {
	printTrace('<== $line');

	final dynamic response = JSON.decode(line);

	if (response is Map<dynamic, dynamic>) {
	if (response['event'] != null) {
	final String event = response['event'];
	final dynamic params = response['params'];

	if (params is Map<dynamic, dynamic>) {
	if (event == 'server.status')
	_handleStatus(response['params']);
	else if (event == 'analysis.errors')
	_handleAnalysisIssues(response['params']);
	else if (event == 'server.error')
	_handleServerError(response['params']);
	}
	} else if (response['error'] != null) {
	// Fields are 'code', 'message', and 'stackTrace'.
	final Map<String, dynamic> error = response['error'];
	printError('Error response from the server: ${error['code']} ${error['message']}');
	if (error['stackTrace'] != null)
	printError(error['stackTrace']);
	}
	}
	}

	void _handleStatus(Map<String, dynamic> statusInfo) {
	// {"event":"server.status","params":{"analysis":{"isAnalyzing":true}}}
	if (statusInfo['analysis'] != null && !_analyzingController.isClosed) {
	final bool isAnalyzing = statusInfo['analysis']['isAnalyzing'];
	_analyzingController.add(isAnalyzing);
	}
	}

	void _handleServerError(Map<String, dynamic> error) {
	// Fields are 'isFatal', 'message', and 'stackTrace'.
	printError('Error from the analysis server: ${error['message']}');
	if (error['stackTrace'] != null)
	printError(error['stackTrace']);
	}

	void _handleAnalysisIssues(Map<String, dynamic> issueInfo) {
	// {"event":"analysis.errors","params":{"file":"/Users/.../lib/main.dart","errors":[]}}
	final String file = issueInfo['file'];
	final List<AnalysisError> errors = issueInfo['errors'].map((Map<String, dynamic> json) => new AnalysisError(json)).toList();
	if (!_errorsController.isClosed)
	_errorsController.add(new FileAnalysisErrors(file, errors));
	}

	Future<bool> dispose() async {
	await _analyzingController.close();
	await _errorsController.close();
	return _process?.kill();
	}
	}

	class AnalysisError implements Comparable<AnalysisError> {
	AnalysisError(this.json);

	static final Map<String, int> _severityMap = <String, int> {
	'ERROR': 3,
	'WARNING': 2,
	'INFO': 1
	};

	// "severity":"INFO","type":"TODO","location":{
	// "file":"/Users/.../lib/test.dart","offset":362,"length":72,"startLine":15,"startColumn":4
	// },"message":"...","hasFix":false}
	Map<String, dynamic> json;

	String get severity => json['severity'];
	int get severityLevel => _severityMap[severity] ?? 0;
	String get type => json['type'];
	String get message => json['message'];
	String get code => json['code'];

	String get file => json['location']['file'];
	int get startLine => json['location']['startLine'];
	int get startColumn => json['location']['startColumn'];
	int get offset => json['location']['offset'];

	@override
	int compareTo(AnalysisError other) {
	// Sort in order of file path, error location, severity, and message.
	if (file != other.file)
	return file.compareTo(other.file);

	if (offset != other.offset)
	return offset - other.offset;

	final int diff = other.severityLevel - severityLevel;
	if (diff != 0)
	return diff;

	return message.compareTo(other.message);
	}

	@override
	String toString() {
	final String relativePath = fs.path.relative(file);
	return '${severity.toLowerCase().padLeft(7)} • $message • $relativePath:$startLine:$startColumn';
	}

	String toLegacyString() {
	return '[${severity.toLowerCase()}] $message ($file:$startLine:$startColumn)';
	}
	}

	class FileAnalysisErrors {
	FileAnalysisErrors(this.file, this.errors);

	final String file;
	final List<AnalysisError> errors;
	}