[flutter_migrate] base boilerplate files (#2694)
diff --git a/packages/flutter_migrate/analysis_options.yaml b/packages/flutter_migrate/analysis_options.yaml
new file mode 100644
index 0000000..9d4b822
--- /dev/null
+++ b/packages/flutter_migrate/analysis_options.yaml
@@ -0,0 +1,7 @@
+# Specify analysis options.
+
+include: ../../analysis_options.yaml
+
+linter:
+ rules:
+ public_member_api_docs: false # Standalone executable, no public API
diff --git a/packages/flutter_migrate/lib/src/base/command.dart b/packages/flutter_migrate/lib/src/base/command.dart
new file mode 100644
index 0000000..18604d7
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/command.dart
@@ -0,0 +1,74 @@
+// 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 'package:args/command_runner.dart';
+
+enum ExitStatus {
+ success,
+ warning,
+ fail,
+ killed,
+}
+
+class CommandResult {
+ const CommandResult(this.exitStatus);
+
+ /// A command that succeeded. It is used to log the result of a command invocation.
+ factory CommandResult.success() {
+ return const CommandResult(ExitStatus.success);
+ }
+
+ /// A command that exited with a warning. It is used to log the result of a command invocation.
+ factory CommandResult.warning() {
+ return const CommandResult(ExitStatus.warning);
+ }
+
+ /// A command that failed. It is used to log the result of a command invocation.
+ factory CommandResult.fail() {
+ return const CommandResult(ExitStatus.fail);
+ }
+
+ final ExitStatus exitStatus;
+
+ @override
+ String toString() {
+ switch (exitStatus) {
+ case ExitStatus.success:
+ return 'success';
+ case ExitStatus.warning:
+ return 'warning';
+ case ExitStatus.fail:
+ return 'fail';
+ case ExitStatus.killed:
+ return 'killed';
+ }
+ }
+}
+
+abstract class MigrateCommand extends Command<void> {
+ @override
+ Future<void> run() async {
+ await runCommand();
+ }
+
+ Future<CommandResult> runCommand();
+
+ /// Gets the parsed command-line option named [name] as a `bool?`.
+ bool? boolArg(String name) {
+ if (!argParser.options.containsKey(name)) {
+ return null;
+ }
+ return argResults == null ? null : argResults![name] as bool;
+ }
+
+ String? stringArg(String name) {
+ if (!argParser.options.containsKey(name)) {
+ return null;
+ }
+ return argResults == null ? null : argResults![name] as String?;
+ }
+
+ /// Gets the parsed command-line option named [name] as an `int`.
+ int? intArg(String name) => argResults?[name] as int?;
+}
diff --git a/packages/flutter_migrate/lib/src/base/common.dart b/packages/flutter_migrate/lib/src/base/common.dart
new file mode 100644
index 0000000..70804f5
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/common.dart
@@ -0,0 +1,287 @@
+// 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:io';
+
+import 'file_system.dart';
+
+/// Throw a specialized exception for expected situations
+/// where the tool should exit with a clear message to the user
+/// and no stack trace unless the --verbose option is specified.
+/// For example: network errors.
+Never throwToolExit(String? message, {int? exitCode}) {
+ throw ToolExit(message, exitCode: exitCode);
+}
+
+/// Specialized exception for expected situations
+/// where the tool should exit with a clear message to the user
+/// and no stack trace unless the --verbose option is specified.
+/// For example: network errors.
+class ToolExit implements Exception {
+ ToolExit(this.message, {this.exitCode});
+
+ final String? message;
+ final int? exitCode;
+
+ @override
+ String toString() => 'Error: $message';
+}
+
+/// Return the name of an enum item.
+String getEnumName(dynamic enumItem) {
+ final String name = '$enumItem';
+ final int index = name.indexOf('.');
+ return index == -1 ? name : name.substring(index + 1);
+}
+
+/// Runs [fn] with special handling of asynchronous errors.
+///
+/// If the execution of [fn] does not throw a synchronous exception, and if the
+/// [Future] returned by [fn] is completed with a value, then the [Future]
+/// returned by [asyncGuard] is completed with that value if it has not already
+/// been completed with an error.
+///
+/// If the execution of [fn] throws a synchronous exception, and no [onError]
+/// callback is provided, then the [Future] returned by [asyncGuard] is
+/// completed with an error whose object and stack trace are given by the
+/// synchronous exception. If an [onError] callback is provided, then the
+/// [Future] returned by [asyncGuard] is completed with its result when passed
+/// the error object and stack trace.
+///
+/// If the execution of [fn] results in an asynchronous exception that would
+/// otherwise be unhandled, and no [onError] callback is provided, then the
+/// [Future] returned by [asyncGuard] is completed with an error whose object
+/// and stack trace are given by the asynchronous exception. If an [onError]
+/// callback is provided, then the [Future] returned by [asyncGuard] is
+/// completed with its result when passed the error object and stack trace.
+///
+/// After the returned [Future] is completed, whether it be with a value or an
+/// error, all further errors resulting from the execution of [fn] are ignored.
+///
+/// Rationale:
+///
+/// Consider the following snippet:
+/// ```
+/// try {
+/// await foo();
+/// ...
+/// } catch (e) {
+/// ...
+/// }
+/// ```
+/// If the [Future] returned by `foo` is completed with an error, that error is
+/// handled by the catch block. However, if `foo` spawns an asynchronous
+/// operation whose errors are unhandled, those errors will not be caught by
+/// the catch block, and will instead propagate to the containing [Zone]. This
+/// behavior is non-intuitive to programmers expecting the `catch` to catch all
+/// the errors resulting from the code under the `try`.
+///
+/// As such, it would be convenient if the `try {} catch {}` here could handle
+/// not only errors completing the awaited [Future]s it contains, but also
+/// any otherwise unhandled asynchronous errors occurring as a result of awaited
+/// expressions. This is how `await` is often assumed to work, which leads to
+/// unexpected unhandled exceptions.
+///
+/// [asyncGuard] is intended to wrap awaited expressions occurring in a `try`
+/// block. The behavior described above gives the behavior that users
+/// intuitively expect from `await`. Consider the snippet:
+/// ```
+/// try {
+/// await asyncGuard(() async {
+/// var c = Completer();
+/// c.completeError('Error');
+/// });
+/// } catch (e) {
+/// // e is 'Error';
+/// }
+/// ```
+/// Without the [asyncGuard] the error 'Error' would be propagated to the
+/// error handler of the containing [Zone]. With the [asyncGuard], the error
+/// 'Error' is instead caught by the `catch`.
+///
+/// [asyncGuard] also accepts an [onError] callback for situations in which
+/// completing the returned [Future] with an error is not appropriate.
+/// For example, it is not always possible to immediately await the returned
+/// [Future]. In these cases, an [onError] callback is needed to prevent an
+/// error from propagating to the containing [Zone].
+///
+/// [onError] must have type `FutureOr<T> Function(Object error)` or
+/// `FutureOr<T> Function(Object error, StackTrace stackTrace)` otherwise an
+/// [ArgumentError] will be thrown synchronously.
+Future<T> asyncGuard<T>(
+ Future<T> Function() fn, {
+ Function? onError,
+}) {
+ if (onError != null &&
+ onError is! _UnaryOnError<T> &&
+ onError is! _BinaryOnError<T>) {
+ throw ArgumentError('onError must be a unary function accepting an Object, '
+ 'or a binary function accepting an Object and '
+ 'StackTrace. onError must return a T');
+ }
+ final Completer<T> completer = Completer<T>();
+
+ void handleError(Object e, StackTrace s) {
+ if (completer.isCompleted) {
+ return;
+ }
+ if (onError == null) {
+ completer.completeError(e, s);
+ return;
+ }
+ if (onError is _BinaryOnError<T>) {
+ completer.complete(onError(e, s));
+ } else if (onError is _UnaryOnError<T>) {
+ completer.complete(onError(e));
+ }
+ }
+
+ runZoned<void>(() async {
+ try {
+ final T result = await fn();
+ if (!completer.isCompleted) {
+ completer.complete(result);
+ }
+ // This catches all exceptions so that they can be propagated to the
+ // caller-supplied error handling or the completer.
+ } catch (e, s) {
+ // ignore: avoid_catches_without_on_clauses, forwards to Future
+ handleError(e, s);
+ }
+ // ignore: deprecated_member_use
+ }, onError: (Object e, StackTrace s) {
+ handleError(e, s);
+ });
+
+ return completer.future;
+}
+
+typedef _UnaryOnError<T> = FutureOr<T> Function(Object error);
+typedef _BinaryOnError<T> = FutureOr<T> Function(
+ Object error, StackTrace stackTrace);
+
+/// Whether the test is running in a web browser compiled to JavaScript.
+///
+/// See also:
+///
+/// * [kIsWeb], the equivalent constant in the `foundation` library.
+const bool isBrowser = identical(0, 0.0);
+
+/// Whether the test is running on the Windows operating system.
+///
+/// This does not include tests compiled to JavaScript running in a browser on
+/// the Windows operating system.
+///
+/// See also:
+///
+/// * [isBrowser], which reports true for tests running in browsers.
+bool get isWindows {
+ if (isBrowser) {
+ return false;
+ }
+ return Platform.isWindows;
+}
+
+/// Whether the test is running on the macOS operating system.
+///
+/// This does not include tests compiled to JavaScript running in a browser on
+/// the macOS operating system.
+///
+/// See also:
+///
+/// * [isBrowser], which reports true for tests running in browsers.
+bool get isMacOS {
+ if (isBrowser) {
+ return false;
+ }
+ return Platform.isMacOS;
+}
+
+/// Whether the test is running on the Linux operating system.
+///
+/// This does not include tests compiled to JavaScript running in a browser on
+/// the Linux operating system.
+///
+/// See also:
+///
+/// * [isBrowser], which reports true for tests running in browsers.
+bool get isLinux {
+ if (isBrowser) {
+ return false;
+ }
+ return Platform.isLinux;
+}
+
+String? flutterRoot;
+
+/// Determine the absolute and normalized path for the root of the current
+/// Flutter checkout.
+///
+/// This method has a series of fallbacks for determining the repo location. The
+/// first success will immediately return the root without further checks.
+///
+/// The order of these tests is:
+/// 1. FLUTTER_ROOT environment variable contains the path.
+/// 2. Platform script is a data URI scheme, returning `../..` to support
+/// tests run from `packages/flutter_tools`.
+/// 3. Platform script is package URI scheme, returning the grandparent directory
+/// of the package config file location from `packages/flutter_tools/.packages`.
+/// 4. Platform script file path is the snapshot path generated by `bin/flutter`,
+/// returning the grandparent directory from `bin/cache`.
+/// 5. Platform script file name is the entrypoint in `packages/flutter_tools/bin/flutter_tools.dart`,
+/// returning the 4th parent directory.
+/// 6. The current directory
+///
+/// If an exception is thrown during any of these checks, an error message is
+/// printed and `.` is returned by default (6).
+String defaultFlutterRoot({
+ required FileSystem fileSystem,
+}) {
+ const String kFlutterRootEnvironmentVariableName =
+ 'FLUTTER_ROOT'; // should point to //flutter/ (root of flutter/flutter repo)
+ const String kSnapshotFileName =
+ 'flutter_tools.snapshot'; // in //flutter/bin/cache/
+ const String kFlutterToolsScriptFileName =
+ 'flutter_tools.dart'; // in //flutter/packages/flutter_tools/bin/
+ String normalize(String path) {
+ return fileSystem.path.normalize(fileSystem.path.absolute(path));
+ }
+
+ if (Platform.environment.containsKey(kFlutterRootEnvironmentVariableName)) {
+ return normalize(
+ Platform.environment[kFlutterRootEnvironmentVariableName]!);
+ }
+ try {
+ if (Platform.script.scheme == 'data') {
+ return normalize('../..'); // The tool is running as a test.
+ }
+ final String Function(String) dirname = fileSystem.path.dirname;
+
+ if (Platform.script.scheme == 'package') {
+ final String packageConfigPath =
+ Uri.parse(Platform.packageConfig!).toFilePath(
+ windows: isWindows,
+ );
+ return normalize(dirname(dirname(dirname(packageConfigPath))));
+ }
+
+ if (Platform.script.scheme == 'file') {
+ final String script = Platform.script.toFilePath(
+ windows: isWindows,
+ );
+ if (fileSystem.path.basename(script) == kSnapshotFileName) {
+ return normalize(dirname(dirname(fileSystem.path.dirname(script))));
+ }
+ if (fileSystem.path.basename(script) == kFlutterToolsScriptFileName) {
+ return normalize(dirname(dirname(dirname(dirname(script)))));
+ }
+ }
+ } on Exception catch (error) {
+ // There is currently no logger attached since this is computed at startup.
+ // ignore: avoid_print
+ print('$error');
+ }
+ return normalize('.');
+}
diff --git a/packages/flutter_migrate/lib/src/base/context.dart b/packages/flutter_migrate/lib/src/base/context.dart
new file mode 100644
index 0000000..ea1dd4d
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/context.dart
@@ -0,0 +1,199 @@
+// 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:collection';
+
+import 'package:meta/meta.dart';
+
+/// Generates an [AppContext] value.
+///
+/// Generators are allowed to return `null`, in which case the context will
+/// store the `null` value as the value for that type.
+typedef Generator = dynamic Function();
+
+/// An exception thrown by [AppContext] when you try to get a [Type] value from
+/// the context, and the instantiation of the value results in a dependency
+/// cycle.
+class ContextDependencyCycleException implements Exception {
+ ContextDependencyCycleException._(this.cycle);
+
+ /// The dependency cycle (last item depends on first item).
+ final List<Type> cycle;
+
+ @override
+ String toString() => 'Dependency cycle detected: ${cycle.join(' -> ')}';
+}
+
+/// The Zone key used to look up the [AppContext].
+@visibleForTesting
+const Object contextKey = _Key.key;
+
+/// The current [AppContext], as determined by the [Zone] hierarchy.
+///
+/// This will be the first context found as we scan up the zone hierarchy, or
+/// the "root" context if a context cannot be found in the hierarchy. The root
+/// context will not have any values associated with it.
+///
+/// This is guaranteed to never return `null`.
+AppContext get context =>
+ Zone.current[contextKey] as AppContext? ?? AppContext._root;
+
+/// A lookup table (mapping types to values) and an implied scope, in which
+/// code is run.
+///
+/// [AppContext] is used to define a singleton injection context for code that
+/// is run within it. Each time you call [run], a child context (and a new
+/// scope) is created.
+///
+/// Child contexts are created and run using zones. To read more about how
+/// zones work, see https://api.dart.dev/stable/dart-async/Zone-class.html.
+class AppContext {
+ AppContext._(
+ this._parent,
+ this.name, [
+ this._overrides = const <Type, Generator>{},
+ this._fallbacks = const <Type, Generator>{},
+ ]);
+
+ final String? name;
+ final AppContext? _parent;
+ final Map<Type, Generator> _overrides;
+ final Map<Type, Generator> _fallbacks;
+ final Map<Type, dynamic> _values = <Type, dynamic>{};
+
+ List<Type>? _reentrantChecks;
+
+ /// Bootstrap context.
+ static final AppContext _root = AppContext._(null, 'ROOT');
+
+ dynamic _boxNull(dynamic value) => value ?? _BoxedNull.instance;
+
+ dynamic _unboxNull(dynamic value) =>
+ value == _BoxedNull.instance ? null : value;
+
+ /// Returns the generated value for [type] if such a generator exists.
+ ///
+ /// If [generators] does not contain a mapping for the specified [type], this
+ /// returns `null`.
+ ///
+ /// If a generator existed and generated a `null` value, this will return a
+ /// boxed value indicating null.
+ ///
+ /// If a value for [type] has already been generated by this context, the
+ /// existing value will be returned, and the generator will not be invoked.
+ ///
+ /// If the generator ends up triggering a reentrant call, it signals a
+ /// dependency cycle, and a [ContextDependencyCycleException] will be thrown.
+ dynamic _generateIfNecessary(Type type, Map<Type, Generator> generators) {
+ if (!generators.containsKey(type)) {
+ return null;
+ }
+
+ return _values.putIfAbsent(type, () {
+ _reentrantChecks ??= <Type>[];
+
+ final int index = _reentrantChecks!.indexOf(type);
+ if (index >= 0) {
+ // We're already in the process of trying to generate this type.
+ throw ContextDependencyCycleException._(
+ UnmodifiableListView<Type>(_reentrantChecks!.sublist(index)));
+ }
+
+ _reentrantChecks!.add(type);
+ try {
+ return _boxNull(generators[type]!());
+ } finally {
+ _reentrantChecks!.removeLast();
+ if (_reentrantChecks!.isEmpty) {
+ _reentrantChecks = null;
+ }
+ }
+ });
+ }
+
+ /// Gets the value associated with the specified [type], or `null` if no
+ /// such value has been associated.
+ T? get<T>() {
+ dynamic value = _generateIfNecessary(T, _overrides);
+ if (value == null && _parent != null) {
+ value = _parent!.get<T>();
+ }
+ return _unboxNull(value ?? _generateIfNecessary(T, _fallbacks)) as T?;
+ }
+
+ /// Runs [body] in a child context and returns the value returned by [body].
+ ///
+ /// If [overrides] is specified, the child context will return corresponding
+ /// values when consulted via [operator[]].
+ ///
+ /// If [fallbacks] is specified, the child context will return corresponding
+ /// values when consulted via [operator[]] only if its parent context didn't
+ /// return such a value.
+ ///
+ /// If [name] is specified, the child context will be assigned the given
+ /// name. This is useful for debugging purposes and is analogous to naming a
+ /// thread in Java.
+ Future<V> run<V>({
+ required FutureOr<V> Function() body,
+ String? name,
+ Map<Type, Generator>? overrides,
+ Map<Type, Generator>? fallbacks,
+ ZoneSpecification? zoneSpecification,
+ }) async {
+ final AppContext child = AppContext._(
+ this,
+ name,
+ Map<Type, Generator>.unmodifiable(overrides ?? const <Type, Generator>{}),
+ Map<Type, Generator>.unmodifiable(fallbacks ?? const <Type, Generator>{}),
+ );
+ return runZoned<Future<V>>(
+ () async => await body(),
+ zoneValues: <_Key, AppContext>{_Key.key: child},
+ zoneSpecification: zoneSpecification,
+ );
+ }
+
+ @override
+ String toString() {
+ final StringBuffer buf = StringBuffer();
+ String indent = '';
+ AppContext? ctx = this;
+ while (ctx != null) {
+ buf.write('AppContext');
+ if (ctx.name != null) {
+ buf.write('[${ctx.name}]');
+ }
+ if (ctx._overrides.isNotEmpty) {
+ buf.write('\n$indent overrides: [${ctx._overrides.keys.join(', ')}]');
+ }
+ if (ctx._fallbacks.isNotEmpty) {
+ buf.write('\n$indent fallbacks: [${ctx._fallbacks.keys.join(', ')}]');
+ }
+ if (ctx._parent != null) {
+ buf.write('\n$indent parent: ');
+ }
+ ctx = ctx._parent;
+ indent += ' ';
+ }
+ return buf.toString();
+ }
+}
+
+/// Private key used to store the [AppContext] in the [Zone].
+class _Key {
+ const _Key();
+
+ static const _Key key = _Key();
+
+ @override
+ String toString() => 'context';
+}
+
+/// Private object that denotes a generated `null` value.
+class _BoxedNull {
+ const _BoxedNull();
+
+ static const _BoxedNull instance = _BoxedNull();
+}
diff --git a/packages/flutter_migrate/lib/src/base/file_system.dart b/packages/flutter_migrate/lib/src/base/file_system.dart
new file mode 100644
index 0000000..ee5eaf8
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/file_system.dart
@@ -0,0 +1,178 @@
+// 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 'package:file/file.dart';
+import 'package:file/local.dart' as local_fs;
+import 'package:meta/meta.dart';
+
+import 'common.dart';
+import 'io.dart';
+import 'logger.dart';
+import 'signals.dart';
+
+// package:file/local.dart must not be exported. This exposes LocalFileSystem,
+// which we override to ensure that temporary directories are cleaned up when
+// the tool is killed by a signal.
+export 'package:file/file.dart';
+
+/// Exception indicating that a file that was expected to exist was not found.
+class FileNotFoundException implements IOException {
+ const FileNotFoundException(this.path);
+
+ final String path;
+
+ @override
+ String toString() => 'File not found: $path';
+}
+
+/// Return a relative path if [fullPath] is contained by the cwd, else return an
+/// absolute path.
+String getDisplayPath(String fullPath, FileSystem fileSystem) {
+ final String cwd =
+ fileSystem.currentDirectory.path + fileSystem.path.separator;
+ return fullPath.startsWith(cwd) ? fullPath.substring(cwd.length) : fullPath;
+}
+
+/// This class extends [local_fs.LocalFileSystem] in order to clean up
+/// directories and files that the tool creates under the system temporary
+/// directory when the tool exits either normally or when killed by a signal.
+class LocalFileSystem extends local_fs.LocalFileSystem {
+ LocalFileSystem(this._signals, this._fatalSignals, this.shutdownHooks);
+
+ @visibleForTesting
+ LocalFileSystem.test({
+ required Signals signals,
+ List<ProcessSignal> fatalSignals = Signals.defaultExitSignals,
+ }) : this(signals, fatalSignals, ShutdownHooks());
+
+ Directory? _systemTemp;
+ final Map<ProcessSignal, Object> _signalTokens = <ProcessSignal, Object>{};
+
+ final ShutdownHooks shutdownHooks;
+
+ Future<void> dispose() async {
+ _tryToDeleteTemp();
+ for (final MapEntry<ProcessSignal, Object> signalToken
+ in _signalTokens.entries) {
+ await _signals.removeHandler(signalToken.key, signalToken.value);
+ }
+ _signalTokens.clear();
+ }
+
+ final Signals _signals;
+ final List<ProcessSignal> _fatalSignals;
+
+ void _tryToDeleteTemp() {
+ try {
+ if (_systemTemp?.existsSync() ?? false) {
+ _systemTemp?.deleteSync(recursive: true);
+ }
+ } on FileSystemException {
+ // ignore
+ }
+ _systemTemp = null;
+ }
+
+ // This getter returns a fresh entry under /tmp, like
+ // /tmp/flutter_tools.abcxyz, then the rest of the tool creates /tmp entries
+ // under that, like /tmp/flutter_tools.abcxyz/flutter_build_stuff.123456.
+ // Right before exiting because of a signal or otherwise, we delete
+ // /tmp/flutter_tools.abcxyz, not the whole of /tmp.
+ @override
+ Directory get systemTempDirectory {
+ if (_systemTemp == null) {
+ if (!superSystemTempDirectory.existsSync()) {
+ throwToolExit(
+ 'Your system temp directory (${superSystemTempDirectory.path}) does not exist. '
+ 'Did you set an invalid override in your environment? See issue https://github.com/flutter/flutter/issues/74042 for more context.');
+ }
+ _systemTemp = superSystemTempDirectory.createTempSync('flutter_tools.')
+ ..createSync(recursive: true);
+ // Make sure that the temporary directory is cleaned up if the tool is
+ // killed by a signal.
+ for (final ProcessSignal signal in _fatalSignals) {
+ final Object token = _signals.addHandler(
+ signal,
+ (ProcessSignal _) {
+ _tryToDeleteTemp();
+ },
+ );
+ _signalTokens[signal] = token;
+ }
+ // Make sure that the temporary directory is cleaned up when the tool
+ // exits normally.
+ shutdownHooks.addShutdownHook(
+ _tryToDeleteTemp,
+ );
+ }
+ return _systemTemp!;
+ }
+
+ // This only exist because the memory file system does not support a systemTemp that does not exists #74042
+ @visibleForTesting
+ Directory get superSystemTempDirectory => super.systemTempDirectory;
+}
+
+/// A function that will be run before the VM exits.
+typedef ShutdownHook = FutureOr<void> Function();
+
+abstract class ShutdownHooks {
+ factory ShutdownHooks() => _DefaultShutdownHooks();
+
+ /// Registers a [ShutdownHook] to be executed before the VM exits.
+ void addShutdownHook(ShutdownHook shutdownHook);
+
+ @visibleForTesting
+ List<ShutdownHook> get registeredHooks;
+
+ /// Runs all registered shutdown hooks and returns a future that completes when
+ /// all such hooks have finished.
+ ///
+ /// Shutdown hooks will be run in groups by their [ShutdownStage]. All shutdown
+ /// hooks within a given stage will be started in parallel and will be
+ /// guaranteed to run to completion before shutdown hooks in the next stage are
+ /// started.
+ ///
+ /// This class is constructed before the [Logger], so it cannot be direct
+ /// injected in the constructor.
+ Future<void> runShutdownHooks(Logger logger);
+}
+
+class _DefaultShutdownHooks implements ShutdownHooks {
+ _DefaultShutdownHooks();
+
+ @override
+ final List<ShutdownHook> registeredHooks = <ShutdownHook>[];
+
+ bool _shutdownHooksRunning = false;
+
+ @override
+ void addShutdownHook(ShutdownHook shutdownHook) {
+ assert(!_shutdownHooksRunning);
+ registeredHooks.add(shutdownHook);
+ }
+
+ @override
+ Future<void> runShutdownHooks(Logger logger) async {
+ logger.printTrace(
+ 'Running ${registeredHooks.length} shutdown hook${registeredHooks.length == 1 ? '' : 's'}',
+ );
+ _shutdownHooksRunning = true;
+ try {
+ final List<Future<dynamic>> futures = <Future<dynamic>>[];
+ for (final ShutdownHook shutdownHook in registeredHooks) {
+ final FutureOr<dynamic> result = shutdownHook();
+ if (result is Future<dynamic>) {
+ futures.add(result);
+ }
+ }
+ await Future.wait<dynamic>(futures);
+ } finally {
+ _shutdownHooksRunning = false;
+ }
+ logger.printTrace('Shutdown hooks complete');
+ }
+}
diff --git a/packages/flutter_migrate/lib/src/base/io.dart b/packages/flutter_migrate/lib/src/base/io.dart
new file mode 100644
index 0000000..8ae2813
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/io.dart
@@ -0,0 +1,340 @@
+// 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.
+
+/// This file serves as the single point of entry into the `dart:io` APIs
+/// within Flutter tools.
+///
+/// In order to make Flutter tools more testable, we use the `FileSystem` APIs
+/// in `package:file` rather than using the `dart:io` file APIs directly (see
+/// `file_system.dart`). Doing so allows us to swap out local file system
+/// access with mockable (or in-memory) file systems, making our tests hermetic
+/// vis-a-vis file system access.
+///
+/// We also use `package:platform` to provide an abstraction away from the
+/// static methods in the `dart:io` `Platform` class (see `platform.dart`). As
+/// such, do not export Platform from this file!
+///
+/// To ensure that all file system and platform API access within Flutter tools
+/// goes through the proper APIs, we forbid direct imports of `dart:io` (via a
+/// test), forcing all callers to instead import this file, which exports the
+/// blessed subset of `dart:io` that is legal to use in Flutter tools.
+///
+/// Because of the nature of this file, it is important that **platform and file
+/// APIs not be exported from `dart:io` in this file**! Moreover, be careful
+/// about any additional exports that you add to this file, as doing so will
+/// increase the API surface that we have to test in Flutter tools, and the APIs
+/// in `dart:io` can sometimes be hard to use in tests.
+
+// We allow `print()` in this file as a fallback for writing to the terminal via
+// regular stdout/stderr/stdio paths. Everything else in the flutter_tools
+// library should route terminal I/O through the [Stdio] class defined below.
+// ignore_for_file: avoid_print
+
+import 'dart:async';
+import 'dart:io' as io
+ show
+ IOSink,
+ Process,
+ ProcessSignal,
+ Stdin,
+ StdinException,
+ Stdout,
+ StdoutException,
+ stderr,
+ stdin,
+ stdout;
+
+import 'package:meta/meta.dart';
+
+import 'common.dart';
+
+export 'dart:io'
+ show
+ BytesBuilder,
+ CompressionOptions,
+ // Directory, NO! Use `file_system.dart`
+ // File, NO! Use `file_system.dart`
+ // FileSystemEntity, NO! Use `file_system.dart`
+ GZipCodec,
+ HandshakeException,
+ HttpClient,
+ HttpClientRequest,
+ HttpClientResponse,
+ HttpClientResponseCompressionState,
+ HttpException,
+ HttpHeaders,
+ HttpRequest,
+ HttpResponse,
+ HttpServer,
+ HttpStatus,
+ IOException,
+ IOSink,
+ InternetAddress,
+ InternetAddressType,
+ // Link NO! Use `file_system.dart`
+ // NetworkInterface NO! Use `io.dart`
+ OSError,
+ Platform,
+ Process,
+ ProcessException,
+ // ProcessInfo, NO! use `io.dart`
+ ProcessResult,
+ // ProcessSignal NO! Use [ProcessSignal] below.
+ ProcessStartMode,
+ // RandomAccessFile NO! Use `file_system.dart`
+ ServerSocket,
+ SignalException,
+ Socket,
+ SocketException,
+ Stdin,
+ StdinException,
+ Stdout,
+ WebSocket,
+ WebSocketException,
+ WebSocketTransformer,
+ ZLibEncoder,
+ exitCode,
+ gzip,
+ pid,
+ // stderr, NO! Use `io.dart`
+ // stdin, NO! Use `io.dart`
+ // stdout, NO! Use `io.dart`
+ systemEncoding;
+
+/// A class that wraps stdout, stderr, and stdin, and exposes the allowed
+/// operations.
+///
+/// In particular, there are three ways that writing to stdout and stderr
+/// can fail. A call to stdout.write() can fail:
+/// * by throwing a regular synchronous exception,
+/// * by throwing an exception asynchronously, and
+/// * by completing the Future stdout.done with an error.
+///
+/// This class enapsulates all three so that we don't have to worry about it
+/// anywhere else.
+class Stdio {
+ Stdio();
+
+ /// Tests can provide overrides to use instead of the stdout and stderr from
+ /// dart:io.
+ @visibleForTesting
+ Stdio.test({
+ required io.Stdout stdout,
+ required io.IOSink stderr,
+ }) : _stdoutOverride = stdout,
+ _stderrOverride = stderr;
+
+ io.Stdout? _stdoutOverride;
+ io.IOSink? _stderrOverride;
+
+ // These flags exist to remember when the done Futures on stdout and stderr
+ // complete to avoid trying to write to a closed stream sink, which would
+ // generate a [StateError].
+ bool _stdoutDone = false;
+ bool _stderrDone = false;
+
+ Stream<List<int>> get stdin => io.stdin;
+
+ io.Stdout get stdout {
+ if (_stdout != null) {
+ return _stdout!;
+ }
+ _stdout = _stdoutOverride ?? io.stdout;
+ _stdout!.done.then(
+ (void _) {
+ _stdoutDone = true;
+ },
+ onError: (Object err, StackTrace st) {
+ _stdoutDone = true;
+ },
+ );
+ return _stdout!;
+ }
+
+ io.Stdout? _stdout;
+
+ @visibleForTesting
+ io.IOSink get stderr {
+ if (_stderr != null) {
+ return _stderr!;
+ }
+ _stderr = _stderrOverride ?? io.stderr;
+ _stderr!.done.then(
+ (void _) {
+ _stderrDone = true;
+ },
+ onError: (Object err, StackTrace st) {
+ _stderrDone = true;
+ },
+ );
+ return _stderr!;
+ }
+
+ io.IOSink? _stderr;
+
+ bool get hasTerminal => io.stdout.hasTerminal;
+
+ static bool? _stdinHasTerminal;
+
+ /// Determines whether there is a terminal attached.
+ ///
+ /// [io.Stdin.hasTerminal] only covers a subset of cases. In this check the
+ /// echoMode is toggled on and off to catch cases where the tool running in
+ /// a docker container thinks there is an attached terminal. This can cause
+ /// runtime errors such as "inappropriate ioctl for device" if not handled.
+ bool get stdinHasTerminal {
+ if (_stdinHasTerminal != null) {
+ return _stdinHasTerminal!;
+ }
+ if (stdin is! io.Stdin) {
+ return _stdinHasTerminal = false;
+ }
+ final io.Stdin ioStdin = stdin as io.Stdin;
+ if (!ioStdin.hasTerminal) {
+ return _stdinHasTerminal = false;
+ }
+ try {
+ final bool currentEchoMode = ioStdin.echoMode;
+ ioStdin.echoMode = !currentEchoMode;
+ ioStdin.echoMode = currentEchoMode;
+ } on io.StdinException {
+ return _stdinHasTerminal = false;
+ }
+ return _stdinHasTerminal = true;
+ }
+
+ int? get terminalColumns => hasTerminal ? stdout.terminalColumns : null;
+ int? get terminalLines => hasTerminal ? stdout.terminalLines : null;
+ bool get supportsAnsiEscapes => hasTerminal && stdout.supportsAnsiEscapes;
+
+ /// Writes [message] to [stderr], falling back on [fallback] if the write
+ /// throws any exception. The default fallback calls [print] on [message].
+ void stderrWrite(
+ String message, {
+ void Function(String, dynamic, StackTrace)? fallback,
+ }) {
+ if (!_stderrDone) {
+ _stdioWrite(stderr, message, fallback: fallback);
+ return;
+ }
+ fallback == null
+ ? print(message)
+ : fallback(
+ message,
+ const io.StdoutException('stderr is done'),
+ StackTrace.current,
+ );
+ }
+
+ /// Writes [message] to [stdout], falling back on [fallback] if the write
+ /// throws any exception. The default fallback calls [print] on [message].
+ void stdoutWrite(
+ String message, {
+ void Function(String, dynamic, StackTrace)? fallback,
+ }) {
+ if (!_stdoutDone) {
+ _stdioWrite(stdout, message, fallback: fallback);
+ return;
+ }
+ fallback == null
+ ? print(message)
+ : fallback(
+ message,
+ const io.StdoutException('stdout is done'),
+ StackTrace.current,
+ );
+ }
+
+ // Helper for [stderrWrite] and [stdoutWrite].
+ void _stdioWrite(
+ io.IOSink sink,
+ String message, {
+ void Function(String, dynamic, StackTrace)? fallback,
+ }) {
+ asyncGuard<void>(() async {
+ sink.write(message);
+ }, onError: (Object error, StackTrace stackTrace) {
+ if (fallback == null) {
+ print(message);
+ } else {
+ fallback(message, error, stackTrace);
+ }
+ });
+ }
+
+ /// Adds [stream] to [stdout].
+ Future<void> addStdoutStream(Stream<List<int>> stream) =>
+ stdout.addStream(stream);
+
+ /// Adds [stream] to [stderr].
+ Future<void> addStderrStream(Stream<List<int>> stream) =>
+ stderr.addStream(stream);
+}
+
+/// A portable version of [io.ProcessSignal].
+///
+/// Listening on signals that don't exist on the current platform is just a
+/// no-op. This is in contrast to [io.ProcessSignal], where listening to
+/// non-existent signals throws an exception.
+///
+/// This class does NOT implement io.ProcessSignal, because that class uses
+/// private fields. This means it cannot be used with, e.g., [Process.killPid].
+/// Alternative implementations of the relevant methods that take
+/// [ProcessSignal] instances are available on this class (e.g. "send").
+class ProcessSignal {
+ @visibleForTesting
+ const ProcessSignal(this._delegate);
+
+ static const ProcessSignal sigwinch =
+ PosixProcessSignal(io.ProcessSignal.sigwinch);
+ static const ProcessSignal sigterm =
+ PosixProcessSignal(io.ProcessSignal.sigterm);
+ static const ProcessSignal sigusr1 =
+ PosixProcessSignal(io.ProcessSignal.sigusr1);
+ static const ProcessSignal sigusr2 =
+ PosixProcessSignal(io.ProcessSignal.sigusr2);
+ static const ProcessSignal sigint = ProcessSignal(io.ProcessSignal.sigint);
+ static const ProcessSignal sigkill = ProcessSignal(io.ProcessSignal.sigkill);
+
+ final io.ProcessSignal _delegate;
+
+ Stream<ProcessSignal> watch() {
+ return _delegate
+ .watch()
+ .map<ProcessSignal>((io.ProcessSignal signal) => this);
+ }
+
+ /// Sends the signal to the given process (identified by pid).
+ ///
+ /// Returns true if the signal was delivered, false otherwise.
+ ///
+ /// On Windows, this can only be used with [ProcessSignal.sigterm], which
+ /// terminates the process.
+ ///
+ /// This is implemented by sending the signal using [Process.killPid].
+ bool send(int pid) {
+ assert(!isWindows || this == ProcessSignal.sigterm);
+ return io.Process.killPid(pid, _delegate);
+ }
+
+ @override
+ String toString() => _delegate.toString();
+}
+
+/// A [ProcessSignal] that is only available on Posix platforms.
+///
+/// Listening to a [_PosixProcessSignal] is a no-op on Windows.
+@visibleForTesting
+class PosixProcessSignal extends ProcessSignal {
+ const PosixProcessSignal(super.wrappedSignal);
+
+ @override
+ Stream<ProcessSignal> watch() {
+ // This uses the real platform since it invokes dart:io functionality directly.
+ if (isWindows) {
+ return const Stream<ProcessSignal>.empty();
+ }
+ return super.watch();
+ }
+}
diff --git a/packages/flutter_migrate/lib/src/base/logger.dart b/packages/flutter_migrate/lib/src/base/logger.dart
new file mode 100644
index 0000000..c84f098
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/logger.dart
@@ -0,0 +1,1395 @@
+// 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:io';
+import 'dart:math' as math;
+import 'dart:math';
+
+import 'package:intl/intl.dart';
+import 'package:meta/meta.dart';
+
+import 'common.dart';
+import 'io.dart';
+import 'terminal.dart' show OutputPreferences, Terminal, TerminalColor;
+
+const int kDefaultStatusPadding = 59;
+final NumberFormat kSecondsFormat = NumberFormat('0.0');
+final NumberFormat kMillisecondsFormat = NumberFormat.decimalPattern();
+
+/// Smallest column that will be used for text wrapping. If the requested column
+/// width is smaller than this, then this is what will be used.
+const int kMinColumnWidth = 10;
+
+/// A factory for generating [Stopwatch] instances for [Status] instances.
+class StopwatchFactory {
+ /// const constructor so that subclasses may be const.
+ const StopwatchFactory();
+
+ /// Create a new [Stopwatch] instance.
+ ///
+ /// The optional [name] parameter is useful in tests when there are multiple
+ /// instances being created.
+ Stopwatch createStopwatch([String name = '']) => Stopwatch();
+}
+
+typedef VoidCallback = void Function();
+
+abstract class Logger {
+ /// Whether or not this logger should print [printTrace] messages.
+ bool get isVerbose => false;
+
+ /// If true, silences the logger output.
+ bool quiet = false;
+
+ /// If true, this logger supports color output.
+ bool get supportsColor;
+
+ /// If true, this logger is connected to a terminal.
+ bool get hasTerminal;
+
+ /// If true, then [printError] has been called at least once for this logger
+ /// since the last time it was set to false.
+ bool hadErrorOutput = false;
+
+ /// If true, then [printWarning] has been called at least once for this logger
+ /// since the last time it was reset to false.
+ bool hadWarningOutput = false;
+
+ /// Causes [checkForFatalLogs] to call [throwToolExit] when it is called if
+ /// [hadWarningOutput] is true.
+ bool fatalWarnings = false;
+
+ /// Returns the terminal attached to this logger.
+ Terminal get terminal;
+
+ /// Display an error `message` to the user. Commands should use this if they
+ /// fail in some way. Errors are typically followed shortly by a call to
+ /// [throwToolExit] to terminate the run.
+ ///
+ /// The `message` argument is printed to the stderr in [TerminalColor.red] by
+ /// default.
+ ///
+ /// The `stackTrace` argument is the stack trace that will be printed if
+ /// supplied.
+ ///
+ /// The `emphasis` argument will cause the output message be printed in bold text.
+ ///
+ /// The `color` argument will print the message in the supplied color instead
+ /// of the default of red. Colors will not be printed if the output terminal
+ /// doesn't support them.
+ ///
+ /// The `indent` argument specifies the number of spaces to indent the overall
+ /// message. If wrapping is enabled in [outputPreferences], then the wrapped
+ /// lines will be indented as well.
+ ///
+ /// If `hangingIndent` is specified, then any wrapped lines will be indented
+ /// by this much more than the first line, if wrapping is enabled in
+ /// [outputPreferences].
+ ///
+ /// If `wrap` is specified, then it overrides the
+ /// `outputPreferences.wrapText` setting.
+ void printError(
+ String message, {
+ StackTrace? stackTrace,
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ });
+
+ /// Display a warning `message` to the user. Commands should use this if they
+ /// important information to convey to the user that is not fatal.
+ ///
+ /// The `message` argument is printed to the stderr in [TerminalColor.cyan] by
+ /// default.
+ ///
+ /// The `emphasis` argument will cause the output message be printed in bold text.
+ ///
+ /// The `color` argument will print the message in the supplied color instead
+ /// of the default of cyan. Colors will not be printed if the output terminal
+ /// doesn't support them.
+ ///
+ /// The `indent` argument specifies the number of spaces to indent the overall
+ /// message. If wrapping is enabled in [outputPreferences], then the wrapped
+ /// lines will be indented as well.
+ ///
+ /// If `hangingIndent` is specified, then any wrapped lines will be indented
+ /// by this much more than the first line, if wrapping is enabled in
+ /// [outputPreferences].
+ ///
+ /// If `wrap` is specified, then it overrides the
+ /// `outputPreferences.wrapText` setting.
+ void printWarning(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ });
+
+ /// Display normal output of the command. This should be used for things like
+ /// progress messages, success messages, or just normal command output.
+ ///
+ /// The `message` argument is printed to the stdout.
+ ///
+ /// The `stackTrace` argument is the stack trace that will be printed if
+ /// supplied.
+ ///
+ /// If the `emphasis` argument is true, it will cause the output message be
+ /// printed in bold text. Defaults to false.
+ ///
+ /// The `color` argument will print the message in the supplied color instead
+ /// of the default of red. Colors will not be printed if the output terminal
+ /// doesn't support them.
+ ///
+ /// If `newline` is true, then a newline will be added after printing the
+ /// status. Defaults to true.
+ ///
+ /// The `indent` argument specifies the number of spaces to indent the overall
+ /// message. If wrapping is enabled in [outputPreferences], then the wrapped
+ /// lines will be indented as well.
+ ///
+ /// If `hangingIndent` is specified, then any wrapped lines will be indented
+ /// by this much more than the first line, if wrapping is enabled in
+ /// [outputPreferences].
+ ///
+ /// If `wrap` is specified, then it overrides the
+ /// `outputPreferences.wrapText` setting.
+ void printStatus(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ bool? newline,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ });
+
+ /// Display the [message] inside a box.
+ ///
+ /// For example, this is the generated output:
+ ///
+ /// ┌─ [title] ─┐
+ /// │ [message] │
+ /// └───────────┘
+ ///
+ /// If a terminal is attached, the lines in [message] are automatically wrapped based on
+ /// the available columns.
+ ///
+ /// Use this utility only to highlight a message in the logs.
+ ///
+ /// This is particularly useful when the message can be easily missed because of clutter
+ /// generated by other commands invoked by the tool.
+ ///
+ /// One common use case is to provide actionable steps in a Flutter app when a Gradle
+ /// error is printed.
+ ///
+ /// In the future, this output can be integrated with an IDE like VS Code to display a
+ /// notification, and allow the user to trigger an action. e.g. run a migration.
+ void printBox(
+ String message, {
+ String? title,
+ });
+
+ /// Use this for verbose tracing output. Users can turn this output on in order
+ /// to help diagnose issues with the toolchain or with their setup.
+ void printTrace(String message);
+
+ /// Start an indeterminate progress display.
+ ///
+ /// The `message` argument is the message to display to the user.
+ ///
+ /// The `progressId` argument provides an ID that can be used to identify
+ /// this type of progress (e.g. `hot.reload`, `hot.restart`).
+ ///
+ /// The `progressIndicatorPadding` can optionally be used to specify the width
+ /// of the space into which the `message` is placed before the progress
+ /// indicator, if any. It is ignored if the message is longer.
+ Status startProgress(
+ String message, {
+ String? progressId,
+ int progressIndicatorPadding = kDefaultStatusPadding,
+ });
+
+ /// A [SilentStatus] or an [AnonymousSpinnerStatus] (depending on whether the
+ /// terminal is fancy enough), already started.
+ Status startSpinner({
+ VoidCallback? onFinish,
+ Duration? timeout,
+ SlowWarningCallback? slowWarningCallback,
+ });
+
+ /// Clears all output.
+ void clear();
+
+ /// If [fatalWarnings] is set, causes the logger to check if
+ /// [hadWarningOutput] is true, and then to call [throwToolExit] if so.
+ ///
+ /// The [fatalWarnings] flag can be set from the command line with the
+ /// "--fatal-warnings" option on commands that support it.
+ void checkForFatalLogs() {
+ if (fatalWarnings && (hadWarningOutput || hadErrorOutput)) {
+ throwToolExit(
+ 'Logger received ${hadErrorOutput ? 'error' : 'warning'} output '
+ 'during the run, and "--fatal-warnings" is enabled.');
+ }
+ }
+}
+
+class StdoutLogger extends Logger {
+ StdoutLogger({
+ required this.terminal,
+ required Stdio stdio,
+ required OutputPreferences outputPreferences,
+ StopwatchFactory stopwatchFactory = const StopwatchFactory(),
+ }) : _stdio = stdio,
+ _outputPreferences = outputPreferences,
+ _stopwatchFactory = stopwatchFactory;
+
+ @override
+ final Terminal terminal;
+ final OutputPreferences _outputPreferences;
+ final Stdio _stdio;
+ final StopwatchFactory _stopwatchFactory;
+
+ Status? _status;
+
+ @override
+ bool get isVerbose => false;
+
+ @override
+ bool get supportsColor => terminal.supportsColor;
+
+ @override
+ bool get hasTerminal => _stdio.stdinHasTerminal;
+
+ @override
+ void printError(
+ String message, {
+ StackTrace? stackTrace,
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ hadErrorOutput = true;
+ _status?.pause();
+ message = wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ );
+ if (emphasis ?? false) {
+ message = terminal.bolden(message);
+ }
+ message = terminal.color(message, color ?? TerminalColor.red);
+ writeToStdErr('$message\n');
+ if (stackTrace != null) {
+ writeToStdErr('$stackTrace\n');
+ }
+ _status?.resume();
+ }
+
+ @override
+ void printWarning(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ hadWarningOutput = true;
+ _status?.pause();
+ message = wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ );
+ if (emphasis ?? false) {
+ message = terminal.bolden(message);
+ }
+ message = terminal.color(message, color ?? TerminalColor.cyan);
+ writeToStdErr('$message\n');
+ _status?.resume();
+ }
+
+ @override
+ void printStatus(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ bool? newline,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ _status?.pause();
+ message = wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ );
+ if (emphasis ?? false) {
+ message = terminal.bolden(message);
+ }
+ if (color != null) {
+ message = terminal.color(message, color);
+ }
+ if (newline ?? true) {
+ message = '$message\n';
+ }
+ writeToStdOut(message);
+ _status?.resume();
+ }
+
+ @override
+ void printBox(
+ String message, {
+ String? title,
+ }) {
+ _status?.pause();
+ _generateBox(
+ title: title,
+ message: message,
+ wrapColumn: _outputPreferences.wrapColumn,
+ terminal: terminal,
+ write: writeToStdOut,
+ );
+ _status?.resume();
+ }
+
+ @protected
+ void writeToStdOut(String message) => _stdio.stdoutWrite(message);
+
+ @protected
+ void writeToStdErr(String message) => _stdio.stderrWrite(message);
+
+ @override
+ void printTrace(String message) {}
+
+ @override
+ Status startProgress(
+ String message, {
+ String? progressId,
+ int progressIndicatorPadding = kDefaultStatusPadding,
+ }) {
+ if (_status != null) {
+ // Ignore nested progresses; return a no-op status object.
+ return SilentStatus(
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ )..start();
+ }
+ if (supportsColor) {
+ _status = SpinnerStatus(
+ message: message,
+ padding: progressIndicatorPadding,
+ onFinish: _clearStatus,
+ stdio: _stdio,
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ terminal: terminal,
+ )..start();
+ } else {
+ _status = SummaryStatus(
+ message: message,
+ padding: progressIndicatorPadding,
+ onFinish: _clearStatus,
+ stdio: _stdio,
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ )..start();
+ }
+ return _status!;
+ }
+
+ @override
+ Status startSpinner({
+ VoidCallback? onFinish,
+ Duration? timeout,
+ SlowWarningCallback? slowWarningCallback,
+ }) {
+ if (_status != null || !supportsColor) {
+ return SilentStatus(
+ onFinish: onFinish,
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ )..start();
+ }
+ _status = AnonymousSpinnerStatus(
+ onFinish: () {
+ if (onFinish != null) {
+ onFinish();
+ }
+ _clearStatus();
+ },
+ stdio: _stdio,
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ terminal: terminal,
+ timeout: timeout,
+ slowWarningCallback: slowWarningCallback,
+ )..start();
+ return _status!;
+ }
+
+ void _clearStatus() {
+ _status = null;
+ }
+
+ @override
+ void clear() {
+ _status?.pause();
+ writeToStdOut('${terminal.clearScreen()}\n');
+ _status?.resume();
+ }
+}
+
+/// A [StdoutLogger] which replaces Unicode characters that cannot be printed to
+/// the Windows console with alternative symbols.
+///
+/// By default, Windows uses either "Consolas" or "Lucida Console" as fonts to
+/// render text in the console. Both fonts only have a limited character set.
+/// Unicode characters, that are not available in either of the two default
+/// fonts, should be replaced by this class with printable symbols. Otherwise,
+/// they will show up as the unrepresentable character symbol '�'.
+class WindowsStdoutLogger extends StdoutLogger {
+ WindowsStdoutLogger({
+ required super.terminal,
+ required super.stdio,
+ required super.outputPreferences,
+ super.stopwatchFactory,
+ });
+
+ @override
+ void writeToStdOut(String message) {
+ final String windowsMessage = terminal.supportsEmoji
+ ? message
+ : message
+ .replaceAll('🔥', '')
+ .replaceAll('🖼️', '')
+ .replaceAll('✗', 'X')
+ .replaceAll('✓', '√')
+ .replaceAll('🔨', '')
+ .replaceAll('💪', '')
+ .replaceAll('⚠️', '!')
+ .replaceAll('✏️', '');
+ _stdio.stdoutWrite(windowsMessage);
+ }
+}
+
+typedef _Writter = void Function(String message);
+
+/// Wraps the message in a box, and writes the bytes by calling [write].
+///
+/// Example output:
+///
+/// ┌─ [title] ─┐
+/// │ [message] │
+/// └───────────┘
+///
+/// When [title] is provided, the box will have a title above it.
+///
+/// The box width never exceeds [wrapColumn].
+///
+/// If [wrapColumn] is not provided, the default value is 100.
+void _generateBox({
+ required String message,
+ required int wrapColumn,
+ required _Writter write,
+ required Terminal terminal,
+ String? title,
+}) {
+ const int kPaddingLeftRight = 1;
+ const int kEdges = 2;
+
+ final int maxTextWidthPerLine = wrapColumn - kEdges - kPaddingLeftRight * 2;
+ final List<String> lines =
+ wrapText(message, shouldWrap: true, columnWidth: maxTextWidthPerLine)
+ .split('\n');
+ final List<int> lineWidth =
+ lines.map((String line) => _getColumnSize(line)).toList();
+ final int maxColumnSize =
+ lineWidth.reduce((int currLen, int maxLen) => max(currLen, maxLen));
+ final int textWidth = min(maxColumnSize, maxTextWidthPerLine);
+ final int textWithPaddingWidth = textWidth + kPaddingLeftRight * 2;
+
+ write('\n');
+
+ // Write `┌─ [title] ─┐`.
+ write('┌');
+ write('─');
+ if (title == null) {
+ write('─' * (textWithPaddingWidth - 1));
+ } else {
+ write(' ${terminal.bolden(title)} ');
+ write('─' * (textWithPaddingWidth - title.length - 3));
+ }
+ write('┐');
+ write('\n');
+
+ // Write `│ [message] │`.
+ for (int lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+ write('│');
+ write(' ' * kPaddingLeftRight);
+ write(lines[lineIdx]);
+ final int remainingSpacesToEnd = textWidth - lineWidth[lineIdx];
+ write(' ' * (remainingSpacesToEnd + kPaddingLeftRight));
+ write('│');
+ write('\n');
+ }
+
+ // Write `└───────────┘`.
+ write('└');
+ write('─' * textWithPaddingWidth);
+ write('┘');
+ write('\n');
+}
+
+final RegExp _ansiEscapePattern =
+ RegExp('\x1B\\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]');
+
+int _getColumnSize(String line) {
+ // Remove ANSI escape characters from the string.
+ return line.replaceAll(_ansiEscapePattern, '').length;
+}
+
+class BufferLogger extends Logger {
+ BufferLogger({
+ required this.terminal,
+ required OutputPreferences outputPreferences,
+ StopwatchFactory stopwatchFactory = const StopwatchFactory(),
+ bool verbose = false,
+ }) : _outputPreferences = outputPreferences,
+ _stopwatchFactory = stopwatchFactory,
+ _verbose = verbose;
+
+ /// Create a [BufferLogger] with test preferences.
+ BufferLogger.test({
+ Terminal? terminal,
+ OutputPreferences? outputPreferences,
+ bool verbose = false,
+ }) : terminal = terminal ?? Terminal.test(),
+ _outputPreferences = outputPreferences ?? OutputPreferences.test(),
+ _stopwatchFactory = const StopwatchFactory(),
+ _verbose = verbose;
+
+ final OutputPreferences _outputPreferences;
+
+ @override
+ final Terminal terminal;
+
+ final StopwatchFactory _stopwatchFactory;
+
+ final bool _verbose;
+
+ @override
+ bool get isVerbose => _verbose;
+
+ @override
+ bool get supportsColor => terminal.supportsColor;
+
+ final StringBuffer _error = StringBuffer();
+ final StringBuffer _warning = StringBuffer();
+ final StringBuffer _status = StringBuffer();
+ final StringBuffer _trace = StringBuffer();
+ final StringBuffer _events = StringBuffer();
+
+ String get errorText => _error.toString();
+ String get warningText => _warning.toString();
+ String get statusText => _status.toString();
+ String get traceText => _trace.toString();
+ String get eventText => _events.toString();
+
+ @override
+ bool get hasTerminal => false;
+
+ @override
+ void printError(
+ String message, {
+ StackTrace? stackTrace,
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ hadErrorOutput = true;
+ _error.writeln(terminal.color(
+ wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ ),
+ color ?? TerminalColor.red,
+ ));
+ }
+
+ @override
+ void printWarning(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ hadWarningOutput = true;
+ _warning.writeln(terminal.color(
+ wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ ),
+ color ?? TerminalColor.cyan,
+ ));
+ }
+
+ @override
+ void printStatus(
+ String message, {
+ bool? emphasis,
+ TerminalColor? color,
+ bool? newline,
+ int? indent,
+ int? hangingIndent,
+ bool? wrap,
+ }) {
+ if (newline ?? true) {
+ _status.writeln(wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ ));
+ } else {
+ _status.write(wrapText(
+ message,
+ indent: indent,
+ hangingIndent: hangingIndent,
+ shouldWrap: wrap ?? _outputPreferences.wrapText,
+ columnWidth: _outputPreferences.wrapColumn,
+ ));
+ }
+ }
+
+ @override
+ void printBox(
+ String message, {
+ String? title,
+ }) {
+ _generateBox(
+ title: title,
+ message: message,
+ wrapColumn: _outputPreferences.wrapColumn,
+ terminal: terminal,
+ write: _status.write,
+ );
+ }
+
+ @override
+ void printTrace(String message) => _trace.writeln(message);
+
+ @override
+ Status startProgress(
+ String message, {
+ String? progressId,
+ int progressIndicatorPadding = kDefaultStatusPadding,
+ }) {
+ assert(progressIndicatorPadding != null);
+ printStatus(message);
+ return SilentStatus(
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ )..start();
+ }
+
+ @override
+ Status startSpinner({
+ VoidCallback? onFinish,
+ Duration? timeout,
+ SlowWarningCallback? slowWarningCallback,
+ }) {
+ return SilentStatus(
+ stopwatch: _stopwatchFactory.createStopwatch(),
+ onFinish: onFinish,
+ )..start();
+ }
+
+ @override
+ void clear() {
+ _error.clear();
+ _status.clear();
+ _trace.clear();
+ _events.clear();
+ }
+}
+
+typedef SlowWarningCallback = String Function();
+
+/// A [Status] class begins when start is called, and may produce progress
+/// information asynchronously.
+///
+/// The [SilentStatus] class never has any output.
+///
+/// The [SpinnerStatus] subclass shows a message with a spinner, and replaces it
+/// with timing information when stopped. When canceled, the information isn't
+/// shown. In either case, a newline is printed.
+///
+/// The [AnonymousSpinnerStatus] subclass just shows a spinner.
+///
+/// The [SummaryStatus] subclass shows only a static message (without an
+/// indicator), then updates it when the operation ends.
+///
+/// Generally, consider `logger.startProgress` instead of directly creating
+/// a [Status] or one of its subclasses.
+abstract class Status {
+ Status({
+ this.onFinish,
+ required Stopwatch stopwatch,
+ this.timeout,
+ }) : _stopwatch = stopwatch;
+
+ final VoidCallback? onFinish;
+ final Duration? timeout;
+
+ @protected
+ final Stopwatch _stopwatch;
+
+ @protected
+ String get elapsedTime {
+ if (_stopwatch.elapsed.inSeconds > 2) {
+ return _getElapsedAsSeconds(_stopwatch.elapsed);
+ }
+ return _getElapsedAsMilliseconds(_stopwatch.elapsed);
+ }
+
+ String _getElapsedAsSeconds(Duration duration) {
+ final double seconds =
+ duration.inMilliseconds / Duration.millisecondsPerSecond;
+ return '${kSecondsFormat.format(seconds)}s';
+ }
+
+ String _getElapsedAsMilliseconds(Duration duration) {
+ return '${kMillisecondsFormat.format(duration.inMilliseconds)}ms';
+ }
+
+ @visibleForTesting
+ bool get seemsSlow => timeout != null && _stopwatch.elapsed > timeout!;
+
+ /// Call to start spinning.
+ void start() {
+ assert(!_stopwatch.isRunning);
+ _stopwatch.start();
+ }
+
+ /// Call to stop spinning after success.
+ void stop() {
+ finish();
+ }
+
+ /// Call to cancel the spinner after failure or cancellation.
+ void cancel() {
+ finish();
+ }
+
+ /// Call to clear the current line but not end the progress.
+ void pause() {}
+
+ /// Call to resume after a pause.
+ void resume() {}
+
+ @protected
+ void finish() {
+ assert(_stopwatch.isRunning);
+ _stopwatch.stop();
+ onFinish?.call();
+ }
+}
+
+/// A [Status] that shows nothing.
+class SilentStatus extends Status {
+ SilentStatus({
+ required super.stopwatch,
+ super.onFinish,
+ });
+
+ @override
+ void finish() {
+ onFinish?.call();
+ }
+}
+
+/// Constructor writes [message] to [stdout]. On [cancel] or [stop], will call
+/// [onFinish]. On [stop], will additionally print out summary information.
+class SummaryStatus extends Status {
+ SummaryStatus({
+ this.message = '',
+ required super.stopwatch,
+ this.padding = kDefaultStatusPadding,
+ super.onFinish,
+ required Stdio stdio,
+ }) : _stdio = stdio;
+
+ final String message;
+ final int padding;
+ final Stdio _stdio;
+
+ bool _messageShowingOnCurrentLine = false;
+
+ @override
+ void start() {
+ _printMessage();
+ super.start();
+ }
+
+ void _writeToStdOut(String message) => _stdio.stdoutWrite(message);
+
+ void _printMessage() {
+ assert(!_messageShowingOnCurrentLine);
+ _writeToStdOut('${message.padRight(padding)} ');
+ _messageShowingOnCurrentLine = true;
+ }
+
+ @override
+ void stop() {
+ if (!_messageShowingOnCurrentLine) {
+ _printMessage();
+ }
+ super.stop();
+ assert(_messageShowingOnCurrentLine);
+ _writeToStdOut(elapsedTime.padLeft(_kTimePadding));
+ _writeToStdOut('\n');
+ }
+
+ @override
+ void cancel() {
+ super.cancel();
+ if (_messageShowingOnCurrentLine) {
+ _writeToStdOut('\n');
+ }
+ }
+
+ @override
+ void pause() {
+ super.pause();
+ if (_messageShowingOnCurrentLine) {
+ _writeToStdOut('\n');
+ _messageShowingOnCurrentLine = false;
+ }
+ }
+}
+
+const int _kTimePadding = 8; // should fit "99,999ms"
+
+/// A kind of animated [Status] that has no message.
+///
+/// Call [pause] before outputting any text while this is running.
+class AnonymousSpinnerStatus extends Status {
+ AnonymousSpinnerStatus({
+ super.onFinish,
+ required super.stopwatch,
+ required Stdio stdio,
+ required Terminal terminal,
+ this.slowWarningCallback,
+ super.timeout,
+ }) : _stdio = stdio,
+ _terminal = terminal,
+ _animation = _selectAnimation(terminal);
+
+ final Stdio _stdio;
+ final Terminal _terminal;
+ String _slowWarning = '';
+ final SlowWarningCallback? slowWarningCallback;
+
+ static const String _backspaceChar = '\b';
+ static const String _clearChar = ' ';
+
+ static const List<String> _emojiAnimations = <String>[
+ '⣾⣽⣻⢿⡿⣟⣯⣷', // counter-clockwise
+ '⣾⣷⣯⣟⡿⢿⣻⣽', // clockwise
+ '⣾⣷⣯⣟⡿⢿⣻⣽⣷⣾⣽⣻⢿⡿⣟⣯⣷', // bouncing clockwise and counter-clockwise
+ '⣾⣷⣯⣽⣻⣟⡿⢿⣻⣟⣯⣽', // snaking
+ '⣾⣽⣻⢿⣿⣷⣯⣟⡿⣿', // alternating rain
+ '⣀⣠⣤⣦⣶⣾⣿⡿⠿⠻⠛⠋⠉⠙⠛⠟⠿⢿⣿⣷⣶⣴⣤⣄', // crawl up and down, large
+ '⠙⠚⠖⠦⢤⣠⣄⡤⠴⠲⠓⠋', // crawl up and down, small
+ '⣀⡠⠤⠔⠒⠊⠉⠑⠒⠢⠤⢄', // crawl up and down, tiny
+ '⡀⣄⣦⢷⠻⠙⠈⠀⠁⠋⠟⡾⣴⣠⢀⠀', // slide up and down
+ '⠙⠸⢰⣠⣄⡆⠇⠋', // clockwise line
+ '⠁⠈⠐⠠⢀⡀⠄⠂', // clockwise dot
+ '⢇⢣⢱⡸⡜⡎', // vertical wobble up
+ '⡇⡎⡜⡸⢸⢱⢣⢇', // vertical wobble down
+ '⡀⣀⣐⣒⣖⣶⣾⣿⢿⠿⠯⠭⠩⠉⠁⠀', // swirl
+ '⠁⠐⠄⢀⢈⢂⢠⣀⣁⣐⣄⣌⣆⣤⣥⣴⣼⣶⣷⣿⣾⣶⣦⣤⣠⣀⡀⠀⠀', // snowing and melting
+ '⠁⠋⠞⡴⣠⢀⠀⠈⠙⠻⢷⣦⣄⡀⠀⠉⠛⠲⢤⢀⠀', // falling water
+ '⠄⡢⢑⠈⠀⢀⣠⣤⡶⠞⠋⠁⠀⠈⠙⠳⣆⡀⠀⠆⡷⣹⢈⠀⠐⠪⢅⡀⠀', // fireworks
+ '⠐⢐⢒⣒⣲⣶⣷⣿⡿⡷⡧⠧⠇⠃⠁⠀⡀⡠⡡⡱⣱⣳⣷⣿⢿⢯⢧⠧⠣⠃⠂⠀⠈⠨⠸⠺⡺⡾⡿⣿⡿⡷⡗⡇⡅⡄⠄⠀⡀⡐⣐⣒⣓⣳⣻⣿⣾⣼⡼⡸⡘⡈⠈⠀', // fade
+ '⢸⡯⠭⠅⢸⣇⣀⡀⢸⣇⣸⡇⠈⢹⡏⠁⠈⢹⡏⠁⢸⣯⣭⡅⢸⡯⢕⡂⠀⠀', // text crawl
+ ];
+
+ static const List<String> _asciiAnimations = <String>[
+ r'-\|/',
+ ];
+
+ static List<String> _selectAnimation(Terminal terminal) {
+ final List<String> animations =
+ terminal.supportsEmoji ? _emojiAnimations : _asciiAnimations;
+ return animations[terminal.preferredStyle % animations.length]
+ .runes
+ .map<String>((int scalar) => String.fromCharCode(scalar))
+ .toList();
+ }
+
+ final List<String> _animation;
+
+ Timer? timer;
+ int ticks = 0;
+ int _lastAnimationFrameLength = 0;
+ bool timedOut = false;
+
+ String get _currentAnimationFrame => _animation[ticks % _animation.length];
+ int get _currentLineLength => _lastAnimationFrameLength + _slowWarning.length;
+
+ void _writeToStdOut(String message) => _stdio.stdoutWrite(message);
+
+ void _clear(int length) {
+ _writeToStdOut('${_backspaceChar * length}'
+ '${_clearChar * length}'
+ '${_backspaceChar * length}');
+ }
+
+ @override
+ void start() {
+ super.start();
+ assert(timer == null);
+ _startSpinner();
+ }
+
+ void _startSpinner() {
+ timer = Timer.periodic(const Duration(milliseconds: 100), _callback);
+ _callback(timer!);
+ }
+
+ void _callback(Timer timer) {
+ assert(this.timer == timer);
+ assert(timer != null);
+ assert(timer.isActive);
+ _writeToStdOut(_backspaceChar * _lastAnimationFrameLength);
+ ticks += 1;
+ if (seemsSlow) {
+ if (!timedOut) {
+ timedOut = true;
+ _clear(_currentLineLength);
+ }
+ if (_slowWarning == '' && slowWarningCallback != null) {
+ _slowWarning = slowWarningCallback!();
+ _writeToStdOut(_slowWarning);
+ }
+ }
+ final String newFrame = _currentAnimationFrame;
+ _lastAnimationFrameLength = newFrame.runes.length;
+ _writeToStdOut(newFrame);
+ }
+
+ @override
+ void pause() {
+ assert(timer != null);
+ assert(timer!.isActive);
+ if (_terminal.supportsColor) {
+ _writeToStdOut('\r\x1B[K'); // go to start of line and clear line
+ } else {
+ _clear(_currentLineLength);
+ }
+ _lastAnimationFrameLength = 0;
+ timer?.cancel();
+ }
+
+ @override
+ void resume() {
+ assert(timer != null);
+ assert(!timer!.isActive);
+ _startSpinner();
+ }
+
+ @override
+ void finish() {
+ assert(timer != null);
+ assert(timer!.isActive);
+ timer?.cancel();
+ timer = null;
+ _clear(_lastAnimationFrameLength);
+ _lastAnimationFrameLength = 0;
+ super.finish();
+ }
+}
+
+/// An animated version of [Status].
+///
+/// The constructor writes [message] to [stdout] with padding, then starts an
+/// indeterminate progress indicator animation.
+///
+/// On [cancel] or [stop], will call [onFinish]. On [stop], will
+/// additionally print out summary information.
+///
+/// Call [pause] before outputting any text while this is running.
+class SpinnerStatus extends AnonymousSpinnerStatus {
+ SpinnerStatus({
+ required this.message,
+ this.padding = kDefaultStatusPadding,
+ super.onFinish,
+ required super.stopwatch,
+ required super.stdio,
+ required super.terminal,
+ });
+
+ final String message;
+ final int padding;
+
+ static final String _margin =
+ AnonymousSpinnerStatus._clearChar * (5 + _kTimePadding - 1);
+
+ int _totalMessageLength = 0;
+
+ @override
+ int get _currentLineLength => _totalMessageLength + super._currentLineLength;
+
+ @override
+ void start() {
+ _printStatus();
+ super.start();
+ }
+
+ void _printStatus() {
+ final String line = '${message.padRight(padding)}$_margin';
+ _totalMessageLength = line.length;
+ _writeToStdOut(line);
+ }
+
+ @override
+ void pause() {
+ super.pause();
+ _totalMessageLength = 0;
+ }
+
+ @override
+ void resume() {
+ _printStatus();
+ super.resume();
+ }
+
+ @override
+ void stop() {
+ super.stop(); // calls finish, which clears the spinner
+ assert(_totalMessageLength > _kTimePadding);
+ _writeToStdOut(AnonymousSpinnerStatus._backspaceChar * (_kTimePadding - 1));
+ _writeToStdOut(elapsedTime.padLeft(_kTimePadding));
+ _writeToStdOut('\n');
+ }
+
+ @override
+ void cancel() {
+ super.cancel(); // calls finish, which clears the spinner
+ assert(_totalMessageLength > 0);
+ _writeToStdOut('\n');
+ }
+}
+
+/// Wraps a block of text into lines no longer than [columnWidth].
+///
+/// Tries to split at whitespace, but if that's not good enough to keep it under
+/// the limit, then it splits in the middle of a word. If [columnWidth] (minus
+/// any indent) is smaller than [kMinColumnWidth], the text is wrapped at that
+/// [kMinColumnWidth] instead.
+///
+/// Preserves indentation (leading whitespace) for each line (delimited by '\n')
+/// in the input, and will indent wrapped lines that same amount, adding
+/// [indent] spaces in addition to any existing indent.
+///
+/// If [hangingIndent] is supplied, then that many additional spaces will be
+/// added to each line, except for the first line. The [hangingIndent] is added
+/// to the specified [indent], if any. This is useful for wrapping
+/// text with a heading prefix (e.g. "Usage: "):
+///
+/// ```dart
+/// String prefix = "Usage: ";
+/// print(prefix + wrapText(invocation, indent: 2, hangingIndent: prefix.length, columnWidth: 40));
+/// ```
+///
+/// yields:
+/// ```
+/// Usage: app main_command <subcommand>
+/// [arguments]
+/// ```
+///
+/// If [outputPreferences.wrapText] is false, then the text will be returned
+/// unchanged. If [shouldWrap] is specified, then it overrides the
+/// [outputPreferences.wrapText] setting.
+///
+/// If the amount of indentation (from the text, [indent], and [hangingIndent])
+/// is such that less than [kMinColumnWidth] characters can fit in the
+/// [columnWidth], then the indent is truncated to allow the text to fit.
+String wrapText(
+ String text, {
+ required int columnWidth,
+ required bool shouldWrap,
+ int? hangingIndent,
+ int? indent,
+}) {
+ assert(columnWidth >= 0);
+ if (text == null || text.isEmpty) {
+ return '';
+ }
+ indent ??= 0;
+ hangingIndent ??= 0;
+ final List<String> splitText = text.split('\n');
+ final List<String> result = <String>[];
+ for (final String line in splitText) {
+ String trimmedText = line.trimLeft();
+ final String leadingWhitespace =
+ line.substring(0, line.length - trimmedText.length);
+ List<String> notIndented;
+ if (hangingIndent != 0) {
+ // When we have a hanging indent, we want to wrap the first line at one
+ // width, and the rest at another (offset by hangingIndent), so we wrap
+ // them twice and recombine.
+ final List<String> firstLineWrap = _wrapTextAsLines(
+ trimmedText,
+ columnWidth: columnWidth - leadingWhitespace.length - indent,
+ shouldWrap: shouldWrap,
+ );
+ notIndented = <String>[firstLineWrap.removeAt(0)];
+ trimmedText = trimmedText.substring(notIndented[0].length).trimLeft();
+ if (trimmedText.isNotEmpty) {
+ notIndented.addAll(_wrapTextAsLines(
+ trimmedText,
+ columnWidth:
+ columnWidth - leadingWhitespace.length - indent - hangingIndent,
+ shouldWrap: shouldWrap,
+ ));
+ }
+ } else {
+ notIndented = _wrapTextAsLines(
+ trimmedText,
+ columnWidth: columnWidth - leadingWhitespace.length - indent,
+ shouldWrap: shouldWrap,
+ );
+ }
+ String? hangingIndentString;
+ final String indentString = ' ' * indent;
+ result.addAll(notIndented.map<String>(
+ (String line) {
+ // Don't return any lines with just whitespace on them.
+ if (line.isEmpty) {
+ return '';
+ }
+ String truncatedIndent =
+ '$indentString${hangingIndentString ?? ''}$leadingWhitespace';
+ if (truncatedIndent.length > columnWidth - kMinColumnWidth) {
+ truncatedIndent = truncatedIndent.substring(
+ 0, math.max(columnWidth - kMinColumnWidth, 0));
+ }
+ final String result = '$truncatedIndent$line';
+ hangingIndentString ??= ' ' * hangingIndent!;
+ return result;
+ },
+ ));
+ }
+ return result.join('\n');
+}
+
+/// Wraps a block of text into lines no longer than [columnWidth], starting at the
+/// [start] column, and returning the result as a list of strings.
+///
+/// Tries to split at whitespace, but if that's not good enough to keep it
+/// under the limit, then splits in the middle of a word. Preserves embedded
+/// newlines, but not indentation (it trims whitespace from each line).
+///
+/// If [columnWidth] is not specified, then the column width will be the width of the
+/// terminal window by default. If the stdout is not a terminal window, then the
+/// default will be [outputPreferences.wrapColumn].
+///
+/// The [columnWidth] is clamped to [kMinColumnWidth] at minimum (so passing negative
+/// widths is fine, for instance).
+///
+/// If [outputPreferences.wrapText] is false, then the text will be returned
+/// simply split at the newlines, but not wrapped. If [shouldWrap] is specified,
+/// then it overrides the [outputPreferences.wrapText] setting.
+List<String> _wrapTextAsLines(
+ String text, {
+ int start = 0,
+ required int columnWidth,
+ required bool shouldWrap,
+}) {
+ if (text == null || text.isEmpty) {
+ return <String>[''];
+ }
+ assert(start >= 0);
+
+ // Splits a string so that the resulting list has the same number of elements
+ // as there are visible characters in the string, but elements may include one
+ // or more adjacent ANSI sequences. Joining the list elements again will
+ // reconstitute the original string. This is useful for manipulating "visible"
+ // characters in the presence of ANSI control codes.
+ List<_AnsiRun> splitWithCodes(String input) {
+ final RegExp characterOrCode =
+ RegExp('(\u001b\\[[0-9;]*m|.)', multiLine: true);
+ List<_AnsiRun> result = <_AnsiRun>[];
+ final StringBuffer current = StringBuffer();
+ for (final Match match in characterOrCode.allMatches(input)) {
+ current.write(match[0]);
+ if (match[0]!.length < 4) {
+ // This is a regular character, write it out.
+ result.add(_AnsiRun(current.toString(), match[0]!));
+ current.clear();
+ }
+ }
+ // If there's something accumulated, then it must be an ANSI sequence, so
+ // add it to the end of the last entry so that we don't lose it.
+ if (current.isNotEmpty) {
+ if (result.isNotEmpty) {
+ result.last.original += current.toString();
+ } else {
+ // If there is nothing in the string besides control codes, then just
+ // return them as the only entry.
+ result = <_AnsiRun>[_AnsiRun(current.toString(), '')];
+ }
+ }
+ return result;
+ }
+
+ String joinRun(List<_AnsiRun> list, int start, [int? end]) {
+ return list
+ .sublist(start, end)
+ .map<String>((_AnsiRun run) => run.original)
+ .join()
+ .trim();
+ }
+
+ final List<String> result = <String>[];
+ final int effectiveLength = math.max(columnWidth - start, kMinColumnWidth);
+ for (final String line in text.split('\n')) {
+ // If the line is short enough, even with ANSI codes, then we can just add
+ // add it and move on.
+ if (line.length <= effectiveLength || !shouldWrap) {
+ result.add(line);
+ continue;
+ }
+ final List<_AnsiRun> splitLine = splitWithCodes(line);
+ if (splitLine.length <= effectiveLength) {
+ result.add(line);
+ continue;
+ }
+
+ int currentLineStart = 0;
+ int? lastWhitespace;
+ // Find the start of the current line.
+ for (int index = 0; index < splitLine.length; ++index) {
+ if (splitLine[index].character.isNotEmpty &&
+ _isWhitespace(splitLine[index])) {
+ lastWhitespace = index;
+ }
+
+ if (index - currentLineStart >= effectiveLength) {
+ // Back up to the last whitespace, unless there wasn't any, in which
+ // case we just split where we are.
+ if (lastWhitespace != null) {
+ index = lastWhitespace;
+ }
+
+ result.add(joinRun(splitLine, currentLineStart, index));
+
+ // Skip any intervening whitespace.
+ while (index < splitLine.length && _isWhitespace(splitLine[index])) {
+ index++;
+ }
+
+ currentLineStart = index;
+ lastWhitespace = null;
+ }
+ }
+ result.add(joinRun(splitLine, currentLineStart));
+ }
+ return result;
+}
+
+// Used to represent a run of ANSI control sequences next to a visible
+// character.
+class _AnsiRun {
+ _AnsiRun(this.original, this.character);
+
+ String original;
+ String character;
+}
+
+/// Returns true if the code unit at [index] in [text] is a whitespace
+/// character.
+///
+/// Based on: https://en.wikipedia.org/wiki/Whitespace_character#Unicode
+bool _isWhitespace(_AnsiRun run) {
+ final int rune = run.character.isNotEmpty ? run.character.codeUnitAt(0) : 0x0;
+ return rune >= 0x0009 && rune <= 0x000D ||
+ rune == 0x0020 ||
+ rune == 0x0085 ||
+ rune == 0x1680 ||
+ rune == 0x180E ||
+ rune >= 0x2000 && rune <= 0x200A ||
+ rune == 0x2028 ||
+ rune == 0x2029 ||
+ rune == 0x202F ||
+ rune == 0x205F ||
+ rune == 0x3000 ||
+ rune == 0xFEFF;
+}
+
+/// An abstraction for instantiation of the correct logger type.
+///
+/// Our logger class hierarchy and runtime requirements are overly complicated.
+class LoggerFactory {
+ LoggerFactory({
+ required Terminal terminal,
+ required Stdio stdio,
+ required OutputPreferences outputPreferences,
+ StopwatchFactory stopwatchFactory = const StopwatchFactory(),
+ }) : _terminal = terminal,
+ _stdio = stdio,
+ _stopwatchFactory = stopwatchFactory,
+ _outputPreferences = outputPreferences;
+
+ final Terminal _terminal;
+ final Stdio _stdio;
+ final StopwatchFactory _stopwatchFactory;
+ final OutputPreferences _outputPreferences;
+
+ /// Create the appropriate logger for the current platform and configuration.
+ Logger createLogger({
+ required bool windows,
+ }) {
+ Logger logger;
+ if (windows) {
+ logger = WindowsStdoutLogger(
+ terminal: _terminal,
+ stdio: _stdio,
+ outputPreferences: _outputPreferences,
+ stopwatchFactory: _stopwatchFactory,
+ );
+ } else {
+ logger = StdoutLogger(
+ terminal: _terminal,
+ stdio: _stdio,
+ outputPreferences: _outputPreferences,
+ stopwatchFactory: _stopwatchFactory);
+ }
+ return logger;
+ }
+}
diff --git a/packages/flutter_migrate/lib/src/base/project.dart b/packages/flutter_migrate/lib/src/base/project.dart
new file mode 100644
index 0000000..a8924d7
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/project.dart
@@ -0,0 +1,91 @@
+// 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 'package:meta/meta.dart';
+
+import 'file_system.dart';
+import 'logger.dart';
+
+/// Emum for each officially supported platform.
+enum SupportedPlatform {
+ android,
+ ios,
+ linux,
+ macos,
+ web,
+ windows,
+ fuchsia,
+ root, // Special platform to represent the root project directory
+}
+
+class FlutterProjectFactory {
+ FlutterProjectFactory();
+
+ @visibleForTesting
+ final Map<String, FlutterProject> projects = <String, FlutterProject>{};
+
+ /// Returns a [FlutterProject] view of the given directory or a ToolExit error,
+ /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid.
+ FlutterProject fromDirectory(Directory directory) {
+ assert(directory != null);
+ return projects.putIfAbsent(directory.path, () {
+ return FlutterProject(directory);
+ });
+ }
+}
+
+/// Represents the contents of a Flutter project at the specified [directory].
+class FlutterProject {
+ FlutterProject(this.directory) : assert(directory != null);
+
+ /// Returns a [FlutterProject] view of the current directory or a ToolExit error,
+ /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid.
+ static FlutterProject current(FileSystem fs) =>
+ FlutterProject(fs.currentDirectory);
+
+ /// Create a [FlutterProject] and bypass the project caching.
+ @visibleForTesting
+ static FlutterProject fromDirectoryTest(Directory directory,
+ [Logger? logger]) {
+ logger ??= BufferLogger.test();
+ return FlutterProject(directory);
+ }
+
+ Directory directory;
+
+ /// The `pubspec.yaml` file of this project.
+ File get pubspecFile => directory.childFile('pubspec.yaml');
+
+ /// The `.metadata` file of this project.
+ File get metadataFile => directory.childFile('.metadata');
+
+ /// Returns a list of platform names that are supported by the project.
+ List<SupportedPlatform> getSupportedPlatforms({bool includeRoot = false}) {
+ final List<SupportedPlatform> platforms = includeRoot
+ ? <SupportedPlatform>[SupportedPlatform.root]
+ : <SupportedPlatform>[];
+ if (directory.childDirectory('android').existsSync()) {
+ platforms.add(SupportedPlatform.android);
+ }
+ if (directory.childDirectory('ios').existsSync()) {
+ platforms.add(SupportedPlatform.ios);
+ }
+ if (directory.childDirectory('web').existsSync()) {
+ platforms.add(SupportedPlatform.web);
+ }
+ if (directory.childDirectory('macos').existsSync()) {
+ platforms.add(SupportedPlatform.macos);
+ }
+ if (directory.childDirectory('linux').existsSync()) {
+ platforms.add(SupportedPlatform.linux);
+ }
+ if (directory.childDirectory('windows').existsSync()) {
+ platforms.add(SupportedPlatform.windows);
+ }
+ if (directory.childDirectory('fuchsia').existsSync()) {
+ platforms.add(SupportedPlatform.fuchsia);
+ }
+ return platforms;
+ }
+}
diff --git a/packages/flutter_migrate/lib/src/base/signals.dart b/packages/flutter_migrate/lib/src/base/signals.dart
new file mode 100644
index 0000000..265f00f
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/signals.dart
@@ -0,0 +1,154 @@
+// 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:io';
+
+import 'package:meta/meta.dart';
+
+import 'common.dart';
+import 'io.dart';
+
+typedef SignalHandler = FutureOr<void> Function(ProcessSignal signal);
+
+/// A class that manages signal handlers.
+///
+/// Signal handlers are run in the order that they were added.
+abstract class Signals {
+ @visibleForTesting
+ factory Signals.test({
+ List<ProcessSignal> exitSignals = defaultExitSignals,
+ }) =>
+ LocalSignals._(exitSignals);
+
+ // The default list of signals that should cause the process to exit.
+ static const List<ProcessSignal> defaultExitSignals = <ProcessSignal>[
+ ProcessSignal.sigterm,
+ ProcessSignal.sigint,
+ ];
+
+ /// Adds a signal handler to run on receipt of signal.
+ ///
+ /// The handler will run after all handlers that were previously added for the
+ /// signal. The function returns an abstract token that should be provided to
+ /// removeHandler to remove the handler.
+ Object addHandler(ProcessSignal signal, SignalHandler handler);
+
+ /// Removes a signal handler.
+ ///
+ /// Removes the signal handler for the signal identified by the abstract
+ /// token parameter. Returns true if the handler was removed and false
+ /// otherwise.
+ Future<bool> removeHandler(ProcessSignal signal, Object token);
+
+ /// If a [SignalHandler] throws an error, either synchronously or
+ /// asynchronously, it will be added to this stream instead of propagated.
+ Stream<Object> get errors;
+}
+
+/// A class that manages the real dart:io signal handlers.
+///
+/// We use a singleton instance of this class to ensure that all handlers for
+/// fatal signals run before this class calls exit().
+class LocalSignals implements Signals {
+ LocalSignals._(this.exitSignals);
+
+ static LocalSignals instance = LocalSignals._(
+ Signals.defaultExitSignals,
+ );
+
+ final List<ProcessSignal> exitSignals;
+
+ // A table mapping (signal, token) -> signal handler.
+ final Map<ProcessSignal, Map<Object, SignalHandler>> _handlersTable =
+ <ProcessSignal, Map<Object, SignalHandler>>{};
+
+ // A table mapping (signal) -> signal handler list. The list is in the order
+ // that the signal handlers should be run.
+ final Map<ProcessSignal, List<SignalHandler>> _handlersList =
+ <ProcessSignal, List<SignalHandler>>{};
+
+ // A table mapping (signal) -> low-level signal event stream.
+ final Map<ProcessSignal, StreamSubscription<ProcessSignal>>
+ _streamSubscriptions =
+ <ProcessSignal, StreamSubscription<ProcessSignal>>{};
+
+ // The stream controller for errors coming from signal handlers.
+ final StreamController<Object> _errorStreamController =
+ StreamController<Object>.broadcast();
+
+ @override
+ Stream<Object> get errors => _errorStreamController.stream;
+
+ @override
+ Object addHandler(ProcessSignal signal, SignalHandler handler) {
+ final Object token = Object();
+ _handlersTable.putIfAbsent(signal, () => <Object, SignalHandler>{});
+ _handlersTable[signal]![token] = handler;
+
+ _handlersList.putIfAbsent(signal, () => <SignalHandler>[]);
+ _handlersList[signal]!.add(handler);
+
+ // If we added the first one, then call signal.watch(), listen, and cache
+ // the stream controller.
+ if (_handlersList[signal]!.length == 1) {
+ _streamSubscriptions[signal] = signal.watch().listen(
+ _handleSignal,
+ onError: (Object e) {
+ _handlersTable[signal]?.remove(token);
+ _handlersList[signal]?.remove(handler);
+ },
+ );
+ }
+ return token;
+ }
+
+ @override
+ Future<bool> removeHandler(ProcessSignal signal, Object token) async {
+ // We don't know about this signal.
+ if (!_handlersTable.containsKey(signal)) {
+ return false;
+ }
+ // We don't know about this token.
+ if (!_handlersTable[signal]!.containsKey(token)) {
+ return false;
+ }
+ final SignalHandler? handler = _handlersTable[signal]!.remove(token);
+ if (handler == null) {
+ return false;
+ }
+ final bool removed = _handlersList[signal]!.remove(handler);
+ if (!removed) {
+ return false;
+ }
+
+ // If _handlersList[signal] is empty, then lookup the cached stream
+ // controller and unsubscribe from the stream.
+ if (_handlersList.isEmpty) {
+ await _streamSubscriptions[signal]?.cancel();
+ }
+ return true;
+ }
+
+ Future<void> _handleSignal(ProcessSignal s) async {
+ final List<SignalHandler>? handlers = _handlersList[s];
+ if (handlers != null) {
+ final List<SignalHandler> handlersCopy = handlers.toList();
+ for (final SignalHandler handler in handlersCopy) {
+ try {
+ await asyncGuard<void>(() async => handler(s));
+ } on Exception catch (e) {
+ if (_errorStreamController.hasListener) {
+ _errorStreamController.add(e);
+ }
+ }
+ }
+ }
+ // If this was a signal that should cause the process to go down, then
+ // call exit();
+ if (exitSignals.contains(s)) {
+ exit(0);
+ }
+ }
+}
diff --git a/packages/flutter_migrate/lib/src/base/terminal.dart b/packages/flutter_migrate/lib/src/base/terminal.dart
new file mode 100644
index 0000000..07976aa
--- /dev/null
+++ b/packages/flutter_migrate/lib/src/base/terminal.dart
@@ -0,0 +1,418 @@
+// 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:convert';
+import 'dart:io';
+
+import 'common.dart';
+import 'io.dart' as io;
+import 'logger.dart';
+
+enum TerminalColor {
+ red,
+ green,
+ blue,
+ cyan,
+ yellow,
+ magenta,
+ grey,
+}
+
+/// A class that contains the context settings for command text output to the
+/// console.
+class OutputPreferences {
+ OutputPreferences({
+ bool? wrapText,
+ int? wrapColumn,
+ bool? showColor,
+ io.Stdio? stdio,
+ }) : _stdio = stdio,
+ wrapText = wrapText ?? stdio?.hasTerminal ?? false,
+ _overrideWrapColumn = wrapColumn,
+ showColor = showColor ?? false;
+
+ /// A version of this class for use in tests.
+ OutputPreferences.test(
+ {this.wrapText = false,
+ int wrapColumn = kDefaultTerminalColumns,
+ this.showColor = false})
+ : _overrideWrapColumn = wrapColumn,
+ _stdio = null;
+
+ final io.Stdio? _stdio;
+
+ /// If [wrapText] is true, then any text sent to the context's [Logger]
+ /// instance (e.g. from the [printError] or [printStatus] functions) will be
+ /// wrapped (newlines added between words) to be no longer than the
+ /// [wrapColumn] specifies. Defaults to true if there is a terminal. To
+ /// determine if there's a terminal, [OutputPreferences] asks the context's
+ /// stdio.
+ final bool wrapText;
+
+ /// The terminal width used by the [wrapText] function if there is no terminal
+ /// attached to [io.Stdio], --wrap is on, and --wrap-columns was not specified.
+ static const int kDefaultTerminalColumns = 100;
+
+ /// The column at which output sent to the context's [Logger] instance
+ /// (e.g. from the [printError] or [printStatus] functions) will be wrapped.
+ /// Ignored if [wrapText] is false. Defaults to the width of the output
+ /// terminal, or to [kDefaultTerminalColumns] if not writing to a terminal.
+ final int? _overrideWrapColumn;
+ int get wrapColumn {
+ return _overrideWrapColumn ??
+ _stdio?.terminalColumns ??
+ kDefaultTerminalColumns;
+ }
+
+ /// Whether or not to output ANSI color codes when writing to the output
+ /// terminal. Defaults to whatever [platform.stdoutSupportsAnsi] says if
+ /// writing to a terminal, and false otherwise.
+ final bool showColor;
+
+ @override
+ String toString() {
+ return '$runtimeType[wrapText: $wrapText, wrapColumn: $wrapColumn, showColor: $showColor]';
+ }
+}
+
+/// The command line terminal, if available.
+abstract class Terminal {
+ /// Create a new test [Terminal].
+ ///
+ /// If not specified, [supportsColor] defaults to `false`.
+ factory Terminal.test({bool supportsColor, bool supportsEmoji}) =
+ _TestTerminal;
+
+ /// Whether the current terminal supports color escape codes.
+ bool get supportsColor;
+
+ /// Whether the current terminal can display emoji.
+ bool get supportsEmoji;
+
+ /// When we have a choice of styles (e.g. animated spinners), this selects the
+ /// style to use.
+ int get preferredStyle;
+
+ /// Whether we are interacting with the flutter tool via the terminal.
+ ///
+ /// If not set, defaults to false.
+ bool get usesTerminalUi;
+ set usesTerminalUi(bool value);
+
+ /// Whether there is a terminal attached to stdin.
+ ///
+ /// If true, this usually indicates that a user is using the CLI as
+ /// opposed to using an IDE. This can be used to determine
+ /// whether it is appropriate to show a terminal prompt,
+ /// or whether an automatic selection should be made instead.
+ bool get stdinHasTerminal;
+
+ /// Warning mark to use in stdout or stderr.
+ String get warningMark;
+
+ /// Success mark to use in stdout.
+ String get successMark;
+
+ String bolden(String message);
+
+ String color(String message, TerminalColor color);
+
+ String clearScreen();
+
+ bool get singleCharMode;
+ set singleCharMode(bool value);
+
+ /// Return keystrokes from the console.
+ ///
+ /// This is a single-subscription stream. This stream may be closed before
+ /// the application exits.
+ ///
+ /// Useful when the console is in [singleCharMode].
+ Stream<String> get keystrokes;
+
+ /// Prompts the user to input a character within a given list. Re-prompts if
+ /// entered character is not in the list.
+ ///
+ /// The `prompt`, if non-null, is the text displayed prior to waiting for user
+ /// input each time. If `prompt` is non-null and `displayAcceptedCharacters`
+ /// is true, the accepted keys are printed next to the `prompt`.
+ ///
+ /// The returned value is the user's input; if `defaultChoiceIndex` is not
+ /// null, and the user presses enter without any other input, the return value
+ /// will be the character in `acceptedCharacters` at the index given by
+ /// `defaultChoiceIndex`.
+ ///
+ /// The accepted characters must be a String with a length of 1, excluding any
+ /// whitespace characters such as `\t`, `\n`, or ` `.
+ ///
+ /// If [usesTerminalUi] is false, throws a [StateError].
+ Future<String> promptForCharInput(
+ List<String> acceptedCharacters, {
+ required Logger logger,
+ String? prompt,
+ int? defaultChoiceIndex,
+ bool displayAcceptedCharacters = true,
+ });
+}
+
+class AnsiTerminal implements Terminal {
+ AnsiTerminal({
+ required io.Stdio stdio,
+ DateTime?
+ now, // Time used to determine preferredStyle. Defaults to 0001-01-01 00:00.
+ bool? supportsColor,
+ }) : _stdio = stdio,
+ _now = now ?? DateTime(1),
+ _supportsColor = supportsColor;
+
+ final io.Stdio _stdio;
+ final DateTime _now;
+
+ static const String bold = '\u001B[1m';
+ static const String resetAll = '\u001B[0m';
+ static const String resetColor = '\u001B[39m';
+ static const String resetBold = '\u001B[22m';
+ static const String clear = '\u001B[2J\u001B[H';
+
+ static const String red = '\u001b[31m';
+ static const String green = '\u001b[32m';
+ static const String blue = '\u001b[34m';
+ static const String cyan = '\u001b[36m';
+ static const String magenta = '\u001b[35m';
+ static const String yellow = '\u001b[33m';
+ static const String grey = '\u001b[90m';
+
+ static const Map<TerminalColor, String> _colorMap = <TerminalColor, String>{
+ TerminalColor.red: red,
+ TerminalColor.green: green,
+ TerminalColor.blue: blue,
+ TerminalColor.cyan: cyan,
+ TerminalColor.magenta: magenta,
+ TerminalColor.yellow: yellow,
+ TerminalColor.grey: grey,
+ };
+
+ static String colorCode(TerminalColor color) => _colorMap[color]!;
+
+ @override
+ bool get supportsColor => _supportsColor ?? stdout.supportsAnsiEscapes;
+ final bool? _supportsColor;
+
+ // Assume unicode emojis are supported when not on Windows.
+ // If we are on Windows, unicode emojis are supported in Windows Terminal,
+ // which sets the WT_SESSION environment variable. See:
+ // https://github.com/microsoft/terminal/blob/master/doc/user-docs/index.md#tips-and-tricks
+ @override
+ bool get supportsEmoji =>
+ !isWindows || Platform.environment.containsKey('WT_SESSION');
+
+ @override
+ int get preferredStyle {
+ const int workdays = DateTime.friday;
+ if (_now.weekday <= workdays) {
+ return _now.weekday - 1;
+ }
+ return _now.hour + workdays;
+ }
+
+ final RegExp _boldControls = RegExp(
+ '(${RegExp.escape(resetBold)}|${RegExp.escape(bold)})',
+ );
+
+ @override
+ bool usesTerminalUi = false;
+
+ @override
+ String get warningMark {
+ return bolden(color('[!]', TerminalColor.red));
+ }
+
+ @override
+ String get successMark {
+ return bolden(color('✓', TerminalColor.green));
+ }
+
+ @override
+ String bolden(String message) {
+ assert(message != null);
+ if (!supportsColor || message.isEmpty) {
+ return message;
+ }
+ final StringBuffer buffer = StringBuffer();
+ for (String line in message.split('\n')) {
+ // If there were bolds or resetBolds in the string before, then nuke them:
+ // they're redundant. This prevents previously embedded resets from
+ // stopping the boldness.
+ line = line.replaceAll(_boldControls, '');
+ buffer.writeln('$bold$line$resetBold');
+ }
+ final String result = buffer.toString();
+ // avoid introducing a new newline to the emboldened text
+ return (!message.endsWith('\n') && result.endsWith('\n'))
+ ? result.substring(0, result.length - 1)
+ : result;
+ }
+
+ @override
+ String color(String message, TerminalColor color) {
+ assert(message != null);
+ if (!supportsColor || color == null || message.isEmpty) {
+ return message;
+ }
+ final StringBuffer buffer = StringBuffer();
+ final String colorCodes = _colorMap[color]!;
+ for (String line in message.split('\n')) {
+ // If there were resets in the string before, then keep them, but
+ // restart the color right after. This prevents embedded resets from
+ // stopping the colors, and allows nesting of colors.
+ line = line.replaceAll(resetColor, '$resetColor$colorCodes');
+ buffer.writeln('$colorCodes$line$resetColor');
+ }
+ final String result = buffer.toString();
+ // avoid introducing a new newline to the colored text
+ return (!message.endsWith('\n') && result.endsWith('\n'))
+ ? result.substring(0, result.length - 1)
+ : result;
+ }
+
+ @override
+ String clearScreen() => supportsColor ? clear : '\n\n';
+
+ @override
+ bool get singleCharMode {
+ if (!_stdio.stdinHasTerminal) {
+ return false;
+ }
+ final io.Stdin stdin = _stdio.stdin as io.Stdin;
+ return stdin.lineMode && stdin.echoMode;
+ }
+
+ @override
+ set singleCharMode(bool value) {
+ if (!_stdio.stdinHasTerminal) {
+ return;
+ }
+ final io.Stdin stdin = _stdio.stdin as io.Stdin;
+ // The order of setting lineMode and echoMode is important on Windows.
+ if (value) {
+ stdin.echoMode = false;
+ stdin.lineMode = false;
+ } else {
+ stdin.lineMode = true;
+ stdin.echoMode = true;
+ }
+ }
+
+ @override
+ bool get stdinHasTerminal => _stdio.stdinHasTerminal;
+
+ Stream<String>? _broadcastStdInString;
+
+ @override
+ Stream<String> get keystrokes {
+ return _broadcastStdInString ??= _stdio.stdin
+ .transform<String>(const AsciiDecoder(allowInvalid: true))
+ .asBroadcastStream();
+ }
+
+ @override
+ Future<String> promptForCharInput(
+ List<String> acceptedCharacters, {
+ required Logger logger,
+ String? prompt,
+ int? defaultChoiceIndex,
+ bool displayAcceptedCharacters = true,
+ }) async {
+ assert(acceptedCharacters.isNotEmpty);
+ assert(prompt == null || prompt.isNotEmpty);
+ if (!usesTerminalUi) {
+ throw StateError('cannot prompt without a terminal ui');
+ }
+ List<String> charactersToDisplay = acceptedCharacters;
+ if (defaultChoiceIndex != null) {
+ assert(defaultChoiceIndex >= 0 &&
+ defaultChoiceIndex < acceptedCharacters.length);
+ charactersToDisplay = List<String>.of(charactersToDisplay);
+ charactersToDisplay[defaultChoiceIndex] =
+ bolden(charactersToDisplay[defaultChoiceIndex]);
+ acceptedCharacters.add('');
+ }
+ String? choice;
+ singleCharMode = true;
+ while (choice == null ||
+ choice.length > 1 ||
+ !acceptedCharacters.contains(choice)) {
+ if (prompt != null) {
+ logger.printStatus(prompt, emphasis: true, newline: false);
+ if (displayAcceptedCharacters) {
+ logger.printStatus(' [${charactersToDisplay.join("|")}]',
+ newline: false);
+ }
+ // prompt ends with ': '
+ logger.printStatus(': ', emphasis: true, newline: false);
+ }
+ choice = (await keystrokes.first).trim();
+ logger.printStatus(choice);
+ }
+ singleCharMode = false;
+ if (defaultChoiceIndex != null && choice == '') {
+ choice = acceptedCharacters[defaultChoiceIndex];
+ }
+ return choice;
+ }
+}
+
+class _TestTerminal implements Terminal {
+ _TestTerminal({this.supportsColor = false, this.supportsEmoji = false});
+
+ @override
+ bool usesTerminalUi = false;
+
+ @override
+ String bolden(String message) => message;
+
+ @override
+ String clearScreen() => '\n\n';
+
+ @override
+ String color(String message, TerminalColor color) => message;
+
+ @override
+ Stream<String> get keystrokes => const Stream<String>.empty();
+
+ @override
+ Future<String> promptForCharInput(
+ List<String> acceptedCharacters, {
+ required Logger logger,
+ String? prompt,
+ int? defaultChoiceIndex,
+ bool displayAcceptedCharacters = true,
+ }) {
+ throw UnsupportedError(
+ 'promptForCharInput not supported in the test terminal.');
+ }
+
+ @override
+ bool get singleCharMode => false;
+ @override
+ set singleCharMode(bool value) {}
+
+ @override
+ final bool supportsColor;
+
+ @override
+ final bool supportsEmoji;
+
+ @override
+ int get preferredStyle => 0;
+
+ @override
+ bool get stdinHasTerminal => false;
+
+ @override
+ String get successMark => '✓';
+
+ @override
+ String get warningMark => '[!]';
+}
diff --git a/packages/flutter_migrate/pubspec.yaml b/packages/flutter_migrate/pubspec.yaml
index 28f180b..3704d5b 100644
--- a/packages/flutter_migrate/pubspec.yaml
+++ b/packages/flutter_migrate/pubspec.yaml
@@ -10,5 +10,20 @@
dependencies:
args: ^2.3.1
+ convert: 3.0.2
+ file: 6.1.4
+ intl: 0.17.0
+ meta: 1.8.0
+ path: ^1.8.0
+ process: 4.2.4
+ test_api: 0.4.13
+ test_core: 0.4.17
+ vm_service: 9.3.0
+ xml: ^6.1.0
+ yaml: 3.1.1
dev_dependencies:
+ collection: 1.16.0
+ file_testing: ^3.0.0
+ lints: ^2.0.0
+ test: ^1.16.0
diff --git a/packages/flutter_migrate/test/base/context_test.dart b/packages/flutter_migrate/test/base/context_test.dart
new file mode 100644
index 0000000..53f8e8f
--- /dev/null
+++ b/packages/flutter_migrate/test/base/context_test.dart
@@ -0,0 +1,296 @@
+// 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 'package:flutter_migrate/src/base/context.dart';
+
+import '../src/common.dart';
+
+void main() {
+ group('AppContext', () {
+ group('global getter', () {
+ late bool called;
+
+ setUp(() {
+ called = false;
+ });
+
+ test('returns non-null context in the root zone', () {
+ expect(context, isNotNull);
+ });
+
+ test(
+ 'returns root context in child of root zone if zone was manually created',
+ () {
+ final Zone rootZone = Zone.current;
+ final AppContext rootContext = context;
+ runZoned<void>(() {
+ expect(Zone.current, isNot(rootZone));
+ expect(Zone.current.parent, rootZone);
+ expect(context, rootContext);
+ called = true;
+ });
+ expect(called, isTrue);
+ });
+
+ test('returns child context after run', () async {
+ final AppContext rootContext = context;
+ await rootContext.run<void>(
+ name: 'child',
+ body: () {
+ expect(context, isNot(rootContext));
+ expect(context.name, 'child');
+ called = true;
+ });
+ expect(called, isTrue);
+ });
+
+ test('returns grandchild context after nested run', () async {
+ final AppContext rootContext = context;
+ await rootContext.run<void>(
+ name: 'child',
+ body: () async {
+ final AppContext childContext = context;
+ await childContext.run<void>(
+ name: 'grandchild',
+ body: () {
+ expect(context, isNot(rootContext));
+ expect(context, isNot(childContext));
+ expect(context.name, 'grandchild');
+ called = true;
+ });
+ });
+ expect(called, isTrue);
+ });
+
+ test('scans up zone hierarchy for first context', () async {
+ final AppContext rootContext = context;
+ await rootContext.run<void>(
+ name: 'child',
+ body: () {
+ final AppContext childContext = context;
+ runZoned<void>(() {
+ expect(context, isNot(rootContext));
+ expect(context, same(childContext));
+ expect(context.name, 'child');
+ called = true;
+ });
+ });
+ expect(called, isTrue);
+ });
+ });
+
+ group('operator[]', () {
+ test('still finds values if async code runs after body has finished',
+ () async {
+ final Completer<void> outer = Completer<void>();
+ final Completer<void> inner = Completer<void>();
+ String? value;
+ await context.run<void>(
+ body: () {
+ outer.future.then<void>((_) {
+ value = context.get<String>();
+ inner.complete();
+ });
+ },
+ fallbacks: <Type, Generator>{
+ String: () => 'value',
+ },
+ );
+ expect(value, isNull);
+ outer.complete();
+ await inner.future;
+ expect(value, 'value');
+ });
+
+ test('caches generated override values', () async {
+ int consultationCount = 0;
+ String? value;
+ await context.run<void>(
+ body: () async {
+ final StringBuffer buf = StringBuffer(context.get<String>()!);
+ buf.write(context.get<String>());
+ await context.run<void>(body: () {
+ buf.write(context.get<String>());
+ });
+ value = buf.toString();
+ },
+ overrides: <Type, Generator>{
+ String: () {
+ consultationCount++;
+ return 'v';
+ },
+ },
+ );
+ expect(value, 'vvv');
+ expect(consultationCount, 1);
+ });
+
+ test('caches generated fallback values', () async {
+ int consultationCount = 0;
+ String? value;
+ await context.run(
+ body: () async {
+ final StringBuffer buf = StringBuffer(context.get<String>()!);
+ buf.write(context.get<String>());
+ await context.run<void>(body: () {
+ buf.write(context.get<String>());
+ });
+ value = buf.toString();
+ },
+ fallbacks: <Type, Generator>{
+ String: () {
+ consultationCount++;
+ return 'v';
+ },
+ },
+ );
+ expect(value, 'vvv');
+ expect(consultationCount, 1);
+ });
+
+ test('returns null if generated value is null', () async {
+ final String? value = await context.run<String?>(
+ body: () => context.get<String>(),
+ overrides: <Type, Generator>{
+ String: () => null,
+ },
+ );
+ expect(value, isNull);
+ });
+
+ test('throws if generator has dependency cycle', () async {
+ final Future<String?> value = context.run<String?>(
+ body: () async {
+ return context.get<String>();
+ },
+ fallbacks: <Type, Generator>{
+ int: () => int.parse(context.get<String>() ?? ''),
+ String: () => '${context.get<double>()}',
+ double: () => context.get<int>()! * 1.0,
+ },
+ );
+ expect(
+ () => value,
+ throwsA(
+ isA<ContextDependencyCycleException>().having(
+ (ContextDependencyCycleException error) => error.cycle,
+ 'cycle',
+ <Type>[String, double, int]).having(
+ (ContextDependencyCycleException error) => error.toString(),
+ 'toString()',
+ 'Dependency cycle detected: String -> double -> int',
+ ),
+ ),
+ );
+ });
+ });
+
+ group('run', () {
+ test('returns the value returned by body', () async {
+ expect(await context.run<int>(body: () => 123), 123);
+ expect(await context.run<String>(body: () => 'value'), 'value');
+ expect(await context.run<int>(body: () async => 456), 456);
+ });
+
+ test('passes name to child context', () async {
+ await context.run<void>(
+ name: 'child',
+ body: () {
+ expect(context.name, 'child');
+ });
+ });
+
+ group('fallbacks', () {
+ late bool called;
+
+ setUp(() {
+ called = false;
+ });
+
+ test('are applied after parent context is consulted', () async {
+ final String? value = await context.run<String?>(
+ body: () {
+ return context.run<String?>(
+ body: () {
+ called = true;
+ return context.get<String>();
+ },
+ fallbacks: <Type, Generator>{
+ String: () => 'child',
+ },
+ );
+ },
+ );
+ expect(called, isTrue);
+ expect(value, 'child');
+ });
+
+ test('are not applied if parent context supplies value', () async {
+ bool childConsulted = false;
+ final String? value = await context.run<String?>(
+ body: () {
+ return context.run<String?>(
+ body: () {
+ called = true;
+ return context.get<String>();
+ },
+ fallbacks: <Type, Generator>{
+ String: () {
+ childConsulted = true;
+ return 'child';
+ },
+ },
+ );
+ },
+ fallbacks: <Type, Generator>{
+ String: () => 'parent',
+ },
+ );
+ expect(called, isTrue);
+ expect(value, 'parent');
+ expect(childConsulted, isFalse);
+ });
+
+ test('may depend on one another', () async {
+ final String? value = await context.run<String?>(
+ body: () {
+ return context.get<String>();
+ },
+ fallbacks: <Type, Generator>{
+ int: () => 123,
+ String: () => '-${context.get<int>()}-',
+ },
+ );
+ expect(value, '-123-');
+ });
+ });
+
+ group('overrides', () {
+ test('intercept consultation of parent context', () async {
+ bool parentConsulted = false;
+ final String? value = await context.run<String?>(
+ body: () {
+ return context.run<String?>(
+ body: () => context.get<String>(),
+ overrides: <Type, Generator>{
+ String: () => 'child',
+ },
+ );
+ },
+ fallbacks: <Type, Generator>{
+ String: () {
+ parentConsulted = true;
+ return 'parent';
+ },
+ },
+ );
+ expect(value, 'child');
+ expect(parentConsulted, isFalse);
+ });
+ });
+ });
+ });
+}
diff --git a/packages/flutter_migrate/test/base/file_system_test.dart b/packages/flutter_migrate/test/base/file_system_test.dart
new file mode 100644
index 0000000..b7a6424
--- /dev/null
+++ b/packages/flutter_migrate/test/base/file_system_test.dart
@@ -0,0 +1,357 @@
+// 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:io' as io;
+
+import 'package:file/memory.dart';
+import 'package:file_testing/file_testing.dart';
+import 'package:flutter_migrate/src/base/common.dart';
+import 'package:flutter_migrate/src/base/file_system.dart';
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/logger.dart';
+import 'package:flutter_migrate/src/base/signals.dart';
+import 'package:test/fake.dart';
+
+import '../src/common.dart';
+
+class LocalFileSystemFake extends LocalFileSystem {
+ LocalFileSystemFake.test({required super.signals}) : super.test();
+
+ @override
+ Directory get superSystemTempDirectory => directory('/does_not_exist');
+}
+
+void main() {
+ group('fsUtils', () {
+ late MemoryFileSystem fs;
+ late FileSystemUtils fsUtils;
+
+ setUp(() {
+ fs = MemoryFileSystem.test();
+ fsUtils = FileSystemUtils(
+ fileSystem: fs,
+ );
+ });
+
+ testWithoutContext('getUniqueFile creates a unique file name', () async {
+ final File fileA = fsUtils.getUniqueFile(
+ fs.currentDirectory, 'foo', 'json')
+ ..createSync();
+ final File fileB =
+ fsUtils.getUniqueFile(fs.currentDirectory, 'foo', 'json');
+
+ expect(fileA.path, '/foo_01.json');
+ expect(fileB.path, '/foo_02.json');
+ });
+
+ testWithoutContext('getUniqueDirectory creates a unique directory name',
+ () async {
+ final Directory directoryA =
+ fsUtils.getUniqueDirectory(fs.currentDirectory, 'foo')..createSync();
+ final Directory directoryB =
+ fsUtils.getUniqueDirectory(fs.currentDirectory, 'foo');
+
+ expect(directoryA.path, '/foo_01');
+ expect(directoryB.path, '/foo_02');
+ });
+ });
+
+ group('copyDirectorySync', () {
+ /// Test file_systems.copyDirectorySync() using MemoryFileSystem.
+ /// Copies between 2 instances of file systems which is also supported by copyDirectorySync().
+ testWithoutContext('test directory copy', () async {
+ final MemoryFileSystem sourceMemoryFs = MemoryFileSystem.test();
+ const String sourcePath = '/some/origin';
+ final Directory sourceDirectory =
+ await sourceMemoryFs.directory(sourcePath).create(recursive: true);
+ sourceMemoryFs.currentDirectory = sourcePath;
+ final File sourceFile1 = sourceMemoryFs.file('some_file.txt')
+ ..writeAsStringSync('bleh');
+ final DateTime writeTime = sourceFile1.lastModifiedSync();
+ sourceMemoryFs
+ .file('sub_dir/another_file.txt')
+ .createSync(recursive: true);
+ sourceMemoryFs.directory('empty_directory').createSync();
+
+ // Copy to another memory file system instance.
+ final MemoryFileSystem targetMemoryFs = MemoryFileSystem.test();
+ const String targetPath = '/some/non-existent/target';
+ final Directory targetDirectory = targetMemoryFs.directory(targetPath);
+
+ copyDirectory(sourceDirectory, targetDirectory);
+
+ expect(targetDirectory.existsSync(), true);
+ targetMemoryFs.currentDirectory = targetPath;
+ expect(targetMemoryFs.directory('empty_directory').existsSync(), true);
+ expect(
+ targetMemoryFs.file('sub_dir/another_file.txt').existsSync(), true);
+ expect(targetMemoryFs.file('some_file.txt').readAsStringSync(), 'bleh');
+
+ // Assert that the copy operation hasn't modified the original file in some way.
+ expect(
+ sourceMemoryFs.file('some_file.txt').lastModifiedSync(), writeTime);
+ // There's still 3 things in the original directory as there were initially.
+ expect(sourceMemoryFs.directory(sourcePath).listSync().length, 3);
+ });
+
+ testWithoutContext('Skip files if shouldCopyFile returns false', () {
+ final MemoryFileSystem fileSystem = MemoryFileSystem.test();
+ final Directory origin = fileSystem.directory('/origin');
+ origin.createSync();
+ fileSystem
+ .file(fileSystem.path.join('origin', 'a.txt'))
+ .writeAsStringSync('irrelevant');
+ fileSystem.directory('/origin/nested').createSync();
+ fileSystem
+ .file(fileSystem.path.join('origin', 'nested', 'a.txt'))
+ .writeAsStringSync('irrelevant');
+ fileSystem
+ .file(fileSystem.path.join('origin', 'nested', 'b.txt'))
+ .writeAsStringSync('irrelevant');
+
+ final Directory destination = fileSystem.directory('/destination');
+ copyDirectory(origin, destination,
+ shouldCopyFile: (File origin, File dest) {
+ return origin.basename == 'b.txt';
+ });
+
+ expect(destination.existsSync(), isTrue);
+ expect(destination.childDirectory('nested').existsSync(), isTrue);
+ expect(
+ destination.childDirectory('nested').childFile('b.txt').existsSync(),
+ isTrue);
+
+ expect(destination.childFile('a.txt').existsSync(), isFalse);
+ expect(
+ destination.childDirectory('nested').childFile('a.txt').existsSync(),
+ isFalse);
+ });
+
+ testWithoutContext('Skip directories if shouldCopyDirectory returns false',
+ () {
+ final MemoryFileSystem fileSystem = MemoryFileSystem.test();
+ final Directory origin = fileSystem.directory('/origin');
+ origin.createSync();
+ fileSystem
+ .file(fileSystem.path.join('origin', 'a.txt'))
+ .writeAsStringSync('irrelevant');
+ fileSystem.directory('/origin/nested').createSync();
+ fileSystem
+ .file(fileSystem.path.join('origin', 'nested', 'a.txt'))
+ .writeAsStringSync('irrelevant');
+ fileSystem
+ .file(fileSystem.path.join('origin', 'nested', 'b.txt'))
+ .writeAsStringSync('irrelevant');
+
+ final Directory destination = fileSystem.directory('/destination');
+ copyDirectory(origin, destination,
+ shouldCopyDirectory: (Directory directory) {
+ return !directory.path.endsWith('nested');
+ });
+
+ expect(destination, exists);
+ expect(destination.childDirectory('nested'), isNot(exists));
+ expect(destination.childDirectory('nested').childFile('b.txt'),
+ isNot(exists));
+ });
+ });
+
+ group('LocalFileSystem', () {
+ late FakeProcessSignal fakeSignal;
+ late ProcessSignal signalUnderTest;
+
+ setUp(() {
+ fakeSignal = FakeProcessSignal();
+ signalUnderTest = ProcessSignal(fakeSignal);
+ });
+
+ testWithoutContext('runs shutdown hooks', () async {
+ final Signals signals = Signals.test();
+ final LocalFileSystem localFileSystem = LocalFileSystem.test(
+ signals: signals,
+ );
+ final Directory temp = localFileSystem.systemTempDirectory;
+
+ expect(temp.existsSync(), isTrue);
+ expect(localFileSystem.shutdownHooks.registeredHooks, hasLength(1));
+ final BufferLogger logger = BufferLogger.test();
+ await localFileSystem.shutdownHooks.runShutdownHooks(logger);
+ expect(temp.existsSync(), isFalse);
+ expect(logger.traceText, contains('Running 1 shutdown hook'));
+ });
+
+ testWithoutContext('deletes system temp entry on a fatal signal', () async {
+ final Completer<void> completer = Completer<void>();
+ final Signals signals = Signals.test();
+ final LocalFileSystem localFileSystem = LocalFileSystem.test(
+ signals: signals,
+ fatalSignals: <ProcessSignal>[signalUnderTest],
+ );
+ final Directory temp = localFileSystem.systemTempDirectory;
+
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ completer.complete();
+ });
+
+ expect(temp.existsSync(), isTrue);
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+
+ expect(temp.existsSync(), isFalse);
+ });
+
+ testWithoutContext('throwToolExit when temp not found', () async {
+ final Signals signals = Signals.test();
+ final LocalFileSystemFake localFileSystem = LocalFileSystemFake.test(
+ signals: signals,
+ );
+
+ try {
+ localFileSystem.systemTempDirectory;
+ fail('expected tool exit');
+ } on ToolExit catch (e) {
+ expect(
+ e.message,
+ 'Your system temp directory (/does_not_exist) does not exist. '
+ 'Did you set an invalid override in your environment? '
+ 'See issue https://github.com/flutter/flutter/issues/74042 for more context.');
+ }
+ });
+ });
+}
+
+class FakeProcessSignal extends Fake implements io.ProcessSignal {
+ final StreamController<io.ProcessSignal> controller =
+ StreamController<io.ProcessSignal>();
+
+ @override
+ Stream<io.ProcessSignal> watch() => controller.stream;
+}
+
+/// Various convenience file system methods.
+class FileSystemUtils {
+ FileSystemUtils({
+ required FileSystem fileSystem,
+ }) : _fileSystem = fileSystem;
+
+ final FileSystem _fileSystem;
+
+ /// Appends a number to a filename in order to make it unique under a
+ /// directory.
+ File getUniqueFile(Directory dir, String baseName, String ext) {
+ final FileSystem fs = dir.fileSystem;
+ int i = 1;
+
+ while (true) {
+ final String name = '${baseName}_${i.toString().padLeft(2, '0')}.$ext';
+ final File file = fs.file(dir.fileSystem.path.join(dir.path, name));
+ if (!file.existsSync()) {
+ file.createSync(recursive: true);
+ return file;
+ }
+ i += 1;
+ }
+ }
+
+ // /// Appends a number to a filename in order to make it unique under a
+ // /// directory.
+ // File getUniqueFile(Directory dir, String baseName, String ext) {
+ // return _getUniqueFile(dir, baseName, ext);
+ // }
+
+ /// Appends a number to a directory name in order to make it unique under a
+ /// directory.
+ Directory getUniqueDirectory(Directory dir, String baseName) {
+ final FileSystem fs = dir.fileSystem;
+ int i = 1;
+
+ while (true) {
+ final String name = '${baseName}_${i.toString().padLeft(2, '0')}';
+ final Directory directory =
+ fs.directory(_fileSystem.path.join(dir.path, name));
+ if (!directory.existsSync()) {
+ return directory;
+ }
+ i += 1;
+ }
+ }
+
+ /// Escapes [path].
+ ///
+ /// On Windows it replaces all '\' with '\\'. On other platforms, it returns the
+ /// path unchanged.
+ String escapePath(String path) =>
+ isWindows ? path.replaceAll(r'\', r'\\') : path;
+
+ /// Returns true if the file system [entity] has not been modified since the
+ /// latest modification to [referenceFile].
+ ///
+ /// Returns true, if [entity] does not exist.
+ ///
+ /// Returns false, if [entity] exists, but [referenceFile] does not.
+ bool isOlderThanReference({
+ required FileSystemEntity entity,
+ required File referenceFile,
+ }) {
+ if (!entity.existsSync()) {
+ return true;
+ }
+ return referenceFile.existsSync() &&
+ referenceFile.statSync().modified.isAfter(entity.statSync().modified);
+ }
+}
+
+/// Creates `destDir` if needed, then recursively copies `srcDir` to
+/// `destDir`, invoking [onFileCopied], if specified, for each
+/// source/destination file pair.
+///
+/// Skips files if [shouldCopyFile] returns `false`.
+/// Does not recurse over directories if [shouldCopyDirectory] returns `false`.
+void copyDirectory(
+ Directory srcDir,
+ Directory destDir, {
+ bool Function(File srcFile, File destFile)? shouldCopyFile,
+ bool Function(Directory)? shouldCopyDirectory,
+ void Function(File srcFile, File destFile)? onFileCopied,
+}) {
+ if (!srcDir.existsSync()) {
+ throw Exception(
+ 'Source directory "${srcDir.path}" does not exist, nothing to copy');
+ }
+
+ if (!destDir.existsSync()) {
+ destDir.createSync(recursive: true);
+ }
+
+ for (final FileSystemEntity entity in srcDir.listSync()) {
+ final String newPath =
+ destDir.fileSystem.path.join(destDir.path, entity.basename);
+ if (entity is Link) {
+ final Link newLink = destDir.fileSystem.link(newPath);
+ newLink.createSync(entity.targetSync());
+ } else if (entity is File) {
+ final File newFile = destDir.fileSystem.file(newPath);
+ if (shouldCopyFile != null && !shouldCopyFile(entity, newFile)) {
+ continue;
+ }
+ newFile.writeAsBytesSync(entity.readAsBytesSync());
+ onFileCopied?.call(entity, newFile);
+ } else if (entity is Directory) {
+ if (shouldCopyDirectory != null && !shouldCopyDirectory(entity)) {
+ continue;
+ }
+ copyDirectory(
+ entity,
+ destDir.fileSystem.directory(newPath),
+ shouldCopyFile: shouldCopyFile,
+ onFileCopied: onFileCopied,
+ );
+ } else {
+ throw Exception(
+ '${entity.path} is neither File nor Directory, was ${entity.runtimeType}');
+ }
+ }
+}
diff --git a/packages/flutter_migrate/test/base/io_test.dart b/packages/flutter_migrate/test/base/io_test.dart
new file mode 100644
index 0000000..608715e
--- /dev/null
+++ b/packages/flutter_migrate/test/base/io_test.dart
@@ -0,0 +1,86 @@
+// 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:io' as io;
+
+import 'package:file/memory.dart';
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:test/fake.dart';
+
+import '../src/common.dart';
+import '../src/io.dart';
+
+void main() {
+ testWithoutContext('IOOverrides can inject a memory file system', () async {
+ final MemoryFileSystem memoryFileSystem = MemoryFileSystem.test();
+ final FlutterIOOverrides flutterIOOverrides =
+ FlutterIOOverrides(fileSystem: memoryFileSystem);
+ await io.IOOverrides.runWithIOOverrides(() async {
+ // statics delegate correctly.
+ expect(io.FileSystemEntity.isWatchSupported,
+ memoryFileSystem.isWatchSupported);
+ expect(io.Directory.systemTemp.path,
+ memoryFileSystem.systemTempDirectory.path);
+
+ // can create and write to files/directories sync.
+ final io.File file = io.File('abc');
+ file.writeAsStringSync('def');
+ final io.Directory directory = io.Directory('foobar');
+ directory.createSync();
+
+ expect(memoryFileSystem.file('abc').existsSync(), true);
+ expect(memoryFileSystem.file('abc').readAsStringSync(), 'def');
+ expect(memoryFileSystem.directory('foobar').existsSync(), true);
+
+ // can create and write to files/directories async.
+ final io.File fileB = io.File('xyz');
+ await fileB.writeAsString('def');
+ final io.Directory directoryB = io.Directory('barfoo');
+ await directoryB.create();
+
+ expect(memoryFileSystem.file('xyz').existsSync(), true);
+ expect(memoryFileSystem.file('xyz').readAsStringSync(), 'def');
+ expect(memoryFileSystem.directory('barfoo').existsSync(), true);
+
+ // Links
+ final io.Link linkA = io.Link('hhh');
+ final io.Link linkB = io.Link('ggg');
+ io.File('jjj').createSync();
+ io.File('lll').createSync();
+ await linkA.create('jjj');
+ linkB.createSync('lll');
+
+ expect(await memoryFileSystem.link('hhh').resolveSymbolicLinks(),
+ await linkA.resolveSymbolicLinks());
+ expect(memoryFileSystem.link('ggg').resolveSymbolicLinksSync(),
+ linkB.resolveSymbolicLinksSync());
+ }, flutterIOOverrides);
+ });
+
+ testWithoutContext('ProcessSignal signals are properly delegated', () async {
+ final FakeProcessSignal signal = FakeProcessSignal();
+ final ProcessSignal signalUnderTest = ProcessSignal(signal);
+
+ signal.controller.add(signal);
+
+ expect(signalUnderTest, await signalUnderTest.watch().first);
+ });
+
+ testWithoutContext('ProcessSignal toString() works', () async {
+ expect(io.ProcessSignal.sigint.toString(), ProcessSignal.sigint.toString());
+ });
+
+ testWithoutContext('test_api defines the Declarer in a known place', () {
+ expect(Zone.current[#test.declarer], isNotNull);
+ });
+}
+
+class FakeProcessSignal extends Fake implements io.ProcessSignal {
+ final StreamController<io.ProcessSignal> controller =
+ StreamController<io.ProcessSignal>();
+
+ @override
+ Stream<io.ProcessSignal> watch() => controller.stream;
+}
diff --git a/packages/flutter_migrate/test/base/logger_test.dart b/packages/flutter_migrate/test/base/logger_test.dart
new file mode 100644
index 0000000..da05522
--- /dev/null
+++ b/packages/flutter_migrate/test/base/logger_test.dart
@@ -0,0 +1,679 @@
+// 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 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/logger.dart';
+import 'package:flutter_migrate/src/base/terminal.dart';
+import 'package:test/fake.dart';
+
+import '../src/common.dart';
+import '../src/fakes.dart';
+
+// final Platform _kNoAnsiPlatform = FakePlatform();
+final String red = RegExp.escape(AnsiTerminal.red);
+final String bold = RegExp.escape(AnsiTerminal.bold);
+final String resetBold = RegExp.escape(AnsiTerminal.resetBold);
+final String resetColor = RegExp.escape(AnsiTerminal.resetColor);
+
+void main() {
+ testWithoutContext('correct logger instance is created', () {
+ final LoggerFactory loggerFactory = LoggerFactory(
+ terminal: Terminal.test(),
+ stdio: FakeStdio(),
+ outputPreferences: OutputPreferences.test(),
+ );
+
+ expect(
+ loggerFactory.createLogger(
+ windows: false,
+ ),
+ isA<StdoutLogger>());
+ expect(
+ loggerFactory.createLogger(
+ windows: true,
+ ),
+ isA<WindowsStdoutLogger>());
+ });
+
+ testWithoutContext(
+ 'WindowsStdoutLogger rewrites emojis when terminal does not support emoji',
+ () {
+ final FakeStdio stdio = FakeStdio();
+ final WindowsStdoutLogger logger = WindowsStdoutLogger(
+ outputPreferences: OutputPreferences.test(),
+ stdio: stdio,
+ terminal: Terminal.test(supportsColor: false, supportsEmoji: false),
+ );
+
+ logger.printStatus('🔥🖼️✗✓🔨💪✏️');
+
+ expect(stdio.writtenToStdout, <String>['X√\n']);
+ });
+
+ testWithoutContext(
+ 'WindowsStdoutLogger does not rewrite emojis when terminal does support emoji',
+ () {
+ final FakeStdio stdio = FakeStdio();
+ final WindowsStdoutLogger logger = WindowsStdoutLogger(
+ outputPreferences: OutputPreferences.test(),
+ stdio: stdio,
+ terminal: Terminal.test(supportsColor: true, supportsEmoji: true),
+ );
+
+ logger.printStatus('🔥🖼️✗✓🔨💪✏️');
+
+ expect(stdio.writtenToStdout, <String>['🔥🖼️✗✓🔨💪✏️\n']);
+ });
+ testWithoutContext(
+ 'Logger does not throw when stdio write throws synchronously', () async {
+ final FakeStdout stdout = FakeStdout(syncError: true);
+ final FakeStdout stderr = FakeStdout(syncError: true);
+ final Stdio stdio = Stdio.test(stdout: stdout, stderr: stderr);
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: stdio,
+ ),
+ stdio: stdio,
+ outputPreferences: OutputPreferences.test(),
+ );
+
+ logger.printStatus('message');
+ logger.printError('error message');
+ });
+
+ testWithoutContext(
+ 'Logger does not throw when stdio write throws asynchronously', () async {
+ final FakeStdout stdout = FakeStdout(syncError: false);
+ final FakeStdout stderr = FakeStdout(syncError: false);
+ final Stdio stdio = Stdio.test(stdout: stdout, stderr: stderr);
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: stdio,
+ ),
+ stdio: stdio,
+ outputPreferences: OutputPreferences.test(),
+ );
+ logger.printStatus('message');
+ logger.printError('error message');
+
+ await stdout.done;
+ await stderr.done;
+ });
+
+ testWithoutContext(
+ 'Logger does not throw when stdio completes done with an error',
+ () async {
+ final FakeStdout stdout =
+ FakeStdout(syncError: false, completeWithError: true);
+ final FakeStdout stderr =
+ FakeStdout(syncError: false, completeWithError: true);
+ final Stdio stdio = Stdio.test(stdout: stdout, stderr: stderr);
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: stdio,
+ ),
+ stdio: stdio,
+ outputPreferences: OutputPreferences.test(),
+ );
+ logger.printStatus('message');
+ logger.printError('error message');
+
+ expect(() async => stdout.done, throwsException);
+ expect(() async => stderr.done, throwsException);
+ });
+
+ group('Output format', () {
+ late FakeStdio fakeStdio;
+ late SummaryStatus summaryStatus;
+ late int called;
+
+ setUp(() {
+ fakeStdio = FakeStdio();
+ called = 0;
+ summaryStatus = SummaryStatus(
+ message: 'Hello world',
+ padding: 20,
+ onFinish: () => called++,
+ stdio: fakeStdio,
+ stopwatch: FakeStopwatch(),
+ );
+ });
+
+ List<String> outputStdout() => fakeStdio.writtenToStdout.join().split('\n');
+ List<String> outputStderr() => fakeStdio.writtenToStderr.join().split('\n');
+
+ testWithoutContext('Error logs are wrapped', () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printError('0123456789' * 15);
+ final List<String> lines = outputStderr();
+
+ expect(outputStdout().length, equals(1));
+ expect(outputStdout().first, isEmpty);
+ expect(lines[0], equals('0123456789' * 4));
+ expect(lines[1], equals('0123456789' * 4));
+ expect(lines[2], equals('0123456789' * 4));
+ expect(lines[3], equals('0123456789' * 3));
+ });
+
+ testWithoutContext('Error logs are wrapped and can be indented.', () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printError('0123456789' * 15, indent: 5);
+ final List<String> lines = outputStderr();
+
+ expect(outputStdout().length, equals(1));
+ expect(outputStdout().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals(' 01234567890123456789012345678901234'));
+ expect(lines[1], equals(' 56789012345678901234567890123456789'));
+ expect(lines[2], equals(' 01234567890123456789012345678901234'));
+ expect(lines[3], equals(' 56789012345678901234567890123456789'));
+ expect(lines[4], equals(' 0123456789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext('Error logs are wrapped and can have hanging indent.',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printError('0123456789' * 15, hangingIndent: 5);
+ final List<String> lines = outputStderr();
+
+ expect(outputStdout().length, equals(1));
+ expect(outputStdout().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals('0123456789012345678901234567890123456789'));
+ expect(lines[1], equals(' 01234567890123456789012345678901234'));
+ expect(lines[2], equals(' 56789012345678901234567890123456789'));
+ expect(lines[3], equals(' 01234567890123456789012345678901234'));
+ expect(lines[4], equals(' 56789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext(
+ 'Error logs are wrapped, indented, and can have hanging indent.',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printError('0123456789' * 15, indent: 4, hangingIndent: 5);
+ final List<String> lines = outputStderr();
+
+ expect(outputStdout().length, equals(1));
+ expect(outputStdout().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals(' 012345678901234567890123456789012345'));
+ expect(lines[1], equals(' 6789012345678901234567890123456'));
+ expect(lines[2], equals(' 7890123456789012345678901234567'));
+ expect(lines[3], equals(' 8901234567890123456789012345678'));
+ expect(lines[4], equals(' 901234567890123456789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext('Stdout logs are wrapped', () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printStatus('0123456789' * 15);
+ final List<String> lines = outputStdout();
+
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ expect(lines[0], equals('0123456789' * 4));
+ expect(lines[1], equals('0123456789' * 4));
+ expect(lines[2], equals('0123456789' * 4));
+ expect(lines[3], equals('0123456789' * 3));
+ });
+
+ testWithoutContext('Stdout logs are wrapped and can be indented.',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printStatus('0123456789' * 15, indent: 5);
+ final List<String> lines = outputStdout();
+
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals(' 01234567890123456789012345678901234'));
+ expect(lines[1], equals(' 56789012345678901234567890123456789'));
+ expect(lines[2], equals(' 01234567890123456789012345678901234'));
+ expect(lines[3], equals(' 56789012345678901234567890123456789'));
+ expect(lines[4], equals(' 0123456789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext('Stdout logs are wrapped and can have hanging indent.',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40));
+ logger.printStatus('0123456789' * 15, hangingIndent: 5);
+ final List<String> lines = outputStdout();
+
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals('0123456789012345678901234567890123456789'));
+ expect(lines[1], equals(' 01234567890123456789012345678901234'));
+ expect(lines[2], equals(' 56789012345678901234567890123456789'));
+ expect(lines[3], equals(' 01234567890123456789012345678901234'));
+ expect(lines[4], equals(' 56789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext(
+ 'Stdout logs are wrapped, indented, and can have hanging indent.',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ );
+ logger.printStatus('0123456789' * 15, indent: 4, hangingIndent: 5);
+ final List<String> lines = outputStdout();
+
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ expect(lines.length, equals(6));
+ expect(lines[0], equals(' 012345678901234567890123456789012345'));
+ expect(lines[1], equals(' 6789012345678901234567890123456'));
+ expect(lines[2], equals(' 7890123456789012345678901234567'));
+ expect(lines[3], equals(' 8901234567890123456789012345678'));
+ expect(lines[4], equals(' 901234567890123456789'));
+ expect(lines[5], isEmpty);
+ });
+
+ testWithoutContext('Error logs are red', () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ supportsColor: true,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ logger.printError('Pants on fire!');
+ final List<String> lines = outputStderr();
+
+ expect(outputStdout().length, equals(1));
+ expect(outputStdout().first, isEmpty);
+ expect(
+ lines[0],
+ equals(
+ '${AnsiTerminal.red}Pants on fire!${AnsiTerminal.resetColor}'));
+ });
+
+ testWithoutContext('Stdout logs are not colored', () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ logger.printStatus('All good.');
+
+ final List<String> lines = outputStdout();
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ expect(lines[0], equals('All good.'));
+ });
+
+ testWithoutContext('Stdout printBox puts content inside a box', () {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ logger.printBox('Hello world', title: 'Test title');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test title ┐\n'
+ '│ Hello world │\n'
+ '└─────────────┘\n'),
+ );
+ });
+
+ testWithoutContext('Stdout printBox does not require title', () {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ logger.printBox('Hello world');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ expect(
+ stdout,
+ contains('\n'
+ '┌─────────────┐\n'
+ '│ Hello world │\n'
+ '└─────────────┘\n'),
+ );
+ });
+
+ testWithoutContext('Stdout printBox handles new lines', () {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ logger.printBox('Hello world\nThis is a new line', title: 'Test title');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test title ───────┐\n'
+ '│ Hello world │\n'
+ '│ This is a new line │\n'
+ '└────────────────────┘\n'),
+ );
+ });
+
+ testWithoutContext(
+ 'Stdout printBox handles content with ANSI escape characters', () {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(showColor: true),
+ );
+ const String bold = '\u001B[1m';
+ const String clear = '\u001B[2J\u001B[H';
+ logger.printBox('${bold}Hello world$clear', title: 'Test title');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test title ┐\n'
+ '│ ${bold}Hello world$clear │\n'
+ '└─────────────┘\n'),
+ );
+ });
+
+ testWithoutContext('Stdout printBox handles column limit', () {
+ const int columnLimit = 14;
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(showColor: true, wrapColumn: columnLimit),
+ );
+ logger.printBox('This line is longer than $columnLimit characters',
+ title: 'Test');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ final List<String> stdoutLines = stdout.split('\n');
+
+ expect(stdoutLines.length, greaterThan(1));
+ expect(stdoutLines[1].length, equals(columnLimit));
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test ─────┐\n'
+ '│ This line │\n'
+ '│ is longer │\n'
+ '│ than 14 │\n'
+ '│ characters │\n'
+ '└────────────┘\n'),
+ );
+ });
+
+ testWithoutContext(
+ 'Stdout printBox handles column limit and respects new lines', () {
+ const int columnLimit = 14;
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(showColor: true, wrapColumn: columnLimit),
+ );
+ logger.printBox('This\nline is longer than\n\n$columnLimit characters',
+ title: 'Test');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ final List<String> stdoutLines = stdout.split('\n');
+
+ expect(stdoutLines.length, greaterThan(1));
+ expect(stdoutLines[1].length, equals(columnLimit));
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test ─────┐\n'
+ '│ This │\n'
+ '│ line is │\n'
+ '│ longer │\n'
+ '│ than │\n'
+ '│ │\n'
+ '│ 14 │\n'
+ '│ characters │\n'
+ '└────────────┘\n'),
+ );
+ });
+
+ testWithoutContext(
+ 'Stdout printBox breaks long words that exceed the column limit', () {
+ const int columnLimit = 14;
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences:
+ OutputPreferences.test(showColor: true, wrapColumn: columnLimit),
+ );
+ logger.printBox('Thiswordislongerthan${columnLimit}characters',
+ title: 'Test');
+ final String stdout = fakeStdio.writtenToStdout.join();
+ final List<String> stdoutLines = stdout.split('\n');
+
+ expect(stdoutLines.length, greaterThan(1));
+ expect(stdoutLines[1].length, equals(columnLimit));
+ expect(
+ stdout,
+ contains('\n'
+ '┌─ Test ─────┐\n'
+ '│ Thiswordis │\n'
+ '│ longerthan │\n'
+ '│ 14characte │\n'
+ '│ rs │\n'
+ '└────────────┘\n'),
+ );
+ });
+
+ testWithoutContext('Stdout startProgress on non-color terminal', () async {
+ final FakeStopwatch fakeStopwatch = FakeStopwatch();
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(),
+ stopwatchFactory: FakeStopwatchFactory(stopwatch: fakeStopwatch),
+ );
+ final Status status = logger.startProgress(
+ 'Hello',
+ progressIndicatorPadding:
+ 20, // this minus the "Hello" equals the 15 below.
+ );
+ expect(outputStderr().length, equals(1));
+ expect(outputStderr().first, isEmpty);
+ // the 5 below is the margin that is always included between the message and the time.
+ expect(outputStdout().join('\n'), matches(r'^Hello {15} {5}$'));
+
+ fakeStopwatch.elapsed = const Duration(seconds: 4, milliseconds: 123);
+ status.stop();
+
+ expect(outputStdout(), <String>['Hello 4.1s', '']);
+ });
+
+ testWithoutContext('SummaryStatus works when canceled', () async {
+ final SummaryStatus summaryStatus = SummaryStatus(
+ message: 'Hello world',
+ padding: 20,
+ onFinish: () => called++,
+ stdio: fakeStdio,
+ stopwatch: FakeStopwatch(),
+ );
+ summaryStatus.start();
+ final List<String> lines = outputStdout();
+ expect(lines[0], startsWith('Hello world '));
+ expect(lines.length, equals(1));
+ expect(lines[0].endsWith('\n'), isFalse);
+
+ // Verify a cancel does _not_ print the time and prints a newline.
+ summaryStatus.cancel();
+ expect(outputStdout(), <String>[
+ 'Hello world ',
+ '',
+ ]);
+
+ // Verify that stopping or canceling multiple times throws.
+ expect(summaryStatus.cancel, throwsAssertionError);
+ expect(summaryStatus.stop, throwsAssertionError);
+ });
+
+ testWithoutContext('SummaryStatus works when stopped', () async {
+ summaryStatus.start();
+ final List<String> lines = outputStdout();
+ expect(lines[0], startsWith('Hello world '));
+ expect(lines.length, equals(1));
+
+ // Verify a stop prints the time.
+ summaryStatus.stop();
+ expect(outputStdout(), <String>[
+ 'Hello world 0ms',
+ '',
+ ]);
+
+ // Verify that stopping or canceling multiple times throws.
+ expect(summaryStatus.stop, throwsAssertionError);
+ expect(summaryStatus.cancel, throwsAssertionError);
+ });
+
+ testWithoutContext('sequential startProgress calls with StdoutLogger',
+ () async {
+ final Logger logger = StdoutLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ stdio: fakeStdio,
+ outputPreferences: OutputPreferences.test(),
+ );
+ logger.startProgress('AAA').stop();
+ logger.startProgress('BBB').stop();
+ final List<String> output = outputStdout();
+
+ expect(output.length, equals(3));
+
+ // There's 61 spaces at the start: 59 (padding default) - 3 (length of AAA) + 5 (margin).
+ // Then there's a left-padded "0ms" 8 characters wide, so 5 spaces then "0ms"
+ // (except sometimes it's randomly slow so we handle up to "99,999ms").
+ expect(output[0], matches(RegExp(r'AAA[ ]{61}[\d, ]{5}[\d]ms')));
+ expect(output[1], matches(RegExp(r'BBB[ ]{61}[\d, ]{5}[\d]ms')));
+ });
+
+ testWithoutContext('sequential startProgress calls with BufferLogger',
+ () async {
+ final BufferLogger logger = BufferLogger(
+ terminal: AnsiTerminal(
+ stdio: fakeStdio,
+ ),
+ outputPreferences: OutputPreferences.test(),
+ );
+ logger.startProgress('AAA').stop();
+ logger.startProgress('BBB').stop();
+
+ expect(logger.statusText, 'AAA\nBBB\n');
+ });
+ });
+}
+
+/// A fake [Logger] that throws the [Invocation] for any method call.
+class FakeLogger implements Logger {
+ @override
+ dynamic noSuchMethod(Invocation invocation) =>
+ throw invocation; // ignore: only_throw_errors
+}
+
+class FakeStdout extends Fake implements Stdout {
+ FakeStdout({required this.syncError, this.completeWithError = false});
+
+ final bool syncError;
+ final bool completeWithError;
+ final Completer<void> _completer = Completer<void>();
+
+ @override
+ void write(Object? object) {
+ if (syncError) {
+ throw Exception('Error!');
+ }
+ Zone.current.runUnaryGuarded<void>((_) {
+ if (completeWithError) {
+ _completer.completeError(Exception('Some pipe error'));
+ } else {
+ _completer.complete();
+ throw Exception('Error!');
+ }
+ }, null);
+ }
+
+ @override
+ Future<void> get done => _completer.future;
+}
diff --git a/packages/flutter_migrate/test/base/signals_test.dart b/packages/flutter_migrate/test/base/signals_test.dart
new file mode 100644
index 0000000..87f0d04
--- /dev/null
+++ b/packages/flutter_migrate/test/base/signals_test.dart
@@ -0,0 +1,181 @@
+// 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:io' as io;
+
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/signals.dart';
+import 'package:test/fake.dart';
+
+import '../src/common.dart';
+
+void main() {
+ group('Signals', () {
+ late Signals signals;
+ late FakeProcessSignal fakeSignal;
+ late ProcessSignal signalUnderTest;
+
+ setUp(() {
+ signals = Signals.test();
+ fakeSignal = FakeProcessSignal();
+ signalUnderTest = ProcessSignal(fakeSignal);
+ });
+
+ testWithoutContext('signal handler runs', () async {
+ final Completer<void> completer = Completer<void>();
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ expect(s, signalUnderTest);
+ completer.complete();
+ });
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ });
+
+ testWithoutContext('signal handlers run in order', () async {
+ final Completer<void> completer = Completer<void>();
+
+ bool first = false;
+
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ expect(s, signalUnderTest);
+ first = true;
+ });
+
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ expect(s, signalUnderTest);
+ expect(first, isTrue);
+ completer.complete();
+ });
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ });
+
+ testWithoutContext(
+ 'signal handlers do not cause concurrent modification errors when removing handlers in a signal callback',
+ () async {
+ final Completer<void> completer = Completer<void>();
+ late Object token;
+ Future<void> handle(ProcessSignal s) async {
+ expect(s, signalUnderTest);
+ expect(await signals.removeHandler(signalUnderTest, token), true);
+ completer.complete();
+ }
+
+ token = signals.addHandler(signalUnderTest, handle);
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ });
+
+ testWithoutContext('signal handler error goes on error stream', () async {
+ final Exception exn = Exception('Error');
+ signals.addHandler(signalUnderTest, (ProcessSignal s) async {
+ throw exn;
+ });
+
+ final Completer<void> completer = Completer<void>();
+ final List<Object> errList = <Object>[];
+ final StreamSubscription<Object> errSub = signals.errors.listen(
+ (Object err) {
+ errList.add(err);
+ completer.complete();
+ },
+ );
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ await errSub.cancel();
+ expect(errList, contains(exn));
+ });
+
+ testWithoutContext('removed signal handler does not run', () async {
+ final Object token = signals.addHandler(
+ signalUnderTest,
+ (ProcessSignal s) async {
+ fail('Signal handler should have been removed.');
+ },
+ );
+
+ await signals.removeHandler(signalUnderTest, token);
+
+ final List<Object> errList = <Object>[];
+ final StreamSubscription<Object> errSub = signals.errors.listen(
+ (Object err) {
+ errList.add(err);
+ },
+ );
+
+ fakeSignal.controller.add(fakeSignal);
+
+ await errSub.cancel();
+ expect(errList, isEmpty);
+ });
+
+ testWithoutContext('non-removed signal handler still runs', () async {
+ final Completer<void> completer = Completer<void>();
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ expect(s, signalUnderTest);
+ completer.complete();
+ });
+
+ final Object token = signals.addHandler(
+ signalUnderTest,
+ (ProcessSignal s) async {
+ fail('Signal handler should have been removed.');
+ },
+ );
+ await signals.removeHandler(signalUnderTest, token);
+
+ final List<Object> errList = <Object>[];
+ final StreamSubscription<Object> errSub = signals.errors.listen(
+ (Object err) {
+ errList.add(err);
+ },
+ );
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ await errSub.cancel();
+ expect(errList, isEmpty);
+ });
+
+ testWithoutContext('only handlers for the correct signal run', () async {
+ final FakeProcessSignal mockSignal2 = FakeProcessSignal();
+ final ProcessSignal otherSignal = ProcessSignal(mockSignal2);
+
+ final Completer<void> completer = Completer<void>();
+ signals.addHandler(signalUnderTest, (ProcessSignal s) {
+ expect(s, signalUnderTest);
+ completer.complete();
+ });
+
+ signals.addHandler(otherSignal, (ProcessSignal s) async {
+ fail('Wrong signal!.');
+ });
+
+ final List<Object> errList = <Object>[];
+ final StreamSubscription<Object> errSub = signals.errors.listen(
+ (Object err) {
+ errList.add(err);
+ },
+ );
+
+ fakeSignal.controller.add(fakeSignal);
+ await completer.future;
+ await errSub.cancel();
+ expect(errList, isEmpty);
+ });
+ });
+}
+
+class FakeProcessSignal extends Fake implements io.ProcessSignal {
+ final StreamController<io.ProcessSignal> controller =
+ StreamController<io.ProcessSignal>();
+
+ @override
+ Stream<io.ProcessSignal> watch() => controller.stream;
+}
diff --git a/packages/flutter_migrate/test/base/terminal_test.dart b/packages/flutter_migrate/test/base/terminal_test.dart
new file mode 100644
index 0000000..6686ec2
--- /dev/null
+++ b/packages/flutter_migrate/test/base/terminal_test.dart
@@ -0,0 +1,331 @@
+// 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 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/logger.dart';
+import 'package:flutter_migrate/src/base/terminal.dart';
+import 'package:test/fake.dart';
+
+import '../src/common.dart';
+
+void main() {
+ group('output preferences', () {
+ testWithoutContext('can wrap output', () async {
+ final BufferLogger bufferLogger = BufferLogger(
+ outputPreferences:
+ OutputPreferences.test(wrapText: true, wrapColumn: 40),
+ terminal: TestTerminal(),
+ );
+ bufferLogger.printStatus('0123456789' * 8);
+
+ expect(bufferLogger.statusText, equals(('${'0123456789' * 4}\n') * 2));
+ });
+
+ testWithoutContext('can turn off wrapping', () async {
+ final BufferLogger bufferLogger = BufferLogger(
+ outputPreferences: OutputPreferences.test(),
+ terminal: TestTerminal(),
+ );
+ final String testString = '0123456789' * 20;
+ bufferLogger.printStatus(testString);
+
+ expect(bufferLogger.statusText, equals('$testString\n'));
+ });
+ });
+
+ group('ANSI coloring and bold', () {
+ late AnsiTerminal terminal;
+
+ setUp(() {
+ terminal = AnsiTerminal(
+ stdio: Stdio(), // Danger, using real stdio.
+ supportsColor: true,
+ );
+ });
+
+ testWithoutContext('adding colors works', () {
+ for (final TerminalColor color in TerminalColor.values) {
+ expect(
+ terminal.color('output', color),
+ equals(
+ '${AnsiTerminal.colorCode(color)}output${AnsiTerminal.resetColor}'),
+ );
+ }
+ });
+
+ testWithoutContext('adding bold works', () {
+ expect(
+ terminal.bolden('output'),
+ equals('${AnsiTerminal.bold}output${AnsiTerminal.resetBold}'),
+ );
+ });
+
+ testWithoutContext('nesting bold within color works', () {
+ expect(
+ terminal.color(terminal.bolden('output'), TerminalColor.blue),
+ equals(
+ '${AnsiTerminal.blue}${AnsiTerminal.bold}output${AnsiTerminal.resetBold}${AnsiTerminal.resetColor}'),
+ );
+ expect(
+ terminal.color('non-bold ${terminal.bolden('output')} also non-bold',
+ TerminalColor.blue),
+ equals(
+ '${AnsiTerminal.blue}non-bold ${AnsiTerminal.bold}output${AnsiTerminal.resetBold} also non-bold${AnsiTerminal.resetColor}'),
+ );
+ });
+
+ testWithoutContext('nesting color within bold works', () {
+ expect(
+ terminal.bolden(terminal.color('output', TerminalColor.blue)),
+ equals(
+ '${AnsiTerminal.bold}${AnsiTerminal.blue}output${AnsiTerminal.resetColor}${AnsiTerminal.resetBold}'),
+ );
+ expect(
+ terminal.bolden(
+ 'non-color ${terminal.color('output', TerminalColor.blue)} also non-color'),
+ equals(
+ '${AnsiTerminal.bold}non-color ${AnsiTerminal.blue}output${AnsiTerminal.resetColor} also non-color${AnsiTerminal.resetBold}'),
+ );
+ });
+
+ testWithoutContext('nesting color within color works', () {
+ expect(
+ terminal.color(terminal.color('output', TerminalColor.blue),
+ TerminalColor.magenta),
+ equals(
+ '${AnsiTerminal.magenta}${AnsiTerminal.blue}output${AnsiTerminal.resetColor}${AnsiTerminal.magenta}${AnsiTerminal.resetColor}'),
+ );
+ expect(
+ terminal.color(
+ 'magenta ${terminal.color('output', TerminalColor.blue)} also magenta',
+ TerminalColor.magenta),
+ equals(
+ '${AnsiTerminal.magenta}magenta ${AnsiTerminal.blue}output${AnsiTerminal.resetColor}${AnsiTerminal.magenta} also magenta${AnsiTerminal.resetColor}'),
+ );
+ });
+
+ testWithoutContext('nesting bold within bold works', () {
+ expect(
+ terminal.bolden(terminal.bolden('output')),
+ equals('${AnsiTerminal.bold}output${AnsiTerminal.resetBold}'),
+ );
+ expect(
+ terminal.bolden('bold ${terminal.bolden('output')} still bold'),
+ equals(
+ '${AnsiTerminal.bold}bold output still bold${AnsiTerminal.resetBold}'),
+ );
+ });
+ });
+
+ group('character input prompt', () {
+ late AnsiTerminal terminalUnderTest;
+
+ setUp(() {
+ terminalUnderTest = TestTerminal(stdio: FakeStdio());
+ });
+
+ testWithoutContext('character prompt throws if usesTerminalUi is false',
+ () async {
+ expect(
+ terminalUnderTest.promptForCharInput(
+ <String>['a', 'b', 'c'],
+ prompt: 'Please choose something',
+ logger: BufferLogger.test(),
+ ),
+ throwsStateError);
+ });
+
+ testWithoutContext('character prompt', () async {
+ final BufferLogger bufferLogger = BufferLogger(
+ terminal: terminalUnderTest,
+ outputPreferences: OutputPreferences.test(),
+ );
+ terminalUnderTest.usesTerminalUi = true;
+ mockStdInStream = Stream<String>.fromFutures(<Future<String>>[
+ Future<String>.value('d'), // Not in accepted list.
+ Future<String>.value('\n'), // Not in accepted list
+ Future<String>.value('b'),
+ ]).asBroadcastStream();
+ final String choice = await terminalUnderTest.promptForCharInput(
+ <String>['a', 'b', 'c'],
+ prompt: 'Please choose something',
+ logger: bufferLogger,
+ );
+ expect(choice, 'b');
+ expect(
+ bufferLogger.statusText,
+ 'Please choose something [a|b|c]: d\n'
+ 'Please choose something [a|b|c]: \n'
+ 'Please choose something [a|b|c]: b\n');
+ });
+
+ testWithoutContext(
+ 'default character choice without displayAcceptedCharacters', () async {
+ final BufferLogger bufferLogger = BufferLogger(
+ terminal: terminalUnderTest,
+ outputPreferences: OutputPreferences.test(),
+ );
+ terminalUnderTest.usesTerminalUi = true;
+ mockStdInStream = Stream<String>.fromFutures(<Future<String>>[
+ Future<String>.value('\n'), // Not in accepted list
+ ]).asBroadcastStream();
+ final String choice = await terminalUnderTest.promptForCharInput(
+ <String>['a', 'b', 'c'],
+ prompt: 'Please choose something',
+ displayAcceptedCharacters: false,
+ defaultChoiceIndex: 1, // which is b.
+ logger: bufferLogger,
+ );
+
+ expect(choice, 'b');
+ expect(bufferLogger.statusText, 'Please choose something: \n');
+ });
+
+ testWithoutContext(
+ 'Does not set single char mode when a terminal is not attached', () {
+ final Stdio stdio = FakeStdio()..stdinHasTerminal = false;
+ final AnsiTerminal ansiTerminal = AnsiTerminal(
+ stdio: stdio,
+ );
+
+ expect(() => ansiTerminal.singleCharMode = true, returnsNormally);
+ });
+ });
+
+ testWithoutContext('AnsiTerminal.preferredStyle', () {
+ final Stdio stdio = FakeStdio();
+ expect(AnsiTerminal(stdio: stdio).preferredStyle,
+ 0); // Defaults to 0 for backwards compatibility.
+
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018)).preferredStyle, 0);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 2)).preferredStyle,
+ 1);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 3)).preferredStyle,
+ 2);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 4)).preferredStyle,
+ 3);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 5)).preferredStyle,
+ 4);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 6)).preferredStyle,
+ 5);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 7)).preferredStyle,
+ 5);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 8)).preferredStyle,
+ 0);
+ expect(AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 9)).preferredStyle,
+ 1);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 10)).preferredStyle,
+ 2);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 11)).preferredStyle,
+ 3);
+
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 1, 1)).preferredStyle,
+ 0);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 2, 1)).preferredStyle,
+ 1);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 3, 1)).preferredStyle,
+ 2);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 4, 1)).preferredStyle,
+ 3);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 5, 1)).preferredStyle,
+ 4);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 6, 1)).preferredStyle,
+ 6);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 7, 1)).preferredStyle,
+ 6);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 8, 1)).preferredStyle,
+ 0);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 9, 1)).preferredStyle,
+ 1);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 10, 1))
+ .preferredStyle,
+ 2);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 11, 1))
+ .preferredStyle,
+ 3);
+
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 1, 23))
+ .preferredStyle,
+ 0);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 2, 23))
+ .preferredStyle,
+ 1);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 3, 23))
+ .preferredStyle,
+ 2);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 4, 23))
+ .preferredStyle,
+ 3);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 5, 23))
+ .preferredStyle,
+ 4);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 6, 23))
+ .preferredStyle,
+ 28);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 7, 23))
+ .preferredStyle,
+ 28);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 8, 23))
+ .preferredStyle,
+ 0);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 9, 23))
+ .preferredStyle,
+ 1);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 10, 23))
+ .preferredStyle,
+ 2);
+ expect(
+ AnsiTerminal(stdio: stdio, now: DateTime(2018, 1, 11, 23))
+ .preferredStyle,
+ 3);
+ });
+}
+
+late Stream<String> mockStdInStream;
+
+class TestTerminal extends AnsiTerminal {
+ TestTerminal({
+ Stdio? stdio,
+ DateTime? now,
+ }) : super(stdio: stdio ?? Stdio(), now: now ?? DateTime(2018));
+
+ @override
+ Stream<String> get keystrokes {
+ return mockStdInStream;
+ }
+
+ @override
+ bool singleCharMode = false;
+
+ @override
+ int get preferredStyle => 0;
+}
+
+class FakeStdio extends Fake implements Stdio {
+ @override
+ bool stdinHasTerminal = false;
+}
diff --git a/packages/flutter_migrate/test/src/common.dart b/packages/flutter_migrate/test/src/common.dart
new file mode 100644
index 0000000..40e55b0
--- /dev/null
+++ b/packages/flutter_migrate/test/src/common.dart
@@ -0,0 +1,200 @@
+// 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:io' as io;
+
+import 'package:flutter_migrate/src/base/context.dart';
+import 'package:flutter_migrate/src/base/file_system.dart';
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:meta/meta.dart';
+import 'package:path/path.dart' as path; // flutter_ignore: package_path_import
+import 'package:test_api/test_api.dart' // ignore: deprecated_member_use
+ as test_package show test;
+import 'package:test_api/test_api.dart' // ignore: deprecated_member_use
+ hide
+ test;
+
+import 'test_utils.dart';
+
+export 'package:test_api/test_api.dart' // ignore: deprecated_member_use
+ hide
+ isInstanceOf,
+ test;
+
+void tryToDelete(FileSystemEntity fileEntity) {
+ // This should not be necessary, but it turns out that
+ // on Windows it's common for deletions to fail due to
+ // bogus (we think) "access denied" errors.
+ try {
+ if (fileEntity.existsSync()) {
+ fileEntity.deleteSync(recursive: true);
+ }
+ } on FileSystemException catch (error) {
+ // We print this so that it's visible in the logs, to get an idea of how
+ // common this problem is, and if any patterns are ever noticed by anyone.
+ // ignore: avoid_print
+ print('Failed to delete ${fileEntity.path}: $error');
+ }
+}
+
+/// Gets the path to the root of the Flutter repository.
+///
+/// This will first look for a `FLUTTER_ROOT` environment variable. If the
+/// environment variable is set, it will be returned. Otherwise, this will
+/// deduce the path from `platform.script`.
+String getFlutterRoot() {
+ if (io.Platform.environment.containsKey('FLUTTER_ROOT')) {
+ return io.Platform.environment['FLUTTER_ROOT']!;
+ }
+
+ Error invalidScript() => StateError(
+ 'Could not determine flutter_tools/ path from script URL (${io.Platform.script}); consider setting FLUTTER_ROOT explicitly.');
+
+ Uri scriptUri;
+ switch (io.Platform.script.scheme) {
+ case 'file':
+ scriptUri = io.Platform.script;
+ break;
+ case 'data':
+ final RegExp flutterTools = RegExp(
+ r'(file://[^"]*[/\\]flutter_tools[/\\][^"]+\.dart)',
+ multiLine: true);
+ final Match? match =
+ flutterTools.firstMatch(Uri.decodeFull(io.Platform.script.path));
+ if (match == null) {
+ throw invalidScript();
+ }
+ scriptUri = Uri.parse(match.group(1)!);
+ break;
+ default:
+ throw invalidScript();
+ }
+
+ final List<String> parts = path.split(fileSystem.path.fromUri(scriptUri));
+ final int toolsIndex = parts.indexOf('flutter_tools');
+ if (toolsIndex == -1) {
+ throw invalidScript();
+ }
+ final String toolsPath = path.joinAll(parts.sublist(0, toolsIndex + 1));
+ return path.normalize(path.join(toolsPath, '..', '..'));
+}
+
+String getMigratePackageRoot() {
+ return io.Directory.current.path;
+}
+
+String getMigrateMain() {
+ return fileSystem.path
+ .join(getMigratePackageRoot(), 'bin', 'flutter_migrate.dart');
+}
+
+Future<ProcessResult> runMigrateCommand(List<String> args,
+ {String? workingDirectory}) {
+ final List<String> commandArgs = <String>['dart', 'run', getMigrateMain()];
+ commandArgs.addAll(args);
+ return processManager.run(commandArgs, workingDirectory: workingDirectory);
+}
+
+/// The tool overrides `test` to ensure that files created under the
+/// system temporary directory are deleted after each test by calling
+/// `LocalFileSystem.dispose()`.
+@isTest
+void test(
+ String description,
+ FutureOr<void> Function() body, {
+ String? testOn,
+ dynamic skip,
+ List<String>? tags,
+ Map<String, dynamic>? onPlatform,
+ int? retry,
+}) {
+ test_package.test(
+ description,
+ () async {
+ addTearDown(() async {
+ await fileSystem.dispose();
+ });
+
+ return body();
+ },
+ skip: skip,
+ tags: tags,
+ onPlatform: onPlatform,
+ retry: retry,
+ testOn: testOn,
+ // We don't support "timeout"; see ../../dart_test.yaml which
+ // configures all tests to have a 15 minute timeout which should
+ // definitely be enough.
+ );
+}
+
+/// Executes a test body in zone that does not allow context-based injection.
+///
+/// For classes which have been refactored to exclude context-based injection
+/// or globals like [fs] or [platform], prefer using this test method as it
+/// will prevent accidentally including these context getters in future code
+/// changes.
+///
+/// For more information, see https://github.com/flutter/flutter/issues/47161
+@isTest
+void testWithoutContext(
+ String description,
+ FutureOr<void> Function() body, {
+ String? testOn,
+ dynamic skip,
+ List<String>? tags,
+ Map<String, dynamic>? onPlatform,
+ int? retry,
+}) {
+ return test(
+ description,
+ () async {
+ return runZoned(body, zoneValues: <Object, Object>{
+ contextKey: const _NoContext(),
+ });
+ },
+ skip: skip,
+ tags: tags,
+ onPlatform: onPlatform,
+ retry: retry,
+ testOn: testOn,
+ // We don't support "timeout"; see ../../dart_test.yaml which
+ // configures all tests to have a 15 minute timeout which should
+ // definitely be enough.
+ );
+}
+
+/// An implementation of [AppContext] that throws if context.get is called in the test.
+///
+/// The intention of the class is to ensure we do not accidentally regress when
+/// moving towards more explicit dependency injection by accidentally using
+/// a Zone value in place of a constructor parameter.
+class _NoContext implements AppContext {
+ const _NoContext();
+
+ @override
+ T get<T>() {
+ throw UnsupportedError('context.get<$T> is not supported in test methods. '
+ 'Use Testbed or testUsingContext if accessing Zone injected '
+ 'values.');
+ }
+
+ @override
+ String get name => 'No Context';
+
+ @override
+ Future<V> run<V>({
+ required FutureOr<V> Function() body,
+ String? name,
+ Map<Type, Generator>? overrides,
+ Map<Type, Generator>? fallbacks,
+ ZoneSpecification? zoneSpecification,
+ }) async {
+ return body();
+ }
+}
+
+/// Matcher for functions that throw [AssertionError].
+final Matcher throwsAssertionError = throwsA(isA<AssertionError>());
diff --git a/packages/flutter_migrate/test/src/context.dart b/packages/flutter_migrate/test/src/context.dart
new file mode 100644
index 0000000..4f43b48
--- /dev/null
+++ b/packages/flutter_migrate/test/src/context.dart
@@ -0,0 +1,125 @@
+// 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 'package:flutter_migrate/src/base/context.dart';
+import 'package:flutter_migrate/src/base/file_system.dart';
+import 'package:flutter_migrate/src/base/logger.dart';
+import 'package:flutter_migrate/src/base/terminal.dart';
+import 'package:meta/meta.dart';
+import 'package:process/process.dart';
+
+import 'common.dart';
+import 'fakes.dart';
+
+/// Return the test logger. This assumes that the current Logger is a BufferLogger.
+BufferLogger get testLogger => context.get<Logger>()! as BufferLogger;
+
+@isTest
+void testUsingContext(
+ String description,
+ dynamic Function() testMethod, {
+ Map<Type, Generator> overrides = const <Type, Generator>{},
+ bool initializeFlutterRoot = true,
+ String? testOn,
+ bool?
+ skip, // should default to `false`, but https://github.com/dart-lang/test/issues/545 doesn't allow this
+}) {
+ if (overrides[FileSystem] != null && overrides[ProcessManager] == null) {
+ throw StateError(
+ 'If you override the FileSystem context you must also provide a ProcessManager, '
+ 'otherwise the processes you launch will not be dealing with the same file system '
+ 'that you are dealing with in your test.');
+ }
+
+ // Ensure we don't rely on the default [Config] constructor which will
+ // leak a sticky $HOME/.flutter_settings behind!
+ Directory? configDir;
+ tearDown(() {
+ if (configDir != null) {
+ tryToDelete(configDir!);
+ configDir = null;
+ }
+ });
+
+ test(description, () async {
+ await runInContext<dynamic>(() {
+ return context.run<dynamic>(
+ name: 'mocks',
+ overrides: <Type, Generator>{
+ AnsiTerminal: () => AnsiTerminal(stdio: FakeStdio()),
+ OutputPreferences: () => OutputPreferences.test(),
+ Logger: () => BufferLogger.test(),
+ ProcessManager: () => const LocalProcessManager(),
+ },
+ body: () {
+ return runZonedGuarded<Future<dynamic>>(() {
+ try {
+ return context.run<dynamic>(
+ // Apply the overrides to the test context in the zone since their
+ // instantiation may reference items already stored on the context.
+ overrides: overrides,
+ name: 'test-specific overrides',
+ body: () async {
+ if (initializeFlutterRoot) {
+ // Provide a sane default for the flutterRoot directory. Individual
+ // tests can override this either in the test or during setup.
+ // Cache.flutterRoot ??= flutterRoot;
+ }
+ return await testMethod();
+ },
+ );
+ // This catch rethrows, so doesn't need to catch only Exception.
+ } catch (error) {
+ // ignore: avoid_catches_without_on_clauses
+ _printBufferedErrors(context);
+ rethrow;
+ }
+ }, (Object error, StackTrace stackTrace) {
+ // When things fail, it's ok to print to the console!
+ print(error); // ignore: avoid_print
+ print(stackTrace); // ignore: avoid_print
+ _printBufferedErrors(context);
+ throw error; //ignore: only_throw_errors
+ });
+ },
+ );
+ }, overrides: <Type, Generator>{});
+ }, testOn: testOn, skip: skip);
+ // We don't support "timeout"; see ../../dart_test.yaml which
+ // configures all tests to have a 15 minute timeout which should
+ // definitely be enough.
+}
+
+void _printBufferedErrors(AppContext testContext) {
+ if (testContext.get<Logger>() is BufferLogger) {
+ final BufferLogger bufferLogger =
+ testContext.get<Logger>()! as BufferLogger;
+ if (bufferLogger.errorText.isNotEmpty) {
+ // This is where the logger outputting errors is implemented, so it has
+ // to use `print`.
+ print(bufferLogger.errorText); // ignore: avoid_print
+ }
+ bufferLogger.clear();
+ }
+}
+
+Future<T> runInContext<T>(
+ FutureOr<T> Function() runner, {
+ Map<Type, Generator>? overrides,
+}) async {
+ // Wrap runner with any asynchronous initialization that should run with the
+ // overrides and callbacks.
+ // late bool runningOnBot;
+ FutureOr<T> runnerWrapper() async {
+ return runner();
+ }
+
+ return context.run<T>(
+ name: 'global fallbacks',
+ body: runnerWrapper,
+ overrides: overrides,
+ fallbacks: <Type, Generator>{});
+}
diff --git a/packages/flutter_migrate/test/src/fakes.dart b/packages/flutter_migrate/test/src/fakes.dart
new file mode 100644
index 0000000..3e6b072
--- /dev/null
+++ b/packages/flutter_migrate/test/src/fakes.dart
@@ -0,0 +1,285 @@
+// 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 show IOSink, Stdout, StdoutException;
+
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/logger.dart';
+import 'package:test/fake.dart';
+
+/// An IOSink that completes a future with the first line written to it.
+class CompleterIOSink extends MemoryIOSink {
+ CompleterIOSink({
+ this.throwOnAdd = false,
+ });
+
+ final bool throwOnAdd;
+
+ final Completer<List<int>> _completer = Completer<List<int>>();
+
+ Future<List<int>> get future => _completer.future;
+
+ @override
+ void add(List<int> data) {
+ if (!_completer.isCompleted) {
+ // When throwOnAdd is true, complete with empty so any expected output
+ // doesn't appear.
+ _completer.complete(throwOnAdd ? <int>[] : data);
+ }
+ if (throwOnAdd) {
+ throw Exception('CompleterIOSink Error');
+ }
+ super.add(data);
+ }
+}
+
+/// An IOSink that collects whatever is written to it.
+class MemoryIOSink implements IOSink {
+ @override
+ Encoding encoding = utf8;
+
+ final List<List<int>> writes = <List<int>>[];
+
+ @override
+ void add(List<int> data) {
+ writes.add(data);
+ }
+
+ @override
+ Future<void> addStream(Stream<List<int>> stream) {
+ final Completer<void> completer = Completer<void>();
+ late StreamSubscription<List<int>> sub;
+ sub = stream.listen(
+ (List<int> data) {
+ try {
+ add(data);
+ // Catches all exceptions to propagate them to the completer.
+ } catch (err, stack) {
+ // ignore: avoid_catches_without_on_clauses
+ sub.cancel();
+ completer.completeError(err, stack);
+ }
+ },
+ onError: completer.completeError,
+ onDone: completer.complete,
+ cancelOnError: true,
+ );
+ return completer.future;
+ }
+
+ @override
+ void writeCharCode(int charCode) {
+ add(<int>[charCode]);
+ }
+
+ @override
+ void write(Object? obj) {
+ add(encoding.encode('$obj'));
+ }
+
+ @override
+ void writeln([Object? obj = '']) {
+ add(encoding.encode('$obj\n'));
+ }
+
+ @override
+ void writeAll(Iterable<dynamic> objects, [String separator = '']) {
+ bool addSeparator = false;
+ for (final dynamic object in objects) {
+ if (addSeparator) {
+ write(separator);
+ }
+ write(object);
+ addSeparator = true;
+ }
+ }
+
+ @override
+ void addError(dynamic error, [StackTrace? stackTrace]) {
+ throw UnimplementedError();
+ }
+
+ @override
+ Future<void> get done => close();
+
+ @override
+ Future<void> close() async {}
+
+ @override
+ Future<void> flush() async {}
+
+ void clear() {
+ writes.clear();
+ }
+
+ String getAndClear() {
+ final String result =
+ utf8.decode(writes.expand((List<int> l) => l).toList());
+ clear();
+ return result;
+ }
+}
+
+class MemoryStdout extends MemoryIOSink implements io.Stdout {
+ @override
+ bool get hasTerminal => _hasTerminal;
+ set hasTerminal(bool value) {
+ assert(value != null);
+ _hasTerminal = value;
+ }
+
+ bool _hasTerminal = true;
+
+ @override
+ io.IOSink get nonBlocking => this;
+
+ @override
+ bool get supportsAnsiEscapes => _supportsAnsiEscapes;
+ set supportsAnsiEscapes(bool value) {
+ assert(value != null);
+ _supportsAnsiEscapes = value;
+ }
+
+ bool _supportsAnsiEscapes = true;
+
+ @override
+ int get terminalColumns {
+ if (_terminalColumns != null) {
+ return _terminalColumns!;
+ }
+ throw const io.StdoutException('unspecified mock value');
+ }
+
+ set terminalColumns(int value) => _terminalColumns = value;
+ int? _terminalColumns;
+
+ @override
+ int get terminalLines {
+ if (_terminalLines != null) {
+ return _terminalLines!;
+ }
+ throw const io.StdoutException('unspecified mock value');
+ }
+
+ set terminalLines(int value) => _terminalLines = value;
+ int? _terminalLines;
+}
+
+/// A Stdio that collects stdout and supports simulated stdin.
+class FakeStdio extends Stdio {
+ final MemoryStdout _stdout = MemoryStdout()..terminalColumns = 80;
+ final MemoryIOSink _stderr = MemoryIOSink();
+ final FakeStdin _stdin = FakeStdin();
+
+ @override
+ MemoryStdout get stdout => _stdout;
+
+ @override
+ MemoryIOSink get stderr => _stderr;
+
+ @override
+ Stream<List<int>> get stdin => _stdin;
+
+ void simulateStdin(String line) {
+ _stdin.controller.add(utf8.encode('$line\n'));
+ }
+
+ @override
+ bool hasTerminal = true;
+
+ List<String> get writtenToStdout =>
+ _stdout.writes.map<String>(_stdout.encoding.decode).toList();
+ List<String> get writtenToStderr =>
+ _stderr.writes.map<String>(_stderr.encoding.decode).toList();
+}
+
+class FakeStdin extends Fake implements Stdin {
+ final StreamController<List<int>> controller = StreamController<List<int>>();
+
+ @override
+ bool echoMode = true;
+
+ @override
+ bool hasTerminal = true;
+
+ @override
+ bool echoNewlineMode = true;
+
+ @override
+ bool lineMode = true;
+
+ @override
+ Stream<S> transform<S>(StreamTransformer<List<int>, S> transformer) {
+ return controller.stream.transform(transformer);
+ }
+
+ @override
+ StreamSubscription<List<int>> listen(
+ void Function(List<int> event)? onData, {
+ Function? onError,
+ void Function()? onDone,
+ bool? cancelOnError,
+ }) {
+ return controller.stream.listen(
+ onData,
+ onError: onError,
+ onDone: onDone,
+ cancelOnError: cancelOnError,
+ );
+ }
+}
+
+class FakeStopwatch implements Stopwatch {
+ @override
+ bool get isRunning => _isRunning;
+ bool _isRunning = false;
+
+ @override
+ void start() => _isRunning = true;
+
+ @override
+ void stop() => _isRunning = false;
+
+ @override
+ Duration elapsed = Duration.zero;
+
+ @override
+ int get elapsedMicroseconds => elapsed.inMicroseconds;
+
+ @override
+ int get elapsedMilliseconds => elapsed.inMilliseconds;
+
+ @override
+ int get elapsedTicks => elapsed.inMilliseconds;
+
+ @override
+ int get frequency => 1000;
+
+ @override
+ void reset() {
+ _isRunning = false;
+ elapsed = Duration.zero;
+ }
+
+ @override
+ String toString() => '$runtimeType $elapsed $isRunning';
+}
+
+class FakeStopwatchFactory implements StopwatchFactory {
+ FakeStopwatchFactory(
+ {Stopwatch? stopwatch, Map<String, Stopwatch>? stopwatches})
+ : stopwatches = <String, Stopwatch>{
+ if (stopwatches != null) ...stopwatches,
+ if (stopwatch != null) '': stopwatch,
+ };
+
+ Map<String, Stopwatch> stopwatches;
+
+ @override
+ Stopwatch createStopwatch([String name = '']) {
+ return stopwatches[name] ?? FakeStopwatch();
+ }
+}
diff --git a/packages/flutter_migrate/test/src/io.dart b/packages/flutter_migrate/test/src/io.dart
new file mode 100644
index 0000000..c7e6bf3
--- /dev/null
+++ b/packages/flutter_migrate/test/src/io.dart
@@ -0,0 +1,138 @@
+// 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:io' as io show Directory, File, IOOverrides, Link;
+
+import 'package:flutter_migrate/src/base/file_system.dart';
+
+/// An [IOOverrides] that can delegate to [FileSystem] implementation if provided.
+///
+/// Does not override any of the socket facilities.
+///
+/// Do not provide a [LocalFileSystem] as a delegate. Since internally this calls
+/// out to `dart:io` classes, it will result in a stack overflow error as the
+/// IOOverrides and LocalFileSystem call each other endlessly.
+///
+/// The only safe delegate types are those that do not call out to `dart:io`,
+/// like the [MemoryFileSystem].
+class FlutterIOOverrides extends io.IOOverrides {
+ FlutterIOOverrides({FileSystem? fileSystem})
+ : _fileSystemDelegate = fileSystem;
+
+ final FileSystem? _fileSystemDelegate;
+
+ @override
+ io.Directory createDirectory(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.createDirectory(path);
+ }
+ return _fileSystemDelegate!.directory(path);
+ }
+
+ @override
+ io.File createFile(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.createFile(path);
+ }
+ return _fileSystemDelegate!.file(path);
+ }
+
+ @override
+ io.Link createLink(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.createLink(path);
+ }
+ return _fileSystemDelegate!.link(path);
+ }
+
+ @override
+ Stream<FileSystemEvent> fsWatch(String path, int events, bool recursive) {
+ if (_fileSystemDelegate == null) {
+ return super.fsWatch(path, events, recursive);
+ }
+ return _fileSystemDelegate!
+ .file(path)
+ .watch(events: events, recursive: recursive);
+ }
+
+ @override
+ bool fsWatchIsSupported() {
+ if (_fileSystemDelegate == null) {
+ return super.fsWatchIsSupported();
+ }
+ return _fileSystemDelegate!.isWatchSupported;
+ }
+
+ @override
+ Future<FileSystemEntityType> fseGetType(String path, bool followLinks) {
+ if (_fileSystemDelegate == null) {
+ return super.fseGetType(path, followLinks);
+ }
+ return _fileSystemDelegate!.type(path, followLinks: followLinks);
+ }
+
+ @override
+ FileSystemEntityType fseGetTypeSync(String path, bool followLinks) {
+ if (_fileSystemDelegate == null) {
+ return super.fseGetTypeSync(path, followLinks);
+ }
+ return _fileSystemDelegate!.typeSync(path, followLinks: followLinks);
+ }
+
+ @override
+ Future<bool> fseIdentical(String path1, String path2) {
+ if (_fileSystemDelegate == null) {
+ return super.fseIdentical(path1, path2);
+ }
+ return _fileSystemDelegate!.identical(path1, path2);
+ }
+
+ @override
+ bool fseIdenticalSync(String path1, String path2) {
+ if (_fileSystemDelegate == null) {
+ return super.fseIdenticalSync(path1, path2);
+ }
+ return _fileSystemDelegate!.identicalSync(path1, path2);
+ }
+
+ @override
+ io.Directory getCurrentDirectory() {
+ if (_fileSystemDelegate == null) {
+ return super.getCurrentDirectory();
+ }
+ return _fileSystemDelegate!.currentDirectory;
+ }
+
+ @override
+ io.Directory getSystemTempDirectory() {
+ if (_fileSystemDelegate == null) {
+ return super.getSystemTempDirectory();
+ }
+ return _fileSystemDelegate!.systemTempDirectory;
+ }
+
+ @override
+ void setCurrentDirectory(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.setCurrentDirectory(path);
+ }
+ _fileSystemDelegate!.currentDirectory = path;
+ }
+
+ @override
+ Future<FileStat> stat(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.stat(path);
+ }
+ return _fileSystemDelegate!.stat(path);
+ }
+
+ @override
+ FileStat statSync(String path) {
+ if (_fileSystemDelegate == null) {
+ return super.statSync(path);
+ }
+ return _fileSystemDelegate!.statSync(path);
+ }
+}
diff --git a/packages/flutter_migrate/test/src/test_flutter_command_runner.dart b/packages/flutter_migrate/test/src/test_flutter_command_runner.dart
new file mode 100644
index 0000000..8e4d36b
--- /dev/null
+++ b/packages/flutter_migrate/test/src/test_flutter_command_runner.dart
@@ -0,0 +1,40 @@
+// 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 'package:args/command_runner.dart';
+import 'package:flutter_migrate/src/base/command.dart';
+
+export 'package:test_api/test_api.dart' // ignore: deprecated_member_use
+ hide
+ isInstanceOf,
+ test;
+
+CommandRunner<void> createTestCommandRunner([MigrateCommand? command]) {
+ final CommandRunner<void> runner = TestCommandRunner();
+ if (command != null) {
+ runner.addCommand(command);
+ }
+ return runner;
+}
+
+class TestCommandRunner extends CommandRunner<void> {
+ TestCommandRunner()
+ : super(
+ 'flutter',
+ 'Manage your Flutter app development.\n'
+ '\n'
+ 'Common commands:\n'
+ '\n'
+ ' flutter create <output directory>\n'
+ ' Create a new Flutter project in the specified directory.\n'
+ '\n'
+ ' flutter run [options]\n'
+ ' Run your Flutter application on an attached device or in an emulator.',
+ );
+
+ @override
+ Future<void> run(Iterable<String> args) {
+ return super.run(args);
+ }
+}
diff --git a/packages/flutter_migrate/test/src/test_utils.dart b/packages/flutter_migrate/test/src/test_utils.dart
new file mode 100644
index 0000000..b51e127
--- /dev/null
+++ b/packages/flutter_migrate/test/src/test_utils.dart
@@ -0,0 +1,62 @@
+// 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:io';
+
+import 'package:flutter_migrate/src/base/file_system.dart';
+import 'package:flutter_migrate/src/base/io.dart';
+import 'package:flutter_migrate/src/base/signals.dart';
+import 'package:process/process.dart';
+
+import 'common.dart';
+
+/// The [FileSystem] for the integration test environment.
+LocalFileSystem fileSystem =
+ LocalFileSystem.test(signals: LocalSignals.instance);
+
+/// The [ProcessManager] for the integration test environment.
+const ProcessManager processManager = LocalProcessManager();
+
+/// Creates a temporary directory but resolves any symlinks to return the real
+/// underlying path to avoid issues with breakpoints/hot reload.
+/// https://github.com/flutter/flutter/pull/21741
+Directory createResolvedTempDirectorySync(String prefix) {
+ assert(prefix.endsWith('.'));
+ final Directory tempDirectory =
+ fileSystem.systemTempDirectory.createTempSync('flutter_$prefix');
+ return fileSystem.directory(tempDirectory.resolveSymbolicLinksSync());
+}
+
+void writeFile(String path, String content,
+ {bool writeFutureModifiedDate = false}) {
+ final File file = fileSystem.file(path)
+ ..createSync(recursive: true)
+ ..writeAsStringSync(content, flush: true);
+ // Some integration tests on Windows to not see this file as being modified
+ // recently enough for the hot reload to pick this change up unless the
+ // modified time is written in the future.
+ if (writeFutureModifiedDate) {
+ file.setLastModifiedSync(DateTime.now().add(const Duration(seconds: 5)));
+ }
+}
+
+void writePackages(String folder) {
+ writeFile(fileSystem.path.join(folder, '.packages'), '''
+test:${fileSystem.path.join(fileSystem.currentDirectory.path, 'lib')}/
+''');
+}
+
+Future<void> getPackages(String folder) async {
+ final List<String> command = <String>[
+ fileSystem.path.join(getFlutterRoot(), 'bin', 'flutter'),
+ 'pub',
+ 'get',
+ ];
+ final ProcessResult result =
+ await processManager.run(command, workingDirectory: folder);
+ if (result.exitCode != 0) {
+ throw Exception(
+ 'flutter pub get failed: ${result.stderr}\n${result.stdout}');
+ }
+}
diff --git a/script/configs/custom_analysis.yaml b/script/configs/custom_analysis.yaml
index 1ad0f64..a281f3c 100644
--- a/script/configs/custom_analysis.yaml
+++ b/script/configs/custom_analysis.yaml
@@ -8,10 +8,13 @@
# Deliberately uses flutter_lints, as that's what it is demonstrating.
- flutter_lints/example
+# Adopts some flutter_tools rules regarding public api docs due to being an
+# extension of the tool and using tools base code.
+- flutter_migrate
# Adds unawaited_futures. We should investigating adding this to the root
# options instead.
- metrics_center
# Has some constructions that are currently handled poorly by dart format.
- rfw/example
# Disables docs requirements, as it is test code.
-- web_benchmarks/testing/test_app
+- web_benchmarks/testing/test_app
\ No newline at end of file
