packages.dart 9.35 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5
import '../base/common.dart';
6
import '../base/os.dart';
7 8 9 10
import '../build_info.dart';
import '../build_system/build_system.dart';
import '../cache.dart';
import '../dart/generate_synthetic_packages.dart';
11
import '../dart/pub.dart';
12
import '../globals.dart' as globals;
13
import '../project.dart';
14
import '../reporting/reporting.dart';
15 16 17 18
import '../runner/flutter_command.dart';

class PackagesCommand extends FlutterCommand {
  PackagesCommand() {
19 20 21
    addSubcommand(PackagesGetCommand('get', false));
    addSubcommand(PackagesGetCommand('upgrade', true));
    addSubcommand(PackagesTestCommand());
22
    addSubcommand(PackagesPublishCommand());
23 24 25 26 27
    addSubcommand(PackagesForwardCommand('downgrade', 'Downgrade packages in a Flutter project', requiresPubspec: true));
    addSubcommand(PackagesForwardCommand('deps', 'Print package dependencies', requiresPubspec: true));
    addSubcommand(PackagesForwardCommand('run', 'Run an executable from a package', requiresPubspec: true));
    addSubcommand(PackagesForwardCommand('cache', 'Work with the Pub system cache'));
    addSubcommand(PackagesForwardCommand('version', 'Print Pub version'));
28
    addSubcommand(PackagesForwardCommand('uploader', 'Manage uploaders for a package on pub.dev'));
29
    addSubcommand(PackagesForwardCommand('global', 'Work with Pub global packages'));
30
    addSubcommand(PackagesForwardCommand('outdated', 'Analyze dependencies to find which ones can be upgraded', requiresPubspec: true));
31
    addSubcommand(PackagesPassthroughCommand());
32 33 34
  }

  @override
35
  final String name = 'pub';
36 37

  @override
38
  List<String> get aliases => const <String>['packages'];
39 40 41 42

  @override
  final String description = 'Commands for managing Flutter packages.';

43
  @override
44
  Future<FlutterCommandResult> runCommand() async => null;
45 46 47
}

class PackagesGetCommand extends FlutterCommand {
48
  PackagesGetCommand(this.name, this.upgrade) {
49
    requiresPubspecYaml();
50 51
    argParser.addFlag('offline',
      negatable: false,
52
      help: 'Use cached packages instead of accessing the network.',
53 54
    );
  }
55

56 57 58 59 60
  @override
  final String name;

  final bool upgrade;

61
  @override
62 63 64
  String get description {
    return '${ upgrade ? "Upgrade" : "Get" } packages in a Flutter project.';
  }
65 66

  @override
67
  String get invocation {
68
    return '${runner.executableName} pub $name [<target directory>]';
69
  }
70

71
  @override
72 73
  Future<Map<CustomDimensions, String>> get usageValues async {
    final Map<CustomDimensions, String> usageValues = <CustomDimensions, String>{};
74 75 76 77 78 79
    final String workingDirectory = argResults.rest.length == 1 ? argResults.rest[0] : null;
    final String target = findProjectRoot(workingDirectory);
    if (target == null) {
      return usageValues;
    }
    final FlutterProject rootProject = FlutterProject.fromPath(target);
80
    final bool hasPlugins = rootProject.flutterPluginsFile.existsSync();
81
    if (hasPlugins) {
82
      final int numberOfPlugins = (rootProject.flutterPluginsFile.readAsLinesSync()).length;
83
      usageValues[CustomDimensions.commandPackagesNumberPlugins] = '$numberOfPlugins';
84
    } else {
85
      usageValues[CustomDimensions.commandPackagesNumberPlugins] = '0';
86
    }
87
    usageValues[CustomDimensions.commandPackagesProjectModule] = '${rootProject.isModule}';
88 89
    usageValues[CustomDimensions.commandPackagesAndroidEmbeddingVersion] =
        rootProject.android.getEmbeddingVersion().toString().split('.').last;
90 91 92
    return usageValues;
  }

93
  Future<void> _runPubGet(String directory, FlutterProject flutterProject) async {
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    if (flutterProject.manifest.generateSyntheticPackage) {
      final Environment environment = Environment(
        artifacts: globals.artifacts,
        logger: globals.logger,
        cacheDir: globals.cache.getRoot(),
        engineVersion: globals.flutterVersion.engineRevision,
        fileSystem: globals.fs,
        flutterRootDir: globals.fs.directory(Cache.flutterRoot),
        outputDir: globals.fs.directory(getBuildDirectory()),
        processManager: globals.processManager,
        projectDir: flutterProject.directory,
      );

      await generateLocalizationsSyntheticPackage(
        environment: environment,
        buildSystem: globals.buildSystem,
      );
    }

113 114
    final Stopwatch pubGetTimer = Stopwatch()..start();
    try {
115 116
      await pub.get(
        context: PubContext.pubGet,
117 118
        directory: directory,
        upgrade: upgrade ,
119
        offline: boolArg('offline'),
120
        checkLastModified: false,
121
        generateSyntheticPackage: flutterProject.manifest.generateSyntheticPackage,
122 123
      );
      pubGetTimer.stop();
124
      globals.flutterUsage.sendTiming('pub', 'get', pubGetTimer.elapsed, label: 'success');
125 126
    // Not limiting to catching Exception because the exception is rethrown.
    } catch (_) { // ignore: avoid_catches_without_on_clauses
127
      pubGetTimer.stop();
128
      globals.flutterUsage.sendTiming('pub', 'get', pubGetTimer.elapsed, label: 'failure');
129 130
      rethrow;
    }
131 132
  }

133
  @override
134
  Future<FlutterCommandResult> runCommand() async {
135
    if (argResults.rest.length > 1) {
136
      throwToolExit('Too many arguments.\n$usage');
137
    }
138

139 140
    final String workingDirectory = argResults.rest.length == 1 ? argResults.rest[0] : null;
    final String target = findProjectRoot(workingDirectory);
141
    if (target == null) {
142
      throwToolExit(
143
       'Expected to find project root in '
144
       '${ workingDirectory ?? "current working directory" }.'
145 146
      );
    }
147
    final FlutterProject rootProject = FlutterProject.fromPath(target);
148 149

    await _runPubGet(target, rootProject);
150
    await rootProject.ensureReadyForPlatformSpecificTooling(checkProjects: true);
151 152 153 154

    // Get/upgrade packages in example app as well
    if (rootProject.hasExampleApp) {
      final FlutterProject exampleProject = rootProject.example;
155
      await _runPubGet(exampleProject.directory.path, exampleProject);
156
      await exampleProject.ensureReadyForPlatformSpecificTooling(checkProjects: true);
157
    }
158

159
    return FlutterCommandResult.success();
160 161
  }
}
162 163

