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.
 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;

   /// Lazily-loaded directory for the repository checkout.
   ///
   /// Cloning a repository is time-consuming, thus the repository is not cloned
   /// until this getter is called.
   Directory get checkoutDirectory {
     if (_checkoutDirectory != null) {
       return _checkoutDirectory;
     }
     _checkoutDirectory = parentDirectory.childDirectory(name);
     if (checkoutDirectory.existsSync() && !useExistingCheckout) {
       deleteDirectory();
     }
     if (!checkoutDirectory.existsSync()) {
       stdio.printTrace('Cloning $name 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,
           );
         }
       }
     } else {
       stdio.printTrace(
         'Using existing $name repo at ${checkoutDirectory.path}...',
       );
     }
     return _checkoutDirectory;
   }

   void deleteDirectory() {
     if (!checkoutDirectory.existsSync()) {
       stdio.printTrace(
         'Tried to delete ${checkoutDirectory.path} but it does not exist.',
       );
       return;
     }
     stdio.printTrace('Deleting $name from ${checkoutDirectory.path}...');
     checkoutDirectory.deleteSync(recursive: true);
   }

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

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

   Version flutterVersion() {
     // Build tool
     processManager.runSync(<String>[
       fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
       'help',
     ]);
     // Check version
     final io.ProcessResult result = processManager.runSync(<String>[
       fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
       '--version',
       '--machine',
     ]);
     final Map<String, dynamic> versionJson = jsonDecode(
       globals.stdoutToString(result.stdout),
     ) as Map<String, dynamic>;
     return Version.fromString(versionJson['frameworkVersion'] as String);
   }

   /// 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) {
     assert(localUpstream);
     cloneName ??= 'clone-of-$name';
     return Repository(
       fileSystem: fileSystem,
       name: cloneName,
       parentDirectory: parentDirectory,
       platform: platform,
       processManager: processManager,
       stdio: stdio,
       upstream: 'file://${checkoutDirectory.path}/',
       useExistingCheckout: useExistingCheckout,
     );
   }
 }

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

 class Checkouts {
   Checkouts({
     @required Platform platform,
     @required this.fileSystem,
     @required this.processManager,
     Directory parentDirectory,
     String directoryName = 'checkouts',
   }) {
     if (parentDirectory != null) {
       directory = parentDirectory.childDirectory(directoryName);
     } else {
       String filePath;
       // If a test
       if (platform.script.scheme == 'data') {
         final RegExp pattern = RegExp(
           r'(file:\/\/[^"]*[/\\]dev\/tools[/\\][^"]+\.dart)',
           multiLine: true,
         );
         final Match match =
             pattern.firstMatch(Uri.decodeFull(platform.script.path));
         if (match == null) {
           throw Exception(
             'Cannot determine path of script!\n${platform.script.path}',
           );
         }
         filePath = Uri.parse(match.group(1)).path.replaceAll(r'%20', ' ');
       } else {
         filePath = platform.script.toFilePath();
       }
       final String checkoutsDirname = fileSystem.path.normalize(
         fileSystem.path.join(
           fileSystem.path.dirname(filePath),
           '..',
           'checkouts',
         ),
       );
       directory = fileSystem.directory(checkoutsDirname);
     }
     if (!directory.existsSync()) {
       directory.createSync(recursive: true);
     }
   }

   Directory directory;
   final FileSystem fileSystem;
   final ProcessManager processManager;

   Repository addRepo({
     @required RepositoryType repoType,
     @required Stdio stdio,
     @required Platform platform,
     FileSystem fileSystem,
     String upstream,
     String name,
     bool localUpstream = false,
     bool useExistingCheckout = false,
   }) {
     switch (repoType) {
       case RepositoryType.framework:
         name ??= 'framework';
         upstream ??= 'https://github.com/flutter/flutter.git';
         break;
       case RepositoryType.engine:
         name ??= 'engine';
         upstream ??= 'https://github.com/flutter/engine.git';
         break;
     }
     return Repository(
       name: name,
       upstream: upstream,
       stdio: stdio,
       platform: platform,
       fileSystem: fileSystem,
       parentDirectory: directory,
       processManager: processManager,
       localUpstream: localUpstream,
       useExistingCheckout: useExistingCheckout,
     );
   }
 }
	// 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.
	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;

	/// Lazily-loaded directory for the repository checkout.
	///
	/// Cloning a repository is time-consuming, thus the repository is not cloned
	/// until this getter is called.
	Directory get checkoutDirectory {
	if (_checkoutDirectory != null) {
	return _checkoutDirectory;
	}
	_checkoutDirectory = parentDirectory.childDirectory(name);
	if (checkoutDirectory.existsSync() && !useExistingCheckout) {
	deleteDirectory();
	}
	if (!checkoutDirectory.existsSync()) {
	stdio.printTrace('Cloning $name 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,
	);
	}
	}
	} else {
	stdio.printTrace(
	'Using existing $name repo at ${checkoutDirectory.path}...',
	);
	}
	return _checkoutDirectory;
	}

	void deleteDirectory() {
	if (!checkoutDirectory.existsSync()) {
	stdio.printTrace(
	'Tried to delete ${checkoutDirectory.path} but it does not exist.',
	);
	return;
	}
	stdio.printTrace('Deleting $name from ${checkoutDirectory.path}...');
	checkoutDirectory.deleteSync(recursive: true);
	}

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

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

	Version flutterVersion() {
	// Build tool
	processManager.runSync(<String>[
	fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
	'help',
	]);
	// Check version
	final io.ProcessResult result = processManager.runSync(<String>[
	fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
	'--version',
	'--machine',
	]);
	final Map<String, dynamic> versionJson = jsonDecode(
	globals.stdoutToString(result.stdout),
	) as Map<String, dynamic>;
	return Version.fromString(versionJson['frameworkVersion'] as String);
	}

	/// 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) {
	assert(localUpstream);
	cloneName ??= 'clone-of-$name';
	return Repository(
	fileSystem: fileSystem,
	name: cloneName,
	parentDirectory: parentDirectory,
	platform: platform,
	processManager: processManager,
	stdio: stdio,
	upstream: 'file://${checkoutDirectory.path}/',
	useExistingCheckout: useExistingCheckout,
	);
	}
	}

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

	class Checkouts {
	Checkouts({
	@required Platform platform,
	@required this.fileSystem,
	@required this.processManager,
	Directory parentDirectory,
	String directoryName = 'checkouts',
	}) {
	if (parentDirectory != null) {
	directory = parentDirectory.childDirectory(directoryName);
	} else {
	String filePath;
	// If a test
	if (platform.script.scheme == 'data') {
	final RegExp pattern = RegExp(
	r'(file:\/\/[^"]*[/\\]dev\/tools[/\\][^"]+\.dart)',
	multiLine: true,
	);
	final Match match =
	pattern.firstMatch(Uri.decodeFull(platform.script.path));
	if (match == null) {
	throw Exception(
	'Cannot determine path of script!\n${platform.script.path}',
	);
	}
	filePath = Uri.parse(match.group(1)).path.replaceAll(r'%20', ' ');
	} else {
	filePath = platform.script.toFilePath();
	}
	final String checkoutsDirname = fileSystem.path.normalize(
	fileSystem.path.join(
	fileSystem.path.dirname(filePath),
	'..',
	'checkouts',
	),
	);
	directory = fileSystem.directory(checkoutsDirname);
	}
	if (!directory.existsSync()) {
	directory.createSync(recursive: true);
	}
	}

	Directory directory;
	final FileSystem fileSystem;
	final ProcessManager processManager;

	Repository addRepo({
	@required RepositoryType repoType,
	@required Stdio stdio,
	@required Platform platform,
	FileSystem fileSystem,
	String upstream,
	String name,
	bool localUpstream = false,
	bool useExistingCheckout = false,
	}) {
	switch (repoType) {
	case RepositoryType.framework:
	name ??= 'framework';
	upstream ??= 'https://github.com/flutter/flutter.git';
	break;
	case RepositoryType.engine:
	name ??= 'engine';
	upstream ??= 'https://github.com/flutter/engine.git';
	break;
	}
	return Repository(
	name: name,
	upstream: upstream,
	stdio: stdio,
	platform: platform,
	fileSystem: fileSystem,
	parentDirectory: directory,
	processManager: processManager,
	localUpstream: localUpstream,
	useExistingCheckout: useExistingCheckout,
	);
	}
	}