Polish CLI init command

Rename a few classes and methods and extract some logic into helper
classes. Also change 2 char shortcuts to a single char.

Closes gh-1751

Author: philwebb

spring-boot-cli/src/main/java/org/springframework/boot/cli/command/init/Dependency.java

@@ -22,36 +22,30 @@
  * @author Stephane Nicoll
  * @since 1.2.0
  */
-class Dependency {
+final class Dependency {
 
-	private String id;
+	private final String id;
 
-	private String name;
+	private final String name;
 
-	private String description;
+	private final String description;
 
-	public String getId() {
-		return this.id;
+	public Dependency(String id, String name, String description) {
+		this.id = id;
+		this.name = name;
+		this.description = description;
 	}
 
-	public void setId(String id) {
-		this.id = id;
+	public String getId() {
+		return this.id;
 	}
 
 	public String getName() {
 		return this.name;
 	}
 
-	public void setName(String name) {
-		this.name = name;
-	}
-
 	public String getDescription() {
 		return this.description;
 	}
 
-	public void setDescription(String description) {
-		this.description = description;
-	}
-
 }

spring-boot-cli/src/main/java/org/springframework/boot/cli/command/init/InitCommand.java

@@ -16,9 +16,18 @@
 
 package org.springframework.boot.cli.command.init;
 
+import java.io.IOException;
+import java.util.Arrays;
+
+import joptsimple.OptionSet;
+import joptsimple.OptionSpec;
+
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.springframework.boot.cli.command.Command;
 import org.springframework.boot.cli.command.OptionParsingCommand;
+import org.springframework.boot.cli.command.options.OptionHandler;
+import org.springframework.boot.cli.command.status.ExitStatus;
+import org.springframework.boot.cli.util.Log;
 
 /**
  * {@link Command} that initializes a project using Spring initializr.
@@ -28,13 +37,168 @@
  */
 public class InitCommand extends OptionParsingCommand {
 
-	InitCommand(InitCommandOptionHandler handler) {
-		super("init", "Initialize a new project structure from Spring Initializr",
-				handler);
+	public InitCommand(InitOptionHandler handler) {
+		super("init", "Initialize a new project using Spring "
+				+ "Initialzr (start.spring.io)", handler);
 	}
 
 	public InitCommand() {
-		this(new InitCommandOptionHandler(HttpClientBuilder.create().build()));
+		this(new InitOptionHandler(getInitializrService()));
+	}
+
+	private static InitializrService getInitializrService() {
+		return new InitializrService(HttpClientBuilder.create().build());
+	}
+
+	private static class InitOptionHandler extends OptionHandler {
+
+		private final ServiceCapabilitiesReportGenerator serviceCapabilitiesReport;
+
+		private final ProjectGenerator projectGenerator;
+
+		private OptionSpec<String> target;
+
+		private OptionSpec<Void> listCapabilities;
+
+		private OptionSpec<String> bootVersion;
+
+		private OptionSpec<String> dependencies;
+
+		private OptionSpec<String> javaVersion;
+
+		private OptionSpec<String> packaging;
+
+		private OptionSpec<String> build;
+
+		private OptionSpec<String> format;
+
+		private OptionSpec<String> type;
+
+		private OptionSpec<Void> extract;
+
+		private OptionSpec<Void> force;
+
+		private OptionSpec<String> output;
+
+		InitOptionHandler(InitializrService initializrService) {
+			this.serviceCapabilitiesReport = new ServiceCapabilitiesReportGenerator(
+					initializrService);
+			this.projectGenerator = new ProjectGenerator(initializrService);
+
+		}
+
+		@Override
+		protected void options() {
+			this.target = option(Arrays.asList("target"), "URL of the service to use")
+					.withRequiredArg().defaultsTo(
+							ProjectGenerationRequest.DEFAULT_SERVICE_URL);
+			this.listCapabilities = option(Arrays.asList("list", "l"),
+					"List the capabilities of the service. Use it to discover the "
+							+ "dependencies and the types that are available");
+			projectGenerationOptions();
+			otherOptions();
+		}
+
+		private void projectGenerationOptions() {
+			this.bootVersion = option(Arrays.asList("boot-version", "b"),
+					"Spring Boot version to use (for example '1.2.0.RELEASE')")
+					.withRequiredArg();
+			this.dependencies = option(
+					Arrays.asList("dependencies", "d"),
+					"Comma separated list of dependencies to include in the "
+							+ "generated project").withRequiredArg();
+			this.javaVersion = option(Arrays.asList("java-version", "j"),
+					"Java version to use (for example '1.8')").withRequiredArg();
+			this.packaging = option(Arrays.asList("packaging", "p"),
+					"Packaging type to use (for example 'jar')").withRequiredArg();
+			this.build = option("build",
+					"The build system to use (for example 'maven' or 'gradle')")
+					.withRequiredArg().defaultsTo("maven");
+			this.format = option(
+					"format",
+					"The format of the generated content (for example 'build' for a build file, "
+							+ "'project' for a project archive)").withRequiredArg()
+					.defaultsTo("project");
+			this.type = option(
+					Arrays.asList("type", "t"),
+					"The project type to use. Not normally needed if you use --build "
+							+ "and/or --format. Check the capabilities of the service "
+							+ "(--list) for more details").withRequiredArg();
+		}
+
+		private void otherOptions() {
+			this.extract = option(Arrays.asList("extract", "x"),
+					"Extract the project archive");
+			this.force = option(Arrays.asList("force", "f"),
+					"Force overwrite of existing files");
+			this.output = option(
+					Arrays.asList("output", "o"),
+					"Location of the generated project. Can be an absolute or a "
+							+ "relative reference and should refer to a directory when "
+							+ "--extract is used").withRequiredArg();
+		}
+
+		@Override
+		protected ExitStatus run(OptionSet options) throws Exception {
+			try {
+				if (options.has(this.listCapabilities)) {
+					generateReport(options);
+				}
+				else {
+					generateProject(options);
+				}
+				return ExitStatus.OK;
+			}
+			catch (ReportableException ex) {
+				Log.error(ex.getMessage());
+				return ExitStatus.ERROR;
+			}
+			catch (Exception ex) {
+				Log.error(ex);
+				return ExitStatus.ERROR;
+			}
+		}
+
+		private void generateReport(OptionSet options) throws IOException {
+			Log.info(this.serviceCapabilitiesReport.generate(options.valueOf(this.target)));
+		}
+
+		protected void generateProject(OptionSet options) throws IOException {
+			ProjectGenerationRequest request = createProjectGenerationRequest(options);
+			this.projectGenerator.generateProject(request, options.has(this.force),
+					options.has(this.extract), options.valueOf(this.output));
+		}
+
+		protected ProjectGenerationRequest createProjectGenerationRequest(
+				OptionSet options) {
+			ProjectGenerationRequest request = new ProjectGenerationRequest();
+			request.setServiceUrl(options.valueOf(this.target));
+			if (options.has(this.bootVersion)) {
+				request.setBootVersion(options.valueOf(this.bootVersion));
+			}
+			if (options.has(this.dependencies)) {
+				for (String dep : options.valueOf(this.dependencies).split(",")) {
+					request.getDependencies().add(dep.trim());
+				}
+			}
+			if (options.has(this.javaVersion)) {
+				request.setJavaVersion(options.valueOf(this.javaVersion));
+			}
+			if (options.has(this.packaging)) {
+				request.setPackaging(options.valueOf(this.packaging));
+			}
+			request.setBuild(options.valueOf(this.build));
+			request.setFormat(options.valueOf(this.format));
+			request.setDetectType(options.has(this.build) || options.has(this.format));
+			if (options.has(this.type)) {
+				request.setType(options.valueOf(this.type));
+			}
+			if (options.has(this.output)) {
+				request.setOutput(options.valueOf(this.output));
+			}
+			return request;
+		}
+
 	}
 
 }