class PackagesTestCommand extends FlutterCommand {
164 165 166 167
  PackagesTestCommand() {
    requiresPubspecYaml();
  }

168 169 170 171 172 173
  @override
  String get name => 'test';

  @override
  String get description {
    return 'Run the "test" package.\n'
174 175 176 177
           'This is similar to "flutter test", but instead of hosting the tests in the '
           'flutter environment it hosts the tests in a pure Dart environment. The main '
           'differences are that the "dart:ui" library is not available and that tests '
           'run faster. This is helpful for testing libraries that do not depend on any '
178 179 180 181 182
           'packages from the Flutter SDK. It is equivalent to "pub run test".';
  }

  @override
  String get invocation {
183
    return '${runner.executableName} pub test [<tests...>]';
184 185 186
  }

  @override
187
  Future<FlutterCommandResult> runCommand() async {
188
    await pub.batch(<String>['run', 'test', ...argResults.rest], context: PubContext.runTest, retry: false);
189
    return FlutterCommandResult.success();
190
  }
191 192
}

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
class PackagesPublishCommand extends FlutterCommand {
  PackagesPublishCommand() {
    requiresPubspecYaml();
    argParser.addFlag('dry-run',
      abbr: 'n',
      negatable: false,
      help: 'Validate but do not publish the package.',
    );
    argParser.addFlag('force',
      abbr: 'f',
      negatable: false,
      help: 'Publish without confirmation if there are no errors.',
    );
  }

  @override
  String get name => 'publish';

  @override
  String get description {
    return 'Publish the current package to pub.dev';
  }

  @override
  String get invocation {
    return '${runner.executableName} pub publish [--dry-run]';
  }

  @override
  Future<FlutterCommandResult> runCommand() async {
    final List<String> args = <String>[
      ...argResults.rest,
225 226
      if (boolArg('dry-run')) '--dry-run',
      if (boolArg('force')) '--force',
227
    ];
228
    await pub.interactively(<String>['publish', ...args], stdio: globals.stdio);
229
    return FlutterCommandResult.success();
230 231 232
  }
}

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
class PackagesForwardCommand extends FlutterCommand {
  PackagesForwardCommand(this._commandName, this._description, {bool requiresPubspec = false}) {
    if (requiresPubspec) {
      requiresPubspecYaml();
    }
  }
  final String _commandName;
  final String _description;

  @override
  String get name => _commandName;

  @override
  String get description {
    return '$_description.\n'
           'This runs the "pub" tool in a Flutter context.';
  }

  @override
  String get invocation {
253
    return '${runner.executableName} pub $_commandName [<arguments...>]';
254 255 256 257
  }

  @override
  Future<FlutterCommandResult> runCommand() async {
258
    await pub.interactively(<String>[_commandName, ...argResults.rest], stdio: globals.stdio);
259
    return FlutterCommandResult.success();
260 261 262 263
  }

}

264
class PackagesPassthroughCommand extends FlutterCommand {
265 266 267
  PackagesPassthroughCommand() {
    requiresPubspecYaml();
  }
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283

  @override
  String get name => 'pub';

  @override
  String get description {
    return 'Pass the remaining arguments to Dart\'s "pub" tool.\n'
           'This runs the "pub" tool in a Flutter context.';
  }

  @override
  String get invocation {
    return '${runner.executableName} packages pub [<arguments...>]';
  }

  @override
284
  Future<FlutterCommandResult> runCommand() async {
285
    await pub.interactively(argResults.rest, stdio: globals.stdio);
286
    return FlutterCommandResult.success();
287
  }
288
}