blob: 14b240dc04c2249c25c62c2b654032149513942d [file] [log] [blame]
// Copyright 2013 The Flutter 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 'dart:io' as io;
import 'package:file/file.dart';
import 'package:http/http.dart' as http;
import 'package:platform/platform.dart';
import 'package:pub_semver/pub_semver.dart';
import 'common/core.dart';
import 'common/package_looping_command.dart';
import 'common/process_runner.dart';
import 'common/pub_version_finder.dart';
import 'common/repository_package.dart';
/// A command to check that packages are publishable via 'dart publish'.
class PublishCheckCommand extends PackageLoopingCommand {
/// Creates an instance of the publish command.
PublishCheckCommand(
Directory packagesDir, {
ProcessRunner processRunner = const ProcessRunner(),
Platform platform = const LocalPlatform(),
http.Client? httpClient,
}) : _pubVersionFinder =
PubVersionFinder(httpClient: httpClient ?? http.Client()),
super(packagesDir, processRunner: processRunner, platform: platform) {
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.',
);
argParser.addFlag(_machineFlag,
help: 'Switch outputs to a machine readable JSON. \n'
'The JSON contains a "status" field indicating the final status of the command, the possible values are:\n'
' $_statusNeedsPublish: There is at least one package need to be published. They also passed all publish checks.\n'
' $_statusMessageNoPublish: There are no packages needs to be published. Either no pubspec change detected or all versions have already been published.\n'
' $_statusMessageError: Some error has occurred.');
}
static const String _allowPrereleaseFlag = 'allow-pre-release';
static const String _machineFlag = 'machine';
static const String _statusNeedsPublish = 'needs-publish';
static const String _statusMessageNoPublish = 'no-publish';
static const String _statusMessageError = 'error';
static const String _statusKey = 'status';
static const String _humanMessageKey = 'humanMessage';
@override
final String name = 'publish-check';
@override
final String description =
'Checks to make sure that a package *could* be published.';
final PubVersionFinder _pubVersionFinder;
/// The overall result of the run for machine-readable output. This is the
/// highest value that occurs during the run.
_PublishCheckResult _overallResult = _PublishCheckResult.nothingToPublish;
@override
bool get captureOutput => getBoolArg(_machineFlag);
@override
Future<void> initializeRun() async {
_overallResult = _PublishCheckResult.nothingToPublish;
}
@override
Future<PackageResult> runForPackage(RepositoryPackage package) async {
_PublishCheckResult? result = await _passesPublishCheck(package);
if (result == null) {
return PackageResult.skip('Package is marked as unpublishable.');
}
if (!_passesAuthorsCheck(package)) {
_printImportantStatusMessage(
'No AUTHORS file found. Packages must include an AUTHORS file.',
isError: true);
result = _PublishCheckResult.error;
}
if (result.index > _overallResult.index) {
_overallResult = result;
}
return result == _PublishCheckResult.error
? PackageResult.fail()
: PackageResult.success();
}
@override
Future<void> completeRun() async {
_pubVersionFinder.httpClient.close();
}
@override
Future<void> handleCapturedOutput(List<String> output) async {
final Map<String, dynamic> machineOutput = <String, dynamic>{
_statusKey: _statusStringForResult(_overallResult),
_humanMessageKey: output,
};
print(const JsonEncoder.withIndent(' ').convert(machineOutput));
}
String _statusStringForResult(_PublishCheckResult result) {
switch (result) {
case _PublishCheckResult.nothingToPublish:
return _statusMessageNoPublish;
case _PublishCheckResult.needsPublishing:
return _statusNeedsPublish;
case _PublishCheckResult.error:
return _statusMessageError;
}
}
Pubspec? _tryParsePubspec(RepositoryPackage package) {
try {
return package.parsePubspec();
} on Exception catch (exception) {
print(
'Failed to parse `pubspec.yaml` at ${package.pubspecFile.path}: '
'$exception',
);
return null;
}
}
// Run `dart pub get` on the examples of [package].
Future<void> _fetchExampleDeps(RepositoryPackage package) async {
for (final RepositoryPackage example in package.getExamples()) {
await processRunner.runAndStream(
'dart',
<String>['pub', 'get'],
workingDir: example.directory,
);
}
}
Future<bool> _hasValidPublishCheckRun(RepositoryPackage package) async {
// `pub publish` does not do `dart pub get` inside `example` directories
// of a package (but they're part of the analysis output!).
// Issue: https://github.com/flutter/flutter/issues/113788
await _fetchExampleDeps(package);
print('Running pub publish --dry-run:');
final io.Process process = await processRunner.start(
flutterCommand,
<String>['pub', 'publish', '--', '--dry-run'],
workingDirectory: package.directory,
);
final StringBuffer outputBuffer = StringBuffer();
final Completer<void> stdOutCompleter = Completer<void>();
process.stdout.listen(
(List<int> 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) {
final String output = String.fromCharCodes(event);
if (output.isNotEmpty) {
// The final result is always printed on stderr, whether success or
// failure.
final bool isError = !output.contains('has 0 warnings');
_printImportantStatusMessage(output, isError: isError);
outputBuffer.write(output);
}
},
onDone: () => stdInCompleter.complete(),
);
if (await process.exitCode == 0) {
return true;
}
if (!getBoolArg(_allowPrereleaseFlag)) {
return false;
}
await stdOutCompleter.future;
await stdInCompleter.future;
final String output = outputBuffer.toString();
return output.contains('Package has 1 warning') &&
output.contains(
'Packages with an SDK constraint on a pre-release of the Dart SDK should themselves be published as a pre-release version.');
}
/// Returns the result of the publish check, or null if the package is marked
/// as unpublishable.
Future<_PublishCheckResult?> _passesPublishCheck(
RepositoryPackage package) async {
final String packageName = package.directory.basename;
final Pubspec? pubspec = _tryParsePubspec(package);
if (pubspec == null) {
print('No valid pubspec found.');
return _PublishCheckResult.error;
} else if (pubspec.publishTo == 'none') {
return null;
}
final Version? version = pubspec.version;
final _PublishCheckResult alreadyPublishedResult =
await _checkPublishingStatus(
packageName: packageName, version: version);
if (alreadyPublishedResult == _PublishCheckResult.nothingToPublish) {
print(
'Package $packageName version: $version has already be published on pub.');
return alreadyPublishedResult;
} else if (alreadyPublishedResult == _PublishCheckResult.error) {
print('Check pub version failed $packageName');
return _PublishCheckResult.error;
}
if (await _hasValidPublishCheckRun(package)) {
print('Package $packageName is able to be published.');
return _PublishCheckResult.needsPublishing;
} else {
print('Unable to publish $packageName');
return _PublishCheckResult.error;
}
}
// Check if `packageName` already has `version` published on pub.
Future<_PublishCheckResult> _checkPublishingStatus(
{required String packageName, required Version? version}) async {
final PubVersionFinderResponse pubVersionFinderResponse =
await _pubVersionFinder.getPackageVersion(packageName: packageName);
switch (pubVersionFinderResponse.result) {
case PubVersionFinderResult.success:
return pubVersionFinderResponse.versions.contains(version)
? _PublishCheckResult.nothingToPublish
: _PublishCheckResult.needsPublishing;
case PubVersionFinderResult.fail:
print('''
Error fetching version on pub for $packageName.
HTTP Status ${pubVersionFinderResponse.httpResponse.statusCode}
HTTP response: ${pubVersionFinderResponse.httpResponse.body}
''');
return _PublishCheckResult.error;
case PubVersionFinderResult.noPackageFound:
return _PublishCheckResult.needsPublishing;
}
}
bool _passesAuthorsCheck(RepositoryPackage package) {
final List<String> pathComponents =
package.directory.fileSystem.path.split(package.path);
if (pathComponents.contains('third_party')) {
// Third-party packages aren't required to have an AUTHORS file.
return true;
}
return package.authorsFile.existsSync();
}
void _printImportantStatusMessage(String message, {required bool isError}) {
final String statusMessage = '${isError ? 'ERROR' : 'SUCCESS'}: $message';
if (getBoolArg(_machineFlag)) {
print(statusMessage);
} else {
if (isError) {
printError(statusMessage);
} else {
printSuccess(statusMessage);
}
}
}
}
/// Possible outcomes of of a publishing check.
enum _PublishCheckResult {
nothingToPublish,
needsPublishing,
error,
}