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:process/process.dart';
 import 'package:platform/platform.dart';

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

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

   final String name;
   final String upstream;
   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);
     if (!useExistingCheckout && _checkoutDirectory.existsSync()) {
       stdio.printTrace('Deleting $name from ${_checkoutDirectory.path}...');
       _checkoutDirectory.deleteSync(recursive: true);
     } else if (useExistingCheckout && _checkoutDirectory.existsSync()) {
       git.run(
         <String>['checkout', 'master'],
         'Checkout to master branch',
         workingDirectory: _checkoutDirectory.path,
       );
       git.run(
         <String>['pull', '--ff-only'],
         'Updating $name repo',
         workingDirectory: _checkoutDirectory.path,
       );
     }
     if (!_checkoutDirectory.existsSync()) {
       stdio.printTrace(
           'Cloning $name from $upstream to ${_checkoutDirectory.path}...');
       git.run(
         <String>['clone', '--', upstream, _checkoutDirectory.path],
         'Cloning $name repo',
         workingDirectory: parentDirectory.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 globals.kReleaseChannels) {
           git.run(
             <String>['checkout', channel, '--'],
             'check out branch $channel locally',
             workingDirectory: _checkoutDirectory.path,
           );
         }
       }
     }

     final String revision = reverseParse('HEAD');
     stdio
         .printTrace('Repository $name is checked out at revision "$revision".');
     return _checkoutDirectory;
   }

   /// 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 == '';
   }

   /// 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,
     );
   }

   void checkout(String revision) {
     git.run(
       <String>['checkout', revision],
       'checkout $revision',
       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,
     );
   }

   /// 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,
     ).trim();
     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;
   }

   /// Resets repository HEAD to [commit].
   void reset(String commit) {
     git.run(
       <String>['reset', commit, '--hard'],
       'reset to the release commit',
       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',
     String upstream = FrameworkRepository.defaultUpstream,
     bool localUpstream = false,
     bool useExistingCheckout = false,
   }) : super(
           name: name,
           upstream: upstream,
           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,
       upstream: 'file://$upstreamPath/',
       localUpstream: false,
       useExistingCheckout: useExistingCheckout,
     );
   }

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

   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,
       upstream: '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 revision) {
     super.checkout(revision);
     // 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(
       globals.stdoutToString(result.stdout),
     ) as Map<String, dynamic>;
     return Version.fromString(versionJson['frameworkVersion'] as String);
   }
 }

 /// 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',
   })  : assert(parentDirectory != null),
         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:process/process.dart';
	import 'package:platform/platform.dart';

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

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

	final String name;
	final String upstream;
	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);
	if (!useExistingCheckout && _checkoutDirectory.existsSync()) {
	stdio.printTrace('Deleting $name from ${_checkoutDirectory.path}...');
	_checkoutDirectory.deleteSync(recursive: true);
	} else if (useExistingCheckout && _checkoutDirectory.existsSync()) {
	git.run(
	<String>['checkout', 'master'],
	'Checkout to master branch',
	workingDirectory: _checkoutDirectory.path,
	);
	git.run(
	<String>['pull', '--ff-only'],
	'Updating $name repo',
	workingDirectory: _checkoutDirectory.path,
	);
	}
	if (!_checkoutDirectory.existsSync()) {
	stdio.printTrace(
	'Cloning $name from $upstream to ${_checkoutDirectory.path}...');
	git.run(
	<String>['clone', '--', upstream, _checkoutDirectory.path],
	'Cloning $name repo',
	workingDirectory: parentDirectory.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 globals.kReleaseChannels) {
	git.run(
	<String>['checkout', channel, '--'],
	'check out branch $channel locally',
	workingDirectory: _checkoutDirectory.path,
	);
	}
	}
	}

	final String revision = reverseParse('HEAD');
	stdio
	.printTrace('Repository $name is checked out at revision "$revision".');
	return _checkoutDirectory;
	}

	/// 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 == '';
	}

	/// 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,
	);
	}

	void checkout(String revision) {
	git.run(
	<String>['checkout', revision],
	'checkout $revision',
	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,
	);
	}

	/// 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,
	).trim();
	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;
	}

	/// Resets repository HEAD to [commit].
	void reset(String commit) {
	git.run(
	<String>['reset', commit, '--hard'],
	'reset to the release commit',
	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',
	String upstream = FrameworkRepository.defaultUpstream,
	bool localUpstream = false,
	bool useExistingCheckout = false,
	}) : super(
	name: name,
	upstream: upstream,
	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,
	upstream: 'file://$upstreamPath/',
	localUpstream: false,
	useExistingCheckout: useExistingCheckout,
	);
	}

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

	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,
	upstream: '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 revision) {
	super.checkout(revision);
	// 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(
	globals.stdoutToString(result.stdout),
	) as Map<String, dynamic>;
	return Version.fromString(versionJson['frameworkVersion'] as String);
	}
	}

	/// 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',
	}) : assert(parentDirectory != null),
	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;
	}