| // Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file | |
| // for details. 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 'dart:convert'; | |
| import 'dart:io' as io; | |
| import 'dart:math' as math; | |
| import 'package:meta/meta.dart'; | |
| import 'package:path/path.dart' as p; | |
| import 'package:stagehand/stagehand.dart' as stagehand; | |
| import '../core.dart'; | |
| import '../events.dart'; | |
| import '../sdk.dart'; | |
| /// A command to create a new project from a set of templates. | |
| class CreateCommand extends DartdevCommand<int> { | |
| static const String cmdName = 'create'; | |
| static String defaultTemplateId = 'console-simple'; | |
| static List<String> legalTemplateIds = [ | |
| 'console-simple', | |
| 'console-full', | |
| 'package-simple', | |
| 'web-simple' | |
| ]; | |
| static Iterable<stagehand.Generator> get generators => | |
| legalTemplateIds.map(retrieveTemplateGenerator); | |
| static stagehand.Generator retrieveTemplateGenerator(String templateId) => | |
| stagehand.getGenerator(templateId); | |
| CreateCommand({bool verbose = false}) | |
| : super(cmdName, 'Create a new project.') { | |
| argParser.addOption( | |
| 'template', | |
| allowed: legalTemplateIds, | |
| help: 'The project template to use.', | |
| defaultsTo: defaultTemplateId, | |
| abbr: 't', | |
| ); | |
| argParser.addFlag('pub', | |
| defaultsTo: true, | |
| help: "Whether to run 'pub get' after the project has been created."); | |
| argParser.addFlag( | |
| 'list-templates', | |
| negatable: false, | |
| hide: !verbose, | |
| help: 'List the available templates in JSON format.', | |
| ); | |
| argParser.addFlag( | |
| 'force', | |
| negatable: false, | |
| help: 'Force project generation, even if the target directory already ' | |
| 'exists.', | |
| ); | |
| } | |
| @override | |
| String get invocation => '${super.invocation} <directory>'; | |
| @override | |
| FutureOr<int> runImpl() async { | |
| if (argResults['list-templates']) { | |
| log.stdout(_availableTemplatesJson()); | |
| return 0; | |
| } | |
| if (argResults.rest.isEmpty) { | |
| printUsage(); | |
| return 1; | |
| } | |
| String templateId = argResults['template']; | |
| String dir = argResults.rest.first; | |
| var targetDir = io.Directory(dir); | |
| if (targetDir.existsSync() && !argResults['force']) { | |
| log.stderr( | |
| "Directory '$dir' already exists " | |
| "(use '--force' to force project generation).", | |
| ); | |
| return 73; | |
| } | |
| log.stdout( | |
| 'Creating ${log.ansi.emphasized(p.absolute(dir))} ' | |
| 'using template $templateId...', | |
| ); | |
| log.stdout(''); | |
| var generator = retrieveTemplateGenerator(templateId); | |
| await generator.generate( | |
| p.basename(dir), | |
| DirectoryGeneratorTarget(generator, io.Directory(dir)), | |
| ); | |
| if (argResults['pub']) { | |
| if (!Sdk.checkArtifactExists(sdk.pubSnapshot)) { | |
| return 255; | |
| } | |
| log.stdout(''); | |
| var progress = log.progress('Running pub get'); | |
| var process = await startDartProcess( | |
| sdk, | |
| [sdk.pubSnapshot, 'get', '--no-precompile'], | |
| cwd: dir, | |
| ); | |
| // Run 'pub get'. We display output from the pub command, but keep the | |
| // output terse. This is to give the user a sense of the work that pub | |
| // did without scrolling the previous stdout sections off the screen. | |
| var buffer = StringBuffer(); | |
| routeToStdout( | |
| process, | |
| logToTrace: true, | |
| listener: (str) { | |
| // Filter lines like '+ multi_server_socket 1.0.2'. | |
| if (!str.startsWith('+ ')) { | |
| buffer.writeln(' $str'); | |
| } | |
| }, | |
| ); | |
| int code = await process.exitCode; | |
| if (code != 0) return code; | |
| progress.finish(showTiming: true); | |
| log.stdout(buffer.toString().trimRight()); | |
| } | |
| log.stdout(''); | |
| log.stdout('Created project $dir! In order to get started, type:'); | |
| log.stdout(''); | |
| log.stdout(log.ansi.emphasized(' cd ${p.relative(dir)}')); | |
| // TODO(devoncarew): Once we have a 'run' command, print out here how to run | |
| // the app. | |
| log.stdout(''); | |
| return 0; | |
| } | |
| @override | |
| UsageEvent createUsageEvent(int exitCode) => CreateUsageEvent( | |
| usagePath, | |
| exitCode: exitCode, | |
| args: argResults.arguments, | |
| ); | |
| @override | |
| String get usageFooter { | |
| int width = legalTemplateIds.map((s) => s.length).reduce(math.max); | |
| String desc = generators.map((g) { | |
| String suffix = g.id == defaultTemplateId ? ' (default)' : ''; | |
| return ' ${g.id.padLeft(width)}: ${g.description}$suffix'; | |
| }).join('\n'); | |
| return '\nAvailable templates:\n$desc'; | |
| } | |
| String _availableTemplatesJson() { | |
| var items = generators.map((stagehand.Generator generator) { | |
| var m = { | |
| 'name': generator.id, | |
| 'label': generator.label, | |
| 'description': generator.description, | |
| 'categories': generator.categories | |
| }; | |
| if (generator.entrypoint != null) { | |
| m['entrypoint'] = generator.entrypoint.path; | |
| } | |
| return m; | |
| }); | |
| JsonEncoder encoder = const JsonEncoder.withIndent(' '); | |
| return encoder.convert(items.toList()); | |
| } | |
| } | |
| /// The [UsageEvent] for the create command. | |
| class CreateUsageEvent extends UsageEvent { | |
| CreateUsageEvent(String usagePath, | |
| {String label, @required int exitCode, @required List<String> args}) | |
| : super(CreateCommand.cmdName, usagePath, | |
| label: label, exitCode: exitCode, args: args); | |
| } | |
| class DirectoryGeneratorTarget extends stagehand.GeneratorTarget { | |
| final stagehand.Generator generator; | |
| final io.Directory dir; | |
| DirectoryGeneratorTarget(this.generator, this.dir) { | |
| dir.createSync(); | |
| } | |
| @override | |
| Future createFile(String path, List<int> contents) async { | |
| io.File file = io.File(p.join(dir.path, path)); | |
| String name = p.relative(file.path, from: dir.path); | |
| log.stdout(' $name'); | |
| await file.create(recursive: true); | |
| await file.writeAsBytes(contents); | |
| } | |
| } |