dev/tools/lib/repository.dart - mirrors/flutter - Git at Google

 // Copyright 2014 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' show jsonDecode;
 import 'dart:io' as io;

 import 'package:file/file.dart';
 import 'package:meta/meta.dart';
 import 'package:platform/platform.dart';
 import 'package:process/process.dart';

 import './git.dart';
 import './globals.dart';
 import './stdio.dart';
 import './version.dart';

 /// Allowed git remote names.
 enum RemoteName {
   upstream,
   mirror,
 }

 class Remote {
   const Remote({
     required RemoteName name,
     required this.url,
   }) : _name = name;

   final RemoteName _name;

   /// The name of the remote.
   String get name {
     switch (_name) {
       case RemoteName.upstream:
         return 'upstream';
       case RemoteName.mirror:
         return 'mirror';
     }
   }

   /// The URL of the remote.
   final String url;
 }

 /// A source code repository.
 abstract class Repository {
   Repository({
     required this.name,
     required this.fetchRemote,
     required this.processManager,
     required this.stdio,
     required this.platform,
     required this.fileSystem,
     required this.parentDirectory,
     this.initialRef,
     this.localUpstream = false,
     this.useExistingCheckout = false,
     this.pushRemote,
   })  : git = Git(processManager),
         assert(localUpstream != null),
         assert(useExistingCheckout != null);

   final String name;
   final Remote fetchRemote;

   /// Remote to publish tags and commits to.
   ///
   /// This value can be null, in which case attempting to publish will lead to
   /// a [ConductorException].
   final Remote? pushRemote;

   /// The initial ref (branch or commit name) to check out.
   final String? initialRef;
   final Git git;
   final ProcessManager processManager;
   final Stdio stdio;
   final Platform platform;
   final FileSystem fileSystem;
   final Directory parentDirectory;
   final bool useExistingCheckout;

   /// If the repository will be used as an upstream for a test repo.
   final bool localUpstream;

   Directory? _checkoutDirectory;

   /// Directory for the repository checkout.
   ///
   /// Since cloning a repository takes a long time, we do not ensure it is
   /// cloned on the filesystem until this getter is accessed.
   Directory get checkoutDirectory {
     if (_checkoutDirectory != null) {
       return _checkoutDirectory!;
     }
     _checkoutDirectory = parentDirectory.childDirectory(name);
     lazilyInitialize(_checkoutDirectory!);
     return _checkoutDirectory!;
   }

   /// Ensure the repository is cloned to disk and initialized with proper state.
   void lazilyInitialize(Directory checkoutDirectory) {
     if (!useExistingCheckout && checkoutDirectory.existsSync()) {
       stdio.printTrace('Deleting $name from ${checkoutDirectory.path}...');
       checkoutDirectory.deleteSync(recursive: true);
     }

     if (!checkoutDirectory.existsSync()) {
       stdio.printTrace(
         'Cloning $name from ${fetchRemote.url} to ${checkoutDirectory.path}...',
       );
       git.run(
         <String>[
           'clone',
           '--origin',
           fetchRemote.name,
           '--',
           fetchRemote.url,
           checkoutDirectory.path
         ],
         'Cloning $name repo',
         workingDirectory: parentDirectory.path,
       );
       if (pushRemote != null) {
         git.run(
           <String>['remote', 'add', pushRemote!.name, pushRemote!.url],
           'Adding remote ${pushRemote!.url} as ${pushRemote!.name}',
           workingDirectory: checkoutDirectory.path,
         );
         git.run(
           <String>['fetch', pushRemote!.name],
           'Fetching git remote ${pushRemote!.name}',
           workingDirectory: checkoutDirectory.path,
         );
       }
       if (localUpstream) {
         // These branches must exist locally for the repo that depends on it
         // to fetch and push to.
         for (final String channel in kReleaseChannels) {
           git.run(
             <String>['checkout', channel, '--'],
             'check out branch $channel locally',
             workingDirectory: checkoutDirectory.path,
           );
         }
       }
     }

     if (initialRef != null) {
       git.run(
         <String>['checkout', '${fetchRemote.name}/$initialRef'],
         'Checking out initialRef $initialRef',
         workingDirectory: checkoutDirectory.path,
       );
     }
     final String revision = reverseParse('HEAD');
     stdio.printTrace(
       'Repository $name is checked out at revision "$revision".',
     );
   }

   /// The URL of the remote named [remoteName].
   String remoteUrl(String remoteName) {
     assert(remoteName != null);
     return git.getOutput(
       <String>['remote', 'get-url', remoteName],
       'verify the URL of the $remoteName remote',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Verify the repository's git checkout is clean.
   bool gitCheckoutClean() {
     final String output = git.getOutput(
       <String>['status', '--porcelain'],
       'check that the git checkout is clean',
       workingDirectory: checkoutDirectory.path,
     );
     return output == '';
   }

   /// Return the revision for the branch point between two refs.
   String branchPoint(String firstRef, String secondRef) {
     return git.getOutput(
       <String>['merge-base', firstRef, secondRef],
       'determine the merge base between $firstRef and $secondRef',
       workingDirectory: checkoutDirectory.path,
     ).trim();
   }

   /// Fetch all branches and associated commits and tags from [remoteName].
   void fetch(String remoteName) {
     git.run(
       <String>['fetch', remoteName, '--tags'],
       'fetch $remoteName --tags',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Create (and checkout) a new branch based on the current HEAD.
   ///
   /// Runs `git checkout -b $branchName`.
   void newBranch(String branchName) {
     git.run(
       <String>['checkout', '-b', branchName],
       'create & checkout new branch $branchName',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Check out the given ref.
   void checkout(String ref) {
     git.run(
       <String>['checkout', ref],
       'checkout ref',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Obtain the version tag of the previous dev release.
   String getFullTag(String remoteName) {
     const String glob = '*.*.*-*.*.pre';
     // describe the latest dev release
     final String ref = 'refs/remotes/$remoteName/dev';
     return git.getOutput(
       <String>['describe', '--match', glob, '--exact-match', '--tags', ref],
       'obtain last released version number',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// List commits in reverse chronological order.
   List<String> revList(List<String> args) {
     return git
         .getOutput(
           <String>['rev-list', ...args],
           'rev-list with args ${args.join(' ')}',
           workingDirectory: checkoutDirectory.path,
         )
         .trim()
         .split('\n');
   }

   /// Look up the commit for [ref].
   String reverseParse(String ref) {
     final String revisionHash = git.getOutput(
       <String>['rev-parse', ref],
       'look up the commit for the ref $ref',
       workingDirectory: checkoutDirectory.path,
     );
     assert(revisionHash.isNotEmpty);
     return revisionHash;
   }

   /// Determines if one ref is an ancestor for another.
   bool isAncestor(String possibleAncestor, String possibleDescendant) {
     final int exitcode = git.run(
       <String>[
         'merge-base',
         '--is-ancestor',
         possibleDescendant,
         possibleAncestor
       ],
       'verify $possibleAncestor is a direct ancestor of $possibleDescendant.',
       allowNonZeroExitCode: true,
       workingDirectory: checkoutDirectory.path,
     );
     return exitcode == 0;
   }

   /// Determines if a given commit has a tag.
   bool isCommitTagged(String commit) {
     final int exitcode = git.run(
       <String>['describe', '--exact-match', '--tags', commit],
       'verify $commit is already tagged',
       allowNonZeroExitCode: true,
       workingDirectory: checkoutDirectory.path,
     );
     return exitcode == 0;
   }

   /// Determines if a commit will cherry-pick to current HEAD without conflict.
   bool canCherryPick(String commit) {
     assert(
       gitCheckoutClean(),
       'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
     );

     final int exitcode = git.run(
       <String>['cherry-pick', '--no-commit', commit],
       'attempt to cherry-pick $commit without committing',
       allowNonZeroExitCode: true,
       workingDirectory: checkoutDirectory.path,
     );

     final bool result = exitcode == 0;

     if (result == false) {
       stdio.printError(git.getOutput(
         <String>['diff'],
         'get diff of failed cherry-pick',
         workingDirectory: checkoutDirectory.path,
       ));
     }

     reset('HEAD');
     return result;
   }

   /// Cherry-pick a [commit] to the current HEAD.
   ///
   /// This method will throw a [GitException] if the command fails.
   void cherryPick(String commit) {
     assert(
       gitCheckoutClean(),
       'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
     );

     git.run(
       <String>['cherry-pick', commit],
       'cherry-pick $commit',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Resets repository HEAD to [ref].
   void reset(String ref) {
     git.run(
       <String>['reset', ref, '--hard'],
       'reset to $ref',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Tag [commit] and push the tag to the remote.
   void tag(String commit, String tagName, String remote) {
     git.run(
       <String>['tag', tagName, commit],
       'tag the commit with the version label',
       workingDirectory: checkoutDirectory.path,
     );
     git.run(
       <String>['push', remote, tagName],
       'publish the tag to the repo',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Push [commit] to the release channel [branch].
   void updateChannel(
     String commit,
     String remote,
     String branch, {
     bool force = false,
   }) {
     git.run(
       <String>[
         'push',
         if (force) '--force',
         remote,
         '$commit:$branch',
       ],
       'update the release branch with the commit',
       workingDirectory: checkoutDirectory.path,
     );
   }

   /// Create an empty commit and return the revision.
   @visibleForTesting
   String authorEmptyCommit([String message = 'An empty commit']) {
     git.run(
       <String>[
         '-c',
         'user.name=Conductor',
         '-c',
         'user.email=conductor@flutter.dev',
         'commit',
         '--allow-empty',
         '-m',
         '\'$message\'',
       ],
       'create an empty commit',
       workingDirectory: checkoutDirectory.path,
     );
     return reverseParse('HEAD');
   }

   /// Create a new clone of the current repository.
   ///
   /// The returned repository will inherit all properties from this one, except
   /// for the upstream, which will be the path to this repository on disk.
   ///
   /// This method is for testing purposes.
   @visibleForTesting
   Repository cloneRepository(String cloneName);
 }

 class FrameworkRepository extends Repository {
   FrameworkRepository(
     this.checkouts, {
     String name = 'framework',
     Remote fetchRemote = const Remote(
         name: RemoteName.upstream, url: FrameworkRepository.defaultUpstream),
     bool localUpstream = false,
     bool useExistingCheckout = false,
     String? initialRef,
     Remote? pushRemote,
   }) : super(
           name: name,
           fetchRemote: fetchRemote,
           pushRemote: pushRemote,
           initialRef: initialRef,
           fileSystem: checkouts.fileSystem,
           localUpstream: localUpstream,
           parentDirectory: checkouts.directory,
           platform: checkouts.platform,
           processManager: checkouts.processManager,
           stdio: checkouts.stdio,
           useExistingCheckout: useExistingCheckout,
         );

   /// A [FrameworkRepository] with the host conductor's repo set as upstream.
   ///
   /// This is useful when testing a commit that has not been merged upstream
   /// yet.
   factory FrameworkRepository.localRepoAsUpstream(
     Checkouts checkouts, {
     String name = 'framework',
     bool useExistingCheckout = false,
     required String upstreamPath,
   }) {
     return FrameworkRepository(
       checkouts,
       name: name,
       fetchRemote: Remote(
         name: RemoteName.upstream,
         url: 'file://$upstreamPath/',
       ),
       localUpstream: false,
       useExistingCheckout: useExistingCheckout,
     );
   }

   final Checkouts checkouts;
   static const String defaultUpstream =
       'https://github.com/flutter/flutter.git';

   static const String defaultBranch = 'master';

   String get cacheDirectory => fileSystem.path.join(
         checkoutDirectory.path,
         'bin',
         'cache',
       );

   @override
   Repository cloneRepository(String? cloneName) {
     assert(localUpstream);
     cloneName ??= 'clone-of-$name';
     return FrameworkRepository(
       checkouts,
       name: cloneName,
       fetchRemote: Remote(
           name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
       useExistingCheckout: useExistingCheckout,
     );
   }

   void _ensureToolReady() {
     final File toolsStamp =
         fileSystem.directory(cacheDirectory).childFile('flutter_tools.stamp');
     if (toolsStamp.existsSync()) {
       final String toolsStampHash = toolsStamp.readAsStringSync().trim();
       final String repoHeadHash = reverseParse('HEAD');
       if (toolsStampHash == repoHeadHash) {
         return;
       }
     }

     stdio.printTrace('Building tool...');
     // Build tool
     processManager.runSync(<String>[
       fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
       'help',
     ]);
   }

   io.ProcessResult runFlutter(List<String> args) {
     _ensureToolReady();

     return processManager.runSync(<String>[
       fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
       ...args,
     ]);
   }

   @override
   void checkout(String ref) {
     super.checkout(ref);
     // The tool will overwrite old cached artifacts, but not delete unused
     // artifacts from a previous version. Thus, delete the entire cache and
     // re-populate.
     final Directory cache = fileSystem.directory(cacheDirectory);
     if (cache.existsSync()) {
       stdio.printTrace('Deleting cache...');
       cache.deleteSync(recursive: true);
     }
     _ensureToolReady();
   }

   Version flutterVersion() {
     // Check version
     final io.ProcessResult result =
         runFlutter(<String>['--version', '--machine']);
     final Map<String, dynamic> versionJson = jsonDecode(
       stdoutToString(result.stdout),
     ) as Map<String, dynamic>;
     return Version.fromString(versionJson['frameworkVersion'] as String);
   }
 }

 /// A wrapper around the host repository that is executing the conductor.
 ///
 /// [Repository] methods that mutate the underlying repository will throw a
 /// [ConductorException].
 class HostFrameworkRepository extends FrameworkRepository {
   HostFrameworkRepository({
     required Checkouts checkouts,
     String name = 'host-framework',
     bool useExistingCheckout = false,
     required String upstreamPath,
   }) : super(
     checkouts,
     name: name,
     fetchRemote: Remote(
       name: RemoteName.upstream,
       url: 'file://$upstreamPath/',
     ),
     localUpstream: false,
     useExistingCheckout: useExistingCheckout,
   ) {
     _checkoutDirectory = checkouts.fileSystem.directory(upstreamPath);
   }

   @override
   Directory get checkoutDirectory => _checkoutDirectory!;

   @override
   void newBranch(String branchName) {
     throw ConductorException('newBranch not implemented for the host repository');
   }

   @override
   void checkout(String ref) {
     throw ConductorException('checkout not implemented for the host repository');
   }

   @override
   String cherryPick(String commit) {
     throw ConductorException('cherryPick not implemented for the host repository');
   }

   @override
   String reset(String ref) {
     throw ConductorException('reset not implemented for the host repository');
   }

   @override
   void tag(String commit, String tagName, String remote) {
     throw ConductorException('tag not implemented for the host repository');
   }

   @override
   void updateChannel(
     String commit,
     String remote,
     String branch, {
     bool force = false,
   }) {
     throw ConductorException('updateChannel not implemented for the host repository');
   }

   @override
   String authorEmptyCommit([String message = 'An empty commit']) {
     throw ConductorException(
       'authorEmptyCommit not implemented for the host repository',
     );
   }
 }

 class EngineRepository extends Repository {
   EngineRepository(
     this.checkouts, {
     String name = 'engine',
     String initialRef = EngineRepository.defaultBranch,
     Remote fetchRemote = const Remote(
         name: RemoteName.upstream, url: EngineRepository.defaultUpstream),
     bool localUpstream = false,
     bool useExistingCheckout = false,
     Remote? pushRemote,
   }) : super(
           name: name,
           fetchRemote: fetchRemote,
           pushRemote: pushRemote,
           initialRef: initialRef,
           fileSystem: checkouts.fileSystem,
           localUpstream: localUpstream,
           parentDirectory: checkouts.directory,
           platform: checkouts.platform,
           processManager: checkouts.processManager,
           stdio: checkouts.stdio,
           useExistingCheckout: useExistingCheckout,
         );

   final Checkouts checkouts;

   static const String defaultUpstream = 'https://github.com/flutter/engine.git';
   static const String defaultBranch = 'master';

   @override
   Repository cloneRepository(String? cloneName) {
     assert(localUpstream);
     cloneName ??= 'clone-of-$name';
     return EngineRepository(
       checkouts,
       name: cloneName,
       fetchRemote: Remote(
           name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
       useExistingCheckout: useExistingCheckout,
     );
   }
 }

 /// An enum of all the repositories that the Conductor supports.
 enum RepositoryType {
   framework,
   engine,
 }

 class Checkouts {
   Checkouts({
     required this.fileSystem,
     required this.platform,
     required this.processManager,
     required this.stdio,
     required Directory parentDirectory,
     String directoryName = 'flutter_conductor_checkouts',
   })  : directory = parentDirectory.childDirectory(directoryName) {
     if (!directory.existsSync()) {
       directory.createSync(recursive: true);
     }
   }

   final Directory directory;
   final FileSystem fileSystem;
   final Platform platform;
   final ProcessManager processManager;
   final Stdio stdio;
 }
	// Copyright 2014 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' show jsonDecode;
	import 'dart:io' as io;

	import 'package:file/file.dart';
	import 'package:meta/meta.dart';
	import 'package:platform/platform.dart';
	import 'package:process/process.dart';

	import './git.dart';
	import './globals.dart';
	import './stdio.dart';
	import './version.dart';

	/// Allowed git remote names.
	enum RemoteName {
	upstream,
	mirror,
	}

	class Remote {
	const Remote({
	required RemoteName name,
	required this.url,
	}) : _name = name;

	final RemoteName _name;

	/// The name of the remote.
	String get name {
	switch (_name) {
	case RemoteName.upstream:
	return 'upstream';
	case RemoteName.mirror:
	return 'mirror';
	}
	}

	/// The URL of the remote.
	final String url;
	}

	/// A source code repository.
	abstract class Repository {
	Repository({
	required this.name,
	required this.fetchRemote,
	required this.processManager,
	required this.stdio,
	required this.platform,
	required this.fileSystem,
	required this.parentDirectory,
	this.initialRef,
	this.localUpstream = false,
	this.useExistingCheckout = false,
	this.pushRemote,
	}) : git = Git(processManager),
	assert(localUpstream != null),
	assert(useExistingCheckout != null);

	final String name;
	final Remote fetchRemote;

	/// Remote to publish tags and commits to.
	///
	/// This value can be null, in which case attempting to publish will lead to
	/// a [ConductorException].
	final Remote? pushRemote;

	/// The initial ref (branch or commit name) to check out.
	final String? initialRef;
	final Git git;
	final ProcessManager processManager;
	final Stdio stdio;
	final Platform platform;
	final FileSystem fileSystem;
	final Directory parentDirectory;
	final bool useExistingCheckout;

	/// If the repository will be used as an upstream for a test repo.
	final bool localUpstream;

	Directory? _checkoutDirectory;

	/// Directory for the repository checkout.
	///
	/// Since cloning a repository takes a long time, we do not ensure it is
	/// cloned on the filesystem until this getter is accessed.
	Directory get checkoutDirectory {
	if (_checkoutDirectory != null) {
	return _checkoutDirectory!;
	}
	_checkoutDirectory = parentDirectory.childDirectory(name);
	lazilyInitialize(_checkoutDirectory!);
	return _checkoutDirectory!;
	}

	/// Ensure the repository is cloned to disk and initialized with proper state.
	void lazilyInitialize(Directory checkoutDirectory) {
	if (!useExistingCheckout && checkoutDirectory.existsSync()) {
	stdio.printTrace('Deleting $name from ${checkoutDirectory.path}...');
	checkoutDirectory.deleteSync(recursive: true);
	}

	if (!checkoutDirectory.existsSync()) {
	stdio.printTrace(
	'Cloning $name from ${fetchRemote.url} to ${checkoutDirectory.path}...',
	);
	git.run(
	<String>[
	'clone',
	'--origin',
	fetchRemote.name,
	'--',
	fetchRemote.url,
	checkoutDirectory.path
	],
	'Cloning $name repo',
	workingDirectory: parentDirectory.path,
	);
	if (pushRemote != null) {
	git.run(
	<String>['remote', 'add', pushRemote!.name, pushRemote!.url],
	'Adding remote ${pushRemote!.url} as ${pushRemote!.name}',
	workingDirectory: checkoutDirectory.path,
	);
	git.run(
	<String>['fetch', pushRemote!.name],
	'Fetching git remote ${pushRemote!.name}',
	workingDirectory: checkoutDirectory.path,
	);
	}
	if (localUpstream) {
	// These branches must exist locally for the repo that depends on it
	// to fetch and push to.
	for (final String channel in kReleaseChannels) {
	git.run(
	<String>['checkout', channel, '--'],
	'check out branch $channel locally',
	workingDirectory: checkoutDirectory.path,
	);
	}
	}
	}

	if (initialRef != null) {
	git.run(
	<String>['checkout', '${fetchRemote.name}/$initialRef'],
	'Checking out initialRef $initialRef',
	workingDirectory: checkoutDirectory.path,
	);
	}
	final String revision = reverseParse('HEAD');
	stdio.printTrace(
	'Repository $name is checked out at revision "$revision".',
	);
	}

	/// The URL of the remote named [remoteName].
	String remoteUrl(String remoteName) {
	assert(remoteName != null);
	return git.getOutput(
	<String>['remote', 'get-url', remoteName],
	'verify the URL of the $remoteName remote',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Verify the repository's git checkout is clean.
	bool gitCheckoutClean() {
	final String output = git.getOutput(
	<String>['status', '--porcelain'],
	'check that the git checkout is clean',
	workingDirectory: checkoutDirectory.path,
	);
	return output == '';
	}

	/// Return the revision for the branch point between two refs.
	String branchPoint(String firstRef, String secondRef) {
	return git.getOutput(
	<String>['merge-base', firstRef, secondRef],
	'determine the merge base between $firstRef and $secondRef',
	workingDirectory: checkoutDirectory.path,
	).trim();
	}

	/// Fetch all branches and associated commits and tags from [remoteName].
	void fetch(String remoteName) {
	git.run(
	<String>['fetch', remoteName, '--tags'],
	'fetch $remoteName --tags',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Create (and checkout) a new branch based on the current HEAD.
	///
	/// Runs `git checkout -b $branchName`.
	void newBranch(String branchName) {
	git.run(
	<String>['checkout', '-b', branchName],
	'create & checkout new branch $branchName',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Check out the given ref.
	void checkout(String ref) {
	git.run(
	<String>['checkout', ref],
	'checkout ref',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Obtain the version tag of the previous dev release.
	String getFullTag(String remoteName) {
	const String glob = '..-.*.pre';
	// describe the latest dev release
	final String ref = 'refs/remotes/$remoteName/dev';
	return git.getOutput(
	<String>['describe', '--match', glob, '--exact-match', '--tags', ref],
	'obtain last released version number',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// List commits in reverse chronological order.
	List<String> revList(List<String> args) {
	return git
	.getOutput(
	<String>['rev-list', ...args],
	'rev-list with args ${args.join(' ')}',
	workingDirectory: checkoutDirectory.path,
	)
	.trim()
	.split('\n');
	}

	/// Look up the commit for [ref].
	String reverseParse(String ref) {
	final String revisionHash = git.getOutput(
	<String>['rev-parse', ref],
	'look up the commit for the ref $ref',
	workingDirectory: checkoutDirectory.path,
	);
	assert(revisionHash.isNotEmpty);
	return revisionHash;
	}

	/// Determines if one ref is an ancestor for another.
	bool isAncestor(String possibleAncestor, String possibleDescendant) {
	final int exitcode = git.run(
	<String>[
	'merge-base',
	'--is-ancestor',
	possibleDescendant,
	possibleAncestor
	],
	'verify $possibleAncestor is a direct ancestor of $possibleDescendant.',
	allowNonZeroExitCode: true,
	workingDirectory: checkoutDirectory.path,
	);
	return exitcode == 0;
	}

	/// Determines if a given commit has a tag.
	bool isCommitTagged(String commit) {
	final int exitcode = git.run(
	<String>['describe', '--exact-match', '--tags', commit],
	'verify $commit is already tagged',
	allowNonZeroExitCode: true,
	workingDirectory: checkoutDirectory.path,
	);
	return exitcode == 0;
	}

	/// Determines if a commit will cherry-pick to current HEAD without conflict.
	bool canCherryPick(String commit) {
	assert(
	gitCheckoutClean(),
	'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
	);

	final int exitcode = git.run(
	<String>['cherry-pick', '--no-commit', commit],
	'attempt to cherry-pick $commit without committing',
	allowNonZeroExitCode: true,
	workingDirectory: checkoutDirectory.path,
	);

	final bool result = exitcode == 0;

	if (result == false) {
	stdio.printError(git.getOutput(
	<String>['diff'],
	'get diff of failed cherry-pick',
	workingDirectory: checkoutDirectory.path,
	));
	}

	reset('HEAD');
	return result;
	}

	/// Cherry-pick a [commit] to the current HEAD.
	///
	/// This method will throw a [GitException] if the command fails.
	void cherryPick(String commit) {
	assert(
	gitCheckoutClean(),
	'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
	);

	git.run(
	<String>['cherry-pick', commit],
	'cherry-pick $commit',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Resets repository HEAD to [ref].
	void reset(String ref) {
	git.run(
	<String>['reset', ref, '--hard'],
	'reset to $ref',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Tag [commit] and push the tag to the remote.
	void tag(String commit, String tagName, String remote) {
	git.run(
	<String>['tag', tagName, commit],
	'tag the commit with the version label',
	workingDirectory: checkoutDirectory.path,
	);
	git.run(
	<String>['push', remote, tagName],
	'publish the tag to the repo',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Push [commit] to the release channel [branch].
	void updateChannel(
	String commit,
	String remote,
	String branch, {
	bool force = false,
	}) {
	git.run(
	<String>[
	'push',
	if (force) '--force',
	remote,
	'$commit:$branch',
	],
	'update the release branch with the commit',
	workingDirectory: checkoutDirectory.path,
	);
	}

	/// Create an empty commit and return the revision.
	@visibleForTesting
	String authorEmptyCommit([String message = 'An empty commit']) {
	git.run(
	<String>[
	'-c',
	'user.name=Conductor',
	'-c',
	'user.email=conductor@flutter.dev',
	'commit',
	'--allow-empty',
	'-m',
	'\'$message\'',
	],
	'create an empty commit',
	workingDirectory: checkoutDirectory.path,
	);
	return reverseParse('HEAD');
	}

	/// Create a new clone of the current repository.
	///
	/// The returned repository will inherit all properties from this one, except
	/// for the upstream, which will be the path to this repository on disk.
	///
	/// This method is for testing purposes.
	@visibleForTesting
	Repository cloneRepository(String cloneName);
	}

	class FrameworkRepository extends Repository {
	FrameworkRepository(
	this.checkouts, {
	String name = 'framework',
	Remote fetchRemote = const Remote(
	name: RemoteName.upstream, url: FrameworkRepository.defaultUpstream),
	bool localUpstream = false,
	bool useExistingCheckout = false,
	String? initialRef,
	Remote? pushRemote,
	}) : super(
	name: name,
	fetchRemote: fetchRemote,
	pushRemote: pushRemote,
	initialRef: initialRef,
	fileSystem: checkouts.fileSystem,
	localUpstream: localUpstream,
	parentDirectory: checkouts.directory,
	platform: checkouts.platform,
	processManager: checkouts.processManager,
	stdio: checkouts.stdio,
	useExistingCheckout: useExistingCheckout,
	);

	/// A [FrameworkRepository] with the host conductor's repo set as upstream.
	///
	/// This is useful when testing a commit that has not been merged upstream
	/// yet.
	factory FrameworkRepository.localRepoAsUpstream(
	Checkouts checkouts, {
	String name = 'framework',
	bool useExistingCheckout = false,
	required String upstreamPath,
	}) {
	return FrameworkRepository(
	checkouts,
	name: name,
	fetchRemote: Remote(
	name: RemoteName.upstream,
	url: 'file://$upstreamPath/',
	),
	localUpstream: false,
	useExistingCheckout: useExistingCheckout,
	);
	}

	final Checkouts checkouts;
	static const String defaultUpstream =
	'https://github.com/flutter/flutter.git';

	static const String defaultBranch = 'master';

	String get cacheDirectory => fileSystem.path.join(
	checkoutDirectory.path,
	'bin',
	'cache',
	);

	@override
	Repository cloneRepository(String? cloneName) {
	assert(localUpstream);
	cloneName ??= 'clone-of-$name';
	return FrameworkRepository(
	checkouts,
	name: cloneName,
	fetchRemote: Remote(
	name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
	useExistingCheckout: useExistingCheckout,
	);
	}

	void _ensureToolReady() {
	final File toolsStamp =
	fileSystem.directory(cacheDirectory).childFile('flutter_tools.stamp');
	if (toolsStamp.existsSync()) {
	final String toolsStampHash = toolsStamp.readAsStringSync().trim();
	final String repoHeadHash = reverseParse('HEAD');
	if (toolsStampHash == repoHeadHash) {
	return;
	}
	}

	stdio.printTrace('Building tool...');
	// Build tool
	processManager.runSync(<String>[
	fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
	'help',
	]);
	}

	io.ProcessResult runFlutter(List<String> args) {
	_ensureToolReady();

	return processManager.runSync(<String>[
	fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
	...args,
	]);
	}

	@override
	void checkout(String ref) {
	super.checkout(ref);
	// The tool will overwrite old cached artifacts, but not delete unused
	// artifacts from a previous version. Thus, delete the entire cache and
	// re-populate.
	final Directory cache = fileSystem.directory(cacheDirectory);
	if (cache.existsSync()) {
	stdio.printTrace('Deleting cache...');
	cache.deleteSync(recursive: true);
	}
	_ensureToolReady();
	}

	Version flutterVersion() {
	// Check version
	final io.ProcessResult result =
	runFlutter(<String>['--version', '--machine']);
	final Map<String, dynamic> versionJson = jsonDecode(
	stdoutToString(result.stdout),
	) as Map<String, dynamic>;
	return Version.fromString(versionJson['frameworkVersion'] as String);
	}
	}

	/// A wrapper around the host repository that is executing the conductor.
	///
	/// [Repository] methods that mutate the underlying repository will throw a
	/// [ConductorException].
	class HostFrameworkRepository extends FrameworkRepository {
	HostFrameworkRepository({
	required Checkouts checkouts,
	String name = 'host-framework',
	bool useExistingCheckout = false,
	required String upstreamPath,
	}) : super(
	checkouts,
	name: name,
	fetchRemote: Remote(
	name: RemoteName.upstream,
	url: 'file://$upstreamPath/',
	),
	localUpstream: false,
	useExistingCheckout: useExistingCheckout,
	) {
	_checkoutDirectory = checkouts.fileSystem.directory(upstreamPath);
	}

	@override
	Directory get checkoutDirectory => _checkoutDirectory!;

	@override
	void newBranch(String branchName) {
	throw ConductorException('newBranch not implemented for the host repository');
	}

	@override
	void checkout(String ref) {
	throw ConductorException('checkout not implemented for the host repository');
	}

	@override
	String cherryPick(String commit) {
	throw ConductorException('cherryPick not implemented for the host repository');
	}

	@override
	String reset(String ref) {
	throw ConductorException('reset not implemented for the host repository');
	}

	@override
	void tag(String commit, String tagName, String remote) {
	throw ConductorException('tag not implemented for the host repository');
	}

	@override
	void updateChannel(
	String commit,
	String remote,
	String branch, {
	bool force = false,
	}) {
	throw ConductorException('updateChannel not implemented for the host repository');
	}

	@override
	String authorEmptyCommit([String message = 'An empty commit']) {
	throw ConductorException(
	'authorEmptyCommit not implemented for the host repository',
	);
	}
	}

	class EngineRepository extends Repository {
	EngineRepository(
	this.checkouts, {
	String name = 'engine',
	String initialRef = EngineRepository.defaultBranch,
	Remote fetchRemote = const Remote(
	name: RemoteName.upstream, url: EngineRepository.defaultUpstream),
	bool localUpstream = false,
	bool useExistingCheckout = false,
	Remote? pushRemote,
	}) : super(
	name: name,
	fetchRemote: fetchRemote,
	pushRemote: pushRemote,
	initialRef: initialRef,
	fileSystem: checkouts.fileSystem,
	localUpstream: localUpstream,
	parentDirectory: checkouts.directory,
	platform: checkouts.platform,
	processManager: checkouts.processManager,
	stdio: checkouts.stdio,
	useExistingCheckout: useExistingCheckout,
	);

	final Checkouts checkouts;

	static const String defaultUpstream = 'https://github.com/flutter/engine.git';
	static const String defaultBranch = 'master';

	@override
	Repository cloneRepository(String? cloneName) {
	assert(localUpstream);
	cloneName ??= 'clone-of-$name';
	return EngineRepository(
	checkouts,
	name: cloneName,
	fetchRemote: Remote(
	name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
	useExistingCheckout: useExistingCheckout,
	);
	}
	}

	/// An enum of all the repositories that the Conductor supports.
	enum RepositoryType {
	framework,
	engine,
	}

	class Checkouts {
	Checkouts({
	required this.fileSystem,
	required this.platform,
	required this.processManager,
	required this.stdio,
	required Directory parentDirectory,
	String directoryName = 'flutter_conductor_checkouts',
	}) : directory = parentDirectory.childDirectory(directoryName) {
	if (!directory.existsSync()) {
	directory.createSync(recursive: true);
	}
	}

	final Directory directory;
	final FileSystem fileSystem;
	final Platform platform;
	final ProcessManager processManager;
	final Stdio stdio;
	}