[tool] version-check publish-check commands can check against pub

script/tool/CHANGELOG.md

@@ -1,3 +1,8 @@
+## NEXT
+
+- Add `against-pub` flag for version-check, which allows the command to check version with pub.
+- Add `machine` flag for publish-check, which replaces outputs to something parsable by machines.
+
 ## 0.1.0+1
 
 - Re-add the bin/ directory.

script/tool/lib/src/common.dart

@@ -11,6 +11,7 @@ import 'package:args/command_runner.dart';
 import 'package:colorize/colorize.dart';
 import 'package:file/file.dart';
 import 'package:git/git.dart';
+import 'package:http/http.dart' as http;
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
@@ -549,6 +550,95 @@ class ProcessRunner {
   }
 }
 
+/// Finding version of [package] that is published on pub.
+class PubVersionFinder {
+  /// Constructor.
+  ///
+  /// Note: you should manually close the [httpClient] when done using the finder.
+  PubVersionFinder({this.pubHost = defaultPubHost, @required this.httpClient});
+
+  /// The default pub host to use.
+  static const String defaultPubHost = 'https://pub.dev';
+
+  /// The pub host url, defaults to `https://pub.dev`.
+  final String pubHost;
+
+  /// The http client.
+  ///
+  /// You should manually close this client when done using this finder.
+  final http.Client httpClient;
+
+  /// Get the package version on pub.
+  Future<PubVersionFinderResponse> getPackageVersion(
+      {@required String package}) async {
+    assert(package != null && package.isNotEmpty);
+    final Uri pubHostUri = Uri.parse(pubHost);
+    final Uri url = pubHostUri.replace(path: '/packages/$package.json');
+    final http.Response response = await httpClient.get(url);
+
+    if (response.statusCode == 404) {
+      return PubVersionFinderResponse(
+          versions: null,
+          result: PubVersionFinderResult.noPackageFound,
+          httpResponse: response);
+    } else if (response.statusCode != 200) {
+      return PubVersionFinderResponse(
+          versions: null,
+          result: PubVersionFinderResult.fail,
+          httpResponse: response);
+    }
+    final List<Version> versions =
+        (json.decode(response.body)['versions'] as List<dynamic>)
+            .map<Version>((final dynamic versionString) =>
+                Version.parse(versionString as String))
+            .toList();
+
+    return PubVersionFinderResponse(
+        versions: versions,
+        result: PubVersionFinderResult.success,
+        httpResponse: response);
+  }
+}
+
+/// Represents a response for [PubVersionFinder].
+class PubVersionFinderResponse {
+  /// Constructor.
+  PubVersionFinderResponse({this.versions, this.result, this.httpResponse}) {
+    versions.sort((Version a, Version b) {
+      /// TODO(cyanglaz): Think about how to handle pre-release version with [Version.prioritize].
+      return b.compareTo(a);
+    });
+  }
+
+  /// The versions found in [PubVersionFinder].
+  ///
+  /// This is sorted by largest to smallest, so the first element in the list is the largest version.
+  /// Might be `null` if the [result] is not [PubVersionFinderResult.success].
+  final List<Version> versions;
+
+  /// The result of the version finder.
+  final PubVersionFinderResult result;
+
+  /// The response object of the http request.
+  final http.Response httpResponse;
+}
+
+/// An enum representing the result of [PubVersionFinder].
+enum PubVersionFinderResult {
+  /// The version finder successfully found a version.
+  success,
+
+  /// The version finder failed to find a valid version.
+  ///
+  /// This might due to http connection errors or user errors.
+  fail,
+
+  /// The version finder failed to locate the package.
+  ///
+  /// This indicates the package is new.
+  noPackageFound,
+}
+
 /// Finding diffs based on `baseGitDir` and `baseSha`.
 class GitVersionFinder {
   /// Constructor

script/tool/lib/src/publish_check_command.dart

@@ -3,10 +3,13 @@
 // found in the LICENSE file.
 
 import 'dart:async';
+import 'dart:convert';
 import 'dart:io' as io;
 
 import 'package:colorize/colorize.dart';
 import 'package:file/file.dart';
+import 'package:http/http.dart' as http;
+import 'package:pub_semver/pub_semver.dart';
 import 'package:pubspec_parse/pubspec_parse.dart';
 
 import 'common.dart';
@@ -18,17 +21,38 @@ class PublishCheckCommand extends PluginCommand {
     Directory packagesDir,
     FileSystem fileSystem, {
     ProcessRunner processRunner = const ProcessRunner(),
-  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    this.httpClient,
+  })  : _pubVersionFinder =
+            PubVersionFinder(httpClient: httpClient ?? http.Client()),
+        super(packagesDir, fileSystem, processRunner: processRunner) {
     argParser.addFlag(
       _allowPrereleaseFlag,
       help: 'Allows the pre-release SDK warning to pass.\n'
           'When enabled, a pub warning, which asks to publish the package as a pre-release version when '
           'the SDK constraint is a pre-release version, is ignored.',
       defaultsTo: false,
     );
+    argParser.addFlag(_machineFlag,
+        help: 'Only prints a final status as a defined string.\n'
+            'The possible values are:\n'
+            '    $_machineMessageNeedsPublish: There is at least one package need to be published. They also passed all publish checks.\n'
+            '    $_machineMessageNoPublish: There are no packages needs to be published. Either no pubspec change detected or all versions have already been published.\n'
+            '    $_machineMessageError: Some error has occurred.',
+        defaultsTo: false,
+        negatable: true);
   }
 
   static const String _allowPrereleaseFlag = 'allow-pre-release';
+  static const String _machineFlag = 'machine';
+  static const String _machineMessageNeedsPublish = 'needs-publish';
+  static const String _machineMessageNoPublish = 'no-publish';
+  static const String _machineMessageError = 'error';
+
+  final List<String> _validStatus = <String>[
+    _machineMessageNeedsPublish,
+    _machineMessageNoPublish,
+    _machineMessageError
+  ];
 
   @override
   final String name = 'publish-check';
@@ -37,15 +61,46 @@ class PublishCheckCommand extends PluginCommand {
   final String description =
       'Checks to make sure that a plugin *could* be published.';
 
+  /// The custom http client used to query versions on pub.
+  final http.Client httpClient;
+
+  final PubVersionFinder _pubVersionFinder;
+
   @override
   Future<void> run() async {
+    final ZoneSpecification logSwitchSpecification = ZoneSpecification(
+        print: (Zone self, ZoneDelegate parent, Zone zone, String message) {
+      final bool logMachineMessage = argResults[_machineFlag] as bool;
+      final bool isMachineMessage = _validStatus.contains(message);
+      if (logMachineMessage == isMachineMessage) {
+        parent.print(zone, message);
+      }
+    });
+
+    await runZoned(_runCommand, zoneSpecification: logSwitchSpecification);
+  }
+
+  Future<void> _runCommand() async {
     final List<Directory> failedPackages = <Directory>[];
 
+    String resultToLog = _machineMessageNoPublish;
     await for (final Directory plugin in getPlugins()) {
-      if (!(await _passesPublishCheck(plugin))) {
-        failedPackages.add(plugin);
+      final _PublishCheckResult result = await _passesPublishCheck(plugin);
+      switch (result) {
+        case _PublishCheckResult._needsPublish:
+          if (failedPackages.isEmpty) {
+            resultToLog = _machineMessageNeedsPublish;
+          }
+          break;
+        case _PublishCheckResult._noPublish:
+          break;
+        case _PublishCheckResult._error:
+          failedPackages.add(plugin);
+          resultToLog = _machineMessageError;
+          break;
       }
     }
+    _pubVersionFinder.httpClient.close();
 
     if (failedPackages.isNotEmpty) {
       final String error =
@@ -56,12 +111,18 @@ class PublishCheckCommand extends PluginCommand {
       final Colorize colorizedError = Colorize('$error\n$joinedFailedPackages')
         ..red();
       print(colorizedError);
-      throw ToolExit(1);
+    } else {
+      final Colorize passedMessage =
+          Colorize('All packages passed publish check!')..green();
+      print(passedMessage);
     }
 
-    final Colorize passedMessage =
-        Colorize('All packages passed publish check!')..green();
-    print(passedMessage);
+    if (argResults[_machineFlag] as bool) {
+      print(resultToLog);
+    }
+    if (failedPackages.isNotEmpty) {
+      throw ToolExit(1);
+    }
   }
 
   Pubspec _tryParsePubspec(Directory package) {
@@ -89,17 +150,23 @@ class PublishCheckCommand extends PluginCommand {
     final Completer<void> stdOutCompleter = Completer<void>();
     process.stdout.listen(
       (List<int> event) {
-        io.stdout.add(event);
-        outputBuffer.write(String.fromCharCodes(event));
+        final String output = String.fromCharCodes(event);
+        if (output.isNotEmpty) {
+          print(output);
+          outputBuffer.write(output);
+        }
       },
       onDone: () => stdOutCompleter.complete(),
     );
 
     final Completer<void> stdInCompleter = Completer<void>();
     process.stderr.listen(
       (List<int> event) {
-        io.stderr.add(event);
-        outputBuffer.write(String.fromCharCodes(event));
+        final String output = String.fromCharCodes(event);
+        if (output.isNotEmpty) {
+          print(Colorize(output)..red());
+          outputBuffer.write(output);
+        }
       },
       onDone: () => stdInCompleter.complete(),
     );
@@ -121,24 +188,67 @@ class PublishCheckCommand extends PluginCommand {
             'Packages with an SDK constraint on a pre-release of the Dart SDK should themselves be published as a pre-release version.');
   }
 
-  Future<bool> _passesPublishCheck(Directory package) async {
+  Future<_PublishCheckResult> _passesPublishCheck(Directory package) async {
     final String packageName = package.basename;
     print('Checking that $packageName can be published.');
 
     final Pubspec pubspec = _tryParsePubspec(package);
     if (pubspec == null) {
-      return false;
+      print('no pubspec');
+      return _PublishCheckResult._error;
     } else if (pubspec.publishTo == 'none') {
       print('Package $packageName is marked as unpublishable. Skipping.');
-      return true;
+      return _PublishCheckResult._noPublish;
+    }
+
+    final Version version = pubspec.version;
+    final bool alreadyPublished = await _checkIfAlreadyPublished(
+        packageName: packageName, version: version);
+    if (alreadyPublished) {
+      print(
+          'Package $packageName version: $version has already be published on pub.');
+      return _PublishCheckResult._noPublish;
     }
 
     if (await _hasValidPublishCheckRun(package)) {
       print('Package $packageName is able to be published.');
-      return true;
+      return _PublishCheckResult._needsPublish;
     } else {
       print('Unable to publish $packageName');
-      return false;
+      return _PublishCheckResult._error;
     }
   }
+
+  // Check if `packageName` already has `version` published on pub.
+  Future<bool> _checkIfAlreadyPublished(
+      {String packageName, Version version}) async {
+    final PubVersionFinderResponse pubVersionFinderResponse =
+        await _pubVersionFinder.getPackageVersion(package: packageName);
+    bool published;
+    switch (pubVersionFinderResponse.result) {
+      case PubVersionFinderResult.success:
+        published = pubVersionFinderResponse.versions.contains(version);
+        break;
+      case PubVersionFinderResult.fail:
+        print(_machineMessageError);
+        printErrorAndExit(errorMessage: '''
+Error fetching version on pub for $packageName.
+HTTP Status ${pubVersionFinderResponse.httpResponse.statusCode}
+HTTP response: ${pubVersionFinderResponse.httpResponse.body}
+''');
+        break;
+      case PubVersionFinderResult.noPackageFound:
+        published = false;
+        break;
+    }
+    return published;
+  }
+}
+
+enum _PublishCheckResult {
+  _needsPublish,
+
+  _noPublish,
+
+  _error,
 }