| // 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:async'; |
| |
| import 'package:meta/meta.dart'; |
| import 'package:package_config/package_config.dart'; |
| import 'package:process/process.dart'; |
| |
| import '../base/bot_detector.dart'; |
| import '../base/common.dart'; |
| import '../base/context.dart'; |
| import '../base/file_system.dart'; |
| import '../base/io.dart' as io; |
| import '../base/io.dart'; |
| import '../base/logger.dart'; |
| import '../base/platform.dart'; |
| import '../base/process.dart'; |
| import '../cache.dart'; |
| import '../convert.dart'; |
| import '../dart/package_map.dart'; |
| import '../project.dart'; |
| import '../reporting/reporting.dart'; |
| |
| /// The [Pub] instance. |
| Pub get pub => context.get<Pub>()!; |
| |
| /// The console environment key used by the pub tool. |
| const String _kPubEnvironmentKey = 'PUB_ENVIRONMENT'; |
| |
| /// The console environment key used by the pub tool to find the cache directory. |
| const String _kPubCacheEnvironmentKey = 'PUB_CACHE'; |
| |
| typedef MessageFilter = String? Function(String message); |
| |
| /// globalCachePath is the directory in which the content of the localCachePath will be moved in |
| void joinCaches({ |
| required FileSystem fileSystem, |
| required Directory globalCacheDirectory, |
| required Directory dependencyDirectory, |
| }) { |
| for (final FileSystemEntity entity in dependencyDirectory.listSync()) { |
| final String newPath = fileSystem.path.join(globalCacheDirectory.path, entity.basename); |
| if (entity is File) { |
| if (!fileSystem.file(newPath).existsSync()) { |
| entity.copySync(newPath); |
| } |
| } else if (entity is Directory) { |
| if (!globalCacheDirectory.childDirectory(entity.basename).existsSync()) { |
| final Directory newDirectory = globalCacheDirectory.childDirectory(entity.basename); |
| newDirectory.createSync(); |
| joinCaches( |
| fileSystem: fileSystem, |
| globalCacheDirectory: newDirectory, |
| dependencyDirectory: entity, |
| ); |
| } |
| } |
| } |
| } |
| |
| Directory createDependencyDirectory(Directory pubGlobalDirectory, String dependencyName) { |
| final Directory newDirectory = pubGlobalDirectory.childDirectory(dependencyName); |
| newDirectory.createSync(); |
| return newDirectory; |
| } |
| |
| bool tryDelete(Directory directory, Logger logger) { |
| try { |
| if (directory.existsSync()) { |
| directory.deleteSync(recursive: true); |
| } |
| } on FileSystemException { |
| logger.printWarning('Failed to delete directory at: ${directory.path}'); |
| return false; |
| } |
| return true; |
| } |
| |
| /// When local cache (flutter_root/.pub-cache) and global cache (HOME/.pub-cache) are present a |
| /// merge needs to be done leaving only the global |
| /// |
| /// Valid pubCache should look like this ./localCachePath/.pub-cache/hosted/pub.dartlang.org |
| bool needsToJoinCache({ |
| required FileSystem fileSystem, |
| required String localCachePath, |
| required Directory? globalDirectory, |
| }) { |
| if (globalDirectory == null) { |
| return false; |
| } |
| final Directory localDirectory = fileSystem.directory(localCachePath); |
| |
| return globalDirectory.childDirectory('hosted').childDirectory('pub.dartlang.org').existsSync() && |
| localDirectory.childDirectory('hosted').childDirectory('pub.dartlang.org').existsSync(); |
| } |
| |
| /// Represents Flutter-specific data that is added to the `PUB_ENVIRONMENT` |
| /// environment variable and allows understanding the type of requests made to |
| /// the package site on Flutter's behalf. |
| // DO NOT update without contacting kevmoo. |
| // We have server-side tooling that assumes the values are consistent. |
| class PubContext { |
| PubContext._(this._values) { |
| for (final String item in _values) { |
| if (!_validContext.hasMatch(item)) { |
| throw ArgumentError.value( |
| _values, 'value', 'Must match RegExp ${_validContext.pattern}'); |
| } |
| } |
| } |
| |
| static PubContext getVerifyContext(String commandName) => |
| PubContext._(<String>['verify', commandName.replaceAll('-', '_')]); |
| |
| static final PubContext create = PubContext._(<String>['create']); |
| static final PubContext createPackage = PubContext._(<String>['create_pkg']); |
| static final PubContext createPlugin = PubContext._(<String>['create_plugin']); |
| static final PubContext interactive = PubContext._(<String>['interactive']); |
| static final PubContext pubGet = PubContext._(<String>['get']); |
| static final PubContext pubUpgrade = PubContext._(<String>['upgrade']); |
| static final PubContext pubAdd = PubContext._(<String>['add']); |
| static final PubContext pubRemove = PubContext._(<String>['remove']); |
| static final PubContext pubForward = PubContext._(<String>['forward']); |
| static final PubContext pubPassThrough = PubContext._(<String>['passthrough']); |
| static final PubContext runTest = PubContext._(<String>['run_test']); |
| static final PubContext flutterTests = PubContext._(<String>['flutter_tests']); |
| static final PubContext updatePackages = PubContext._(<String>['update_packages']); |
| |
| final List<String> _values; |
| |
| static final RegExp _validContext = RegExp('[a-z][a-z_]*[a-z]'); |
| |
| @override |
| String toString() => 'PubContext: ${_values.join(':')}'; |
| |
| String toAnalyticsString() { |
| return _values.map((String s) => s.replaceAll('_', '-')).toList().join('-'); |
| } |
| } |
| |
| /// A handle for interacting with the pub tool. |
| abstract class Pub { |
| /// Create a default [Pub] instance. |
| factory Pub({ |
| required FileSystem fileSystem, |
| required Logger logger, |
| required ProcessManager processManager, |
| required Platform platform, |
| required BotDetector botDetector, |
| required Usage usage, |
| }) = _DefaultPub; |
| |
| /// Create a [Pub] instance with a mocked [stdio]. |
| @visibleForTesting |
| factory Pub.test({ |
| required FileSystem fileSystem, |
| required Logger logger, |
| required ProcessManager processManager, |
| required Platform platform, |
| required BotDetector botDetector, |
| required Usage usage, |
| required Stdio stdio, |
| }) = _DefaultPub.test; |
| |
| /// Runs `pub get` for [project]. |
| /// |
| /// [context] provides extra information to package server requests to |
| /// understand usage. |
| /// |
| /// If [shouldSkipThirdPartyGenerator] is true, the overall pub get will be |
| /// skipped if the package config file has a "generator" other than "pub". |
| /// Defaults to true. |
| /// Will also resolve dependencies in the example folder if present. |
| Future<void> get({ |
| required PubContext context, |
| required FlutterProject project, |
| bool upgrade = false, |
| bool offline = false, |
| String? flutterRootOverride, |
| bool checkUpToDate = false, |
| bool shouldSkipThirdPartyGenerator = true, |
| bool printProgress = true, |
| }); |
| |
| /// Runs pub in 'batch' mode. |
| /// |
| /// forwarding complete lines written by pub to its stdout/stderr streams to |
| /// the corresponding stream of this process, optionally applying filtering. |
| /// The pub process will not receive anything on its stdin stream. |
| /// |
| /// The `--trace` argument is passed to `pub` when `showTraceForErrors` |
| /// `isRunningOnBot` is true. |
| /// |
| /// [context] provides extra information to package server requests to |
| /// understand usage. |
| Future<void> batch( |
| List<String> arguments, { |
| required PubContext context, |
| String? directory, |
| MessageFilter? filter, |
| String failureMessage = 'pub failed', |
| }); |
| |
| /// Runs pub in 'interactive' mode. |
| /// |
| /// This will run the pub process with StdioInherited (unless [_stdio] is set |
| /// for testing). |
| /// |
| /// The pub process will be run in current working directory, so `--directory` |
| /// should be passed appropriately in [arguments]. This ensures output from |
| /// pub will refer to relative paths correctly. |
| /// |
| /// [touchesPackageConfig] should be true if this is a command expexted to |
| /// create a new `.dart_tool/package_config.json` file. |
| Future<void> interactively( |
| List<String> arguments, { |
| FlutterProject? project, |
| required PubContext context, |
| required String command, |
| bool touchesPackageConfig = false, |
| bool generateSyntheticPackage = false, |
| bool printProgress = true, |
| }); |
| } |
| |
| class _DefaultPub implements Pub { |
| _DefaultPub({ |
| required FileSystem fileSystem, |
| required Logger logger, |
| required ProcessManager processManager, |
| required Platform platform, |
| required BotDetector botDetector, |
| required Usage usage, |
| }) : _fileSystem = fileSystem, |
| _logger = logger, |
| _platform = platform, |
| _botDetector = botDetector, |
| _usage = usage, |
| _processUtils = ProcessUtils( |
| logger: logger, |
| processManager: processManager, |
| ), |
| _processManager = processManager, |
| _stdio = null; |
| |
| @visibleForTesting |
| _DefaultPub.test({ |
| required FileSystem fileSystem, |
| required Logger logger, |
| required ProcessManager processManager, |
| required Platform platform, |
| required BotDetector botDetector, |
| required Usage usage, |
| required Stdio stdio, |
| }) : _fileSystem = fileSystem, |
| _logger = logger, |
| _platform = platform, |
| _botDetector = botDetector, |
| _usage = usage, |
| _processUtils = ProcessUtils( |
| logger: logger, |
| processManager: processManager, |
| ), |
| _processManager = processManager, |
| _stdio = stdio; |
| |
| final FileSystem _fileSystem; |
| final Logger _logger; |
| final ProcessUtils _processUtils; |
| final Platform _platform; |
| final BotDetector _botDetector; |
| final Usage _usage; |
| final ProcessManager _processManager; |
| final Stdio? _stdio; |
| |
| @override |
| Future<void> get({ |
| required PubContext context, |
| required FlutterProject project, |
| bool upgrade = false, |
| bool offline = false, |
| bool generateSyntheticPackage = false, |
| bool generateSyntheticPackageForExample = false, |
| String? flutterRootOverride, |
| bool checkUpToDate = false, |
| bool shouldSkipThirdPartyGenerator = true, |
| bool printProgress = true, |
| }) async { |
| final String directory = project.directory.path; |
| final File packageConfigFile = project.packageConfigFile; |
| final File lastVersion = _fileSystem.file( |
| _fileSystem.path.join(directory, '.dart_tool', 'version')); |
| final File currentVersion = _fileSystem.file( |
| _fileSystem.path.join(Cache.flutterRoot!, 'version')); |
| final File pubspecYaml = project.pubspecFile; |
| final File pubLockFile = _fileSystem.file( |
| _fileSystem.path.join(directory, 'pubspec.lock') |
| ); |
| |
| if (shouldSkipThirdPartyGenerator && project.packageConfigFile.existsSync()) { |
| Map<String, Object?> packageConfigMap; |
| try { |
| packageConfigMap = jsonDecode( |
| project.packageConfigFile.readAsStringSync(), |
| ) as Map<String, Object?>; |
| } on FormatException { |
| packageConfigMap = <String, Object?>{}; |
| } |
| |
| final bool isPackageConfigGeneratedByThirdParty = |
| packageConfigMap.containsKey('generator') && |
| packageConfigMap['generator'] != 'pub'; |
| |
| if (isPackageConfigGeneratedByThirdParty) { |
| _logger.printTrace('Skipping pub get: generated by third-party.'); |
| return; |
| } |
| } |
| |
| // If the pubspec.yaml is older than the package config file and the last |
| // flutter version used is the same as the current version skip pub get. |
| // This will incorrectly skip pub on the master branch if dependencies |
| // are being added/removed from the flutter framework packages, but this |
| // can be worked around by manually running pub. |
| if (checkUpToDate && |
| packageConfigFile.existsSync() && |
| pubLockFile.existsSync() && |
| pubspecYaml.lastModifiedSync().isBefore(pubLockFile.lastModifiedSync()) && |
| pubspecYaml.lastModifiedSync().isBefore(packageConfigFile.lastModifiedSync()) && |
| lastVersion.existsSync() && |
| lastVersion.readAsStringSync() == currentVersion.readAsStringSync()) { |
| _logger.printTrace('Skipping pub get: version match.'); |
| return; |
| } |
| |
| final String command = upgrade ? 'upgrade' : 'get'; |
| final bool verbose = _logger.isVerbose; |
| final List<String> args = <String>[ |
| if (_logger.supportsColor) |
| '--color', |
| if (verbose) |
| '--verbose', |
| '--directory', |
| _fileSystem.path.relative(directory), |
| ...<String>[ |
| command, |
| ], |
| if (offline) |
| '--offline', |
| '--example', |
| ]; |
| await _runWithStdioInherited( |
| args, |
| command: command, |
| context: context, |
| directory: directory, |
| failureMessage: 'pub $command failed', |
| flutterRootOverride: flutterRootOverride, |
| printProgress: printProgress |
| ); |
| await _updateVersionAndPackageConfig(project); |
| } |
| |
| /// Runs pub with [arguments] and [ProcessStartMode.inheritStdio] mode. |
| /// |
| /// Uses [ProcessStartMode.normal] and [Pub._stdio] if [Pub.test] constructor |
| /// was used. |
| /// |
| /// Prints the stdout and stderr of the whole run, unless silenced using |
| /// [printProgress]. |
| /// |
| /// Sends an analytics event. |
| Future<void> _runWithStdioInherited( |
| List<String> arguments, { |
| required String command, |
| required bool printProgress, |
| required PubContext context, |
| required String directory, |
| String failureMessage = 'pub failed', |
| String? flutterRootOverride, |
| }) async { |
| int exitCode; |
| |
| final List<String> pubCommand = _pubCommand(arguments); |
| final Map<String, String> pubEnvironment = await _createPubEnvironment(context, flutterRootOverride); |
| |
| try { |
| if (printProgress) { |
| final io.Stdio? stdio = _stdio; |
| if (stdio == null) { |
| // Let pub inherit stdio and output directly to the tool's stdout and |
| // stderr handles. |
| final io.Process process = await _processUtils.start( |
| pubCommand, |
| workingDirectory: _fileSystem.path.current, |
| environment: pubEnvironment, |
| mode: ProcessStartMode.inheritStdio, |
| ); |
| |
| exitCode = await process.exitCode; |
| } else { |
| // Omit [mode] parameter to send output to [process.stdout] and |
| // [process.stderr]. |
| final io.Process process = await _processUtils.start( |
| pubCommand, |
| workingDirectory: _fileSystem.path.current, |
| environment: pubEnvironment, |
| ); |
| |
| // Direct pub output to [Pub._stdio] for tests. |
| final StreamSubscription<List<int>> stdoutSubscription = |
| process.stdout.listen(stdio.stdout.add); |
| final StreamSubscription<List<int>> stderrSubscription = |
| process.stderr.listen(stdio.stderr.add); |
| |
| await Future.wait<void>(<Future<void>>[ |
| stdoutSubscription.asFuture<void>(), |
| stderrSubscription.asFuture<void>(), |
| ]); |
| |
| unawaited(stdoutSubscription.cancel()); |
| unawaited(stderrSubscription.cancel()); |
| |
| exitCode = await process.exitCode; |
| } |
| } else { |
| // Do not try to use [ProcessUtils.start] here, because it requires you |
| // to read all data out of the stdout and stderr streams. If you don't |
| // read the streams, it may appear to work fine on your platform but |
| // will block the tool's process on Windows. |
| // See https://api.dart.dev/stable/dart-io/Process/start.html |
| // |
| // [ProcessUtils.run] will send the output to [result.stdout] and |
| // [result.stderr], which we will ignore. |
| final RunResult result = await _processUtils.run( |
| pubCommand, |
| workingDirectory: _fileSystem.path.current, |
| environment: pubEnvironment, |
| ); |
| |
| exitCode = result.exitCode; |
| } |
| // The exception is rethrown, so don't catch only Exceptions. |
| } catch (exception) { // ignore: avoid_catches_without_on_clauses |
| if (exception is io.ProcessException) { |
| final StringBuffer buffer = StringBuffer('${exception.message}\n'); |
| final String directoryExistsMessage = _fileSystem.directory(directory).existsSync() |
| ? 'exists' |
| : 'does not exist'; |
| buffer.writeln('Working directory: "$directory" ($directoryExistsMessage)'); |
| final Map<String, String> env = await _createPubEnvironment(context, flutterRootOverride); |
| buffer.write(_stringifyPubEnv(env)); |
| throw io.ProcessException( |
| exception.executable, |
| exception.arguments, |
| buffer.toString(), |
| exception.errorCode, |
| ); |
| } |
| rethrow; |
| } |
| |
| final int code = exitCode; |
| final String result = code == 0 ? 'success' : 'failure'; |
| PubResultEvent( |
| context: context.toAnalyticsString(), |
| result: result, |
| usage: _usage, |
| ).send(); |
| |
| if (code != 0) { |
| final StringBuffer buffer = StringBuffer('$failureMessage\n'); |
| buffer.writeln('command: "${pubCommand.join(' ')}"'); |
| buffer.write(_stringifyPubEnv(pubEnvironment)); |
| buffer.writeln('exit code: $code'); |
| throwToolExit( |
| buffer.toString(), |
| exitCode: code, |
| ); |
| } |
| } |
| |
| // For surfacing pub env in crash reporting |
| String _stringifyPubEnv(Map<String, String> map, {String prefix = 'pub env'}) { |
| if (map.isEmpty) { |
| return ''; |
| } |
| final StringBuffer buffer = StringBuffer(); |
| buffer.writeln('$prefix: {'); |
| for (final MapEntry<String, String> entry in map.entries) { |
| buffer.writeln(' "${entry.key}": "${entry.value}",'); |
| } |
| buffer.writeln('}'); |
| return buffer.toString(); |
| } |
| |
| @override |
| Future<void> batch( |
| List<String> arguments, { |
| required PubContext context, |
| String? directory, |
| MessageFilter? filter, |
| String failureMessage = 'pub failed', |
| String? flutterRootOverride, |
| }) async { |
| final bool showTraceForErrors = await _botDetector.isRunningOnBot; |
| |
| String lastPubMessage = 'no message'; |
| String? filterWrapper(String line) { |
| lastPubMessage = line; |
| if (filter == null) { |
| return line; |
| } |
| return filter(line); |
| } |
| |
| if (showTraceForErrors) { |
| arguments.insert(0, '--trace'); |
| } |
| final Map<String, String> pubEnvironment = await _createPubEnvironment(context, flutterRootOverride); |
| final List<String> pubCommand = _pubCommand(arguments); |
| final int code = await _processUtils.stream( |
| pubCommand, |
| workingDirectory: directory, |
| mapFunction: filterWrapper, // may set versionSolvingFailed, lastPubMessage |
| environment: pubEnvironment, |
| ); |
| |
| String result = 'success'; |
| if (code != 0) { |
| result = 'failure'; |
| } |
| PubResultEvent( |
| context: context.toAnalyticsString(), |
| result: result, |
| usage: _usage, |
| ).send(); |
| |
| if (code != 0) { |
| final StringBuffer buffer = StringBuffer('$failureMessage\n'); |
| buffer.writeln('command: "${pubCommand.join(' ')}"'); |
| buffer.write(_stringifyPubEnv(pubEnvironment)); |
| buffer.writeln('exit code: $code'); |
| buffer.writeln('last line of pub output: "${lastPubMessage.trim()}"'); |
| throwToolExit( |
| buffer.toString(), |
| exitCode: code, |
| ); |
| } |
| } |
| |
| @override |
| Future<void> interactively( |
| List<String> arguments, { |
| FlutterProject? project, |
| required PubContext context, |
| required String command, |
| bool touchesPackageConfig = false, |
| bool generateSyntheticPackage = false, |
| bool printProgress = true, |
| }) async { |
| await _runWithStdioInherited( |
| arguments, |
| command: command, |
| directory: _fileSystem.currentDirectory.path, |
| context: context, |
| printProgress: printProgress, |
| ); |
| if (touchesPackageConfig && project != null) { |
| await _updateVersionAndPackageConfig(project); |
| } |
| } |
| |
| /// The command used for running pub. |
| List<String> _pubCommand(List<String> arguments) { |
| // TODO(zanderso): refactor to use artifacts. |
| final String sdkPath = _fileSystem.path.joinAll(<String>[ |
| Cache.flutterRoot!, |
| 'bin', |
| 'cache', |
| 'dart-sdk', |
| 'bin', |
| 'dart', |
| ]); |
| if (!_processManager.canRun(sdkPath)) { |
| throwToolExit( |
| 'Your Flutter SDK download may be corrupt or missing permissions to run. ' |
| 'Try re-downloading the Flutter SDK into a directory that has read/write ' |
| 'permissions for the current user.' |
| ); |
| } |
| return <String>[sdkPath, '__deprecated_pub', ...arguments]; |
| } |
| |
| // Returns the environment value that should be used when running pub. |
| // |
| // Includes any existing environment variable, if one exists. |
| // |
| // [context] provides extra information to package server requests to |
| // understand usage. |
| Future<String> _getPubEnvironmentValue(PubContext pubContext) async { |
| // DO NOT update this function without contacting kevmoo. |
| // We have server-side tooling that assumes the values are consistent. |
| final String? existing = _platform.environment[_kPubEnvironmentKey]; |
| final List<String> values = <String>[ |
| if (existing != null && existing.isNotEmpty) existing, |
| if (await _botDetector.isRunningOnBot) 'flutter_bot', |
| 'flutter_cli', |
| ...pubContext._values, |
| ]; |
| return values.join(':'); |
| } |
| |
| /// There are 3 ways to get the pub cache location |
| /// |
| /// 1) Provide the _kPubCacheEnvironmentKey. |
| /// 2) There is a local cache (in the Flutter SDK) but not a global one (in the user's home directory). |
| /// 3) If both local and global are available then merge the local into global and return the global. |
| String? _getPubCacheIfAvailable() { |
| if (_platform.environment.containsKey(_kPubCacheEnvironmentKey)) { |
| return _platform.environment[_kPubCacheEnvironmentKey]; |
| } |
| |
| final String localCachePath = _fileSystem.path.join(Cache.flutterRoot!, '.pub-cache'); |
| final Directory? globalDirectory; |
| if (_platform.isWindows) { |
| globalDirectory = _getWindowsGlobalDirectory; |
| } |
| else { |
| if (_platform.environment['HOME'] == null) { |
| globalDirectory = null; |
| } else { |
| final String homeDirectoryPath = _platform.environment['HOME']!; |
| globalDirectory = _fileSystem.directory(_fileSystem.path.join(homeDirectoryPath, '.pub-cache')); |
| } |
| } |
| |
| if (needsToJoinCache( |
| fileSystem: _fileSystem, |
| localCachePath: localCachePath, |
| globalDirectory: globalDirectory, |
| )) { |
| final Directory localDirectoryPub = _fileSystem.directory( |
| _fileSystem.path.join(localCachePath, 'hosted', 'pub.dartlang.org') |
| ); |
| final Directory globalDirectoryPub = _fileSystem.directory( |
| _fileSystem.path.join(globalDirectory!.path, 'hosted', 'pub.dartlang.org') |
| ); |
| for (final FileSystemEntity entity in localDirectoryPub.listSync()) { |
| if (entity is Directory && !globalDirectoryPub.childDirectory(entity.basename).existsSync()){ |
| try { |
| final Directory newDirectory = createDependencyDirectory(globalDirectoryPub, entity.basename); |
| joinCaches( |
| fileSystem: _fileSystem, |
| globalCacheDirectory: newDirectory, |
| dependencyDirectory: entity, |
| ); |
| } on FileSystemException { |
| if (!tryDelete(globalDirectoryPub.childDirectory(entity.basename), _logger)) { |
| _logger.printWarning('The join of pub-caches failed'); |
| _logger.printStatus('Running "dart pub cache repair"'); |
| _processManager.runSync(<String>['dart', 'pub', 'cache', 'repair']); |
| } |
| } |
| } |
| } |
| tryDelete(_fileSystem.directory(localCachePath), _logger); |
| return globalDirectory.path; |
| } else if (globalDirectory != null && globalDirectory.existsSync()) { |
| return globalDirectory.path; |
| } else if (_fileSystem.directory(localCachePath).existsSync()) { |
| return localCachePath; |
| } |
| // Use pub's default location by returning null. |
| return null; |
| } |
| |
| Directory? get _getWindowsGlobalDirectory { |
| // %LOCALAPPDATA% is preferred as the cache location over %APPDATA%, because the latter is synchronised between |
| // devices when the user roams between them, whereas the former is not. |
| // The default cache dir used to be in %APPDATA%, so to avoid breaking old installs, |
| // we use the old dir in %APPDATA% if it exists. Else, we use the new default location |
| // in %LOCALAPPDATA%. |
| for (final String envVariable in <String>['APPDATA', 'LOCALAPPDATA']) { |
| if (_platform.environment[envVariable] != null) { |
| final String homePath = _platform.environment[envVariable]!; |
| final Directory globalDirectory = _fileSystem.directory(_fileSystem.path.join(homePath, 'Pub', 'Cache')); |
| if (globalDirectory.existsSync()) { |
| return globalDirectory; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /// The full environment used when running pub. |
| /// |
| /// [context] provides extra information to package server requests to |
| /// understand usage. |
| Future<Map<String, String>> _createPubEnvironment(PubContext context, [ String? flutterRootOverride ]) async { |
| final Map<String, String> environment = <String, String>{ |
| 'FLUTTER_ROOT': flutterRootOverride ?? Cache.flutterRoot!, |
| _kPubEnvironmentKey: await _getPubEnvironmentValue(context), |
| }; |
| final String? pubCache = _getPubCacheIfAvailable(); |
| if (pubCache != null) { |
| environment[_kPubCacheEnvironmentKey] = pubCache; |
| } |
| return environment; |
| } |
| |
| /// Updates the .dart_tool/version file to be equal to current Flutter |
| /// version. |
| /// |
| /// Calls [_updatePackageConfig] for [project] and [project.example] (if it |
| /// exists). |
| /// |
| /// This should be called after pub invocations that are expected to update |
| /// the packageConfig. |
| Future<void> _updateVersionAndPackageConfig(FlutterProject project) async { |
| if (!project.packageConfigFile.existsSync()) { |
| throwToolExit('${project.directory}: pub did not create .dart_tools/package_config.json file.'); |
| } |
| final File lastVersion = _fileSystem.file( |
| _fileSystem.path.join(project.directory.path, '.dart_tool', 'version'), |
| ); |
| final File currentVersion = _fileSystem.file( |
| _fileSystem.path.join(Cache.flutterRoot!, 'version')); |
| lastVersion.writeAsStringSync(currentVersion.readAsStringSync()); |
| |
| await _updatePackageConfig(project); |
| if (project.hasExampleApp && project.example.pubspecFile.existsSync()) { |
| await _updatePackageConfig(project.example); |
| } |
| } |
| |
| /// Update the package configuration file in [project]. |
| /// |
| /// Creates a corresponding `package_config_subset` file that is used by the |
| /// build system to avoid rebuilds caused by an updated pub timestamp. |
| /// |
| /// if `project.generateSyntheticPackage` is `true` then insert flutter_gen |
| /// synthetic package into the package configuration. This is used by the l10n |
| /// localization tooling to insert a new reference into the package_config |
| /// file, allowing the import of a package URI that is not specified in the |
| /// pubspec.yaml |
| /// |
| /// For more information, see: |
| /// * [generateLocalizations], `in lib/src/localizations/gen_l10n.dart` |
| Future<void> _updatePackageConfig(FlutterProject project) async { |
| final File packageConfigFile = project.packageConfigFile; |
| final PackageConfig packageConfig = await loadPackageConfigWithLogging(packageConfigFile, logger: _logger); |
| |
| packageConfigFile.parent |
| .childFile('package_config_subset') |
| .writeAsStringSync(_computePackageConfigSubset( |
| packageConfig, |
| _fileSystem, |
| )); |
| |
| if (!project.manifest.generateSyntheticPackage) { |
| return; |
| } |
| if (packageConfig.packages.any((Package package) => package.name == 'flutter_gen')) { |
| return; |
| } |
| |
| // TODO(jonahwillams): Using raw json manipulation here because |
| // savePackageConfig always writes to local io, and it changes absolute |
| // paths to relative on round trip. |
| // See: https://github.com/dart-lang/package_config/issues/99, |
| // and: https://github.com/dart-lang/package_config/issues/100. |
| |
| // Because [loadPackageConfigWithLogging] succeeded [packageConfigFile] |
| // we can rely on the file to exist and be correctly formatted. |
| final Map<String, dynamic> jsonContents = |
| json.decode(packageConfigFile.readAsStringSync()) as Map<String, dynamic>; |
| |
| (jsonContents['packages'] as List<dynamic>).add(<String, dynamic>{ |
| 'name': 'flutter_gen', |
| 'rootUri': 'flutter_gen', |
| 'languageVersion': '2.12', |
| }); |
| |
| packageConfigFile.writeAsStringSync(json.encode(jsonContents)); |
| } |
| |
| // Subset the package config file to only the parts that are relevant for |
| // rerunning the dart compiler. |
| String _computePackageConfigSubset(PackageConfig packageConfig, FileSystem fileSystem) { |
| final StringBuffer buffer = StringBuffer(); |
| for (final Package package in packageConfig.packages) { |
| buffer.writeln(package.name); |
| buffer.writeln(package.languageVersion); |
| buffer.writeln(package.root); |
| buffer.writeln(package.packageUriRoot); |
| } |
| buffer.writeln(packageConfig.version); |
| return buffer.toString(); |
| } |
| } |