Add validation for command parameters

Add validation for the parameters that each command accepts. Add logic to check if command has mandatory parameters and all of them are provided - if any of them is missing, command is not executed. Add logic to validate all arguments passed to command - if the command does not accept arguments, but there are some passed to it, it is not executed. Add ICommandParameter interface to describe command parameter. Add allowedParameters property to ICommand interface. Add canExecute method to ICommand interface. It is not mandatory to implement it and it is used when the command will validate the parameters on its own. The common validation is implemented in CommandsService.

ICommandParameter describes one parameter that the command accepts. It can be mandatory for the command or not. That's why I've added mandatory boolean parameter to the interface. Each parameter have its own logic for valid values, that's why ICommandParameter has validate method. It is called from the CommandsService when the arguments are validated. CommandsService itself tries to validate all command arguments. One special case is when the command is hierarchical. In this situation the root command is validated first, but it doesn't have own definition, so it doesn't have allowed parameters. That's why CommandsService checks if the command is valid hierarchical command. If command has canExecute method implemented, CommandsService will use it to validate the arguments. If not, it will try to validate all passed command line arguments with the allowed parameters of the command, by checking their count, calling validate method, etc.

Each command has different number of allowed parameters. In most of the cases the command parameter is string and the only requirement for it is to be non-empty. That's why new StringCommandParameter class is added. It is used to define such parameters. In case the parameter has more complicated logic, new class, that implements ICommandParameter is added for it.

Remove some tests as the validation logic is moved outside of some methods - in the command parameters. Add new unit tests.

https://huboard.com/NativeScript/nativescript-cli#/issues/48065867

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -18,6 +18,7 @@ $injector.require("analyticsSettingsService", "./services/analytics-settings-ser
 
 $injector.require("emulatorSettingsService", "./services/emulator-settings-service");
 
+$injector.require("platformCommandParameter", "./platform-command-param");
 $injector.requireCommand("create", "./commands/create-project");
 $injector.requireCommand("platform|*list", "./commands/list-platforms");
 $injector.requireCommand("platform|add", "./commands/add-platform");

lib/commands/add-platform.ts

@@ -1,12 +1,28 @@
 ///<reference path="../.d.ts"/>
+"use strict";
 
 export class AddPlatformCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService,
+		private $errors: IErrors) { }
 
 	execute(args: string[]): IFuture<void> {
 		return (() => {
 			this.$platformService.addPlatforms(args).wait();
 		}).future<void>()();
 	}
+
+	allowedParameters: ICommandParameter[] = [];
+
+	canExecute(args: string[]): IFuture<boolean> {
+		return (() => {
+			if(!args || args.length === 0) {
+				this.$errors.fail("No platform specified. Please specify a platform to add");
+			}
+
+			_.each(args, arg => this.$platformService.validatePlatform(arg));
+
+			return true;
+		}).future<boolean>()();
+	}
 }
 $injector.registerCommand("platform|add", AddPlatformCommand);

lib/commands/build.ts

@@ -1,12 +1,16 @@
 ///<reference path="../.d.ts"/>
+"use strict";
 
 export class BuildCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService,
+		private $platformCommandParameter: ICommandParameter) { }
 
 	execute(args: string[]): IFuture<void> {
 		return (() => {
 			this.$platformService.buildPlatform(args[0]).wait();
 		}).future<void>()();
 	}
+
+	allowedParameters = [this.$platformCommandParameter];
 }
 $injector.registerCommand("build", BuildCommand);

lib/commands/create-project.ts

@@ -1,7 +1,26 @@
 ///<reference path="../.d.ts"/>
+"use strict";
+
+export class ProjectCommandParameter implements ICommandParameter {
+	constructor(private $errors: IErrors,
+		private $projectNameValidator: IProjectNameValidator) { }
+
+	mandatory = true;
+	validate(value: string): IFuture<boolean> {
+		return (() => {
+			if(!value) {
+				this.$errors.fail("You must specify <App name> when creating a new project.");
+			}
+
+			return this.$projectNameValidator.validate(value);
+		}).future<boolean>()();
+	}
+}
 
 export class CreateProjectCommand implements ICommand {
-	constructor(private $projectService: IProjectService) { }
+	constructor(private $projectService: IProjectService,
+		private $errors: IErrors,
+		private $projectNameValidator: IProjectNameValidator) { }
 
 	public enableHooks = false;
 
@@ -10,5 +29,7 @@ export class CreateProjectCommand implements ICommand {
 			this.$projectService.createProject(args[0]).wait();
 		}).future<void>()();
 	}
+
+	allowedParameters = [new ProjectCommandParameter(this.$errors, this.$projectNameValidator) ]
 }
 $injector.registerCommand("create", CreateProjectCommand);

lib/commands/deploy.ts

@@ -1,10 +1,14 @@
 ///<reference path="../.d.ts"/>
+"use strict";
 
 export class DeployOnDeviceCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService,
+		private $platformCommandParameter: ICommandParameter) { }
 
 	execute(args: string[]): IFuture<void> {
 		return this.$platformService.deployOnDevice(args[0]);
 	}
+
+	allowedParameters = [this.$platformCommandParameter];
 }
-$injector.registerCommand("deploy", DeployOnDeviceCommand);
+$injector.registerCommand("deploy", DeployOnDeviceCommand);

lib/commands/emulate.ts

@@ -1,8 +1,11 @@
 ///<reference path="../.d.ts"/>
 
 export class EmulateCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService,
+		private $platformCommandParameter: ICommandParameter) { }
 
-	execute(args: string[]): IFuture<void> { return this.$platformService.deployOnEmulator(args[0]);}
+	execute(args: string[]): IFuture<void> { return this.$platformService.deployOnEmulator(args[0]); }
+
+	allowedParameters = [this.$platformCommandParameter];
 }
-$injector.registerCommand("emulate", EmulateCommand);
+$injector.registerCommand("emulate", EmulateCommand);

lib/commands/list-devices.ts

@@ -4,7 +4,8 @@ import util = require("util")
 
 export class ListDevicesCommand implements ICommand {
 	constructor(private $devicesServices: Mobile.IDevicesServices,
-				private $logger: ILogger) { }
+		private $logger: ILogger,
+		private $stringParameter: ICommandParameter) { }
 
 	execute(args: string[]): IFuture<void> {
 		return (() => {
@@ -17,5 +18,7 @@ export class ListDevicesCommand implements ICommand {
 			this.$devicesServices.execute(action, undefined, {allowNoDevices: true}).wait();
 		}).future<void>()();
 	}
+
+	allowedParameters = [this.$stringParameter];
 }
 $injector.registerCommand("list-devices", ListDevicesCommand);

lib/commands/list-platforms.ts

@@ -24,5 +24,7 @@ export class ListPlatformsCommand implements ICommand {
 			}
 		}).future<void>()();
 	}
+
+	allowedParameters: ICommandParameter[] = [];
 }
 $injector.registerCommand("platform|*list", ListPlatformsCommand);

lib/commands/post-install.ts

@@ -21,5 +21,7 @@ export class PostInstallCommand implements ICommand {
 			this.$autoCompletionService.enableAutoCompletion().wait();
 		}).future<void>()();
 	}
+
+	public allowedParameters: ICommandParameter[] = [];
 }
 $injector.registerCommand("dev-post-install", PostInstallCommand);

lib/commands/prepare.ts

@@ -1,12 +1,15 @@
 ///<reference path="../.d.ts"/>
 
 export class PrepareCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService,
+		private $platformCommandParameter: ICommandParameter) { }
 
 	execute(args: string[]): IFuture<void> {
 		return (() => {
 			this.$platformService.preparePlatform(args[0]).wait();
 		}).future<void>()();
 	}
+
+	allowedParameters = [this.$platformCommandParameter];
 }
 $injector.registerCommand("prepare", PrepareCommand);