Android releated commands - platform add, prepare, build and platform list

lib/bootstrap.ts

@@ -3,8 +3,17 @@ require("./common/bootstrap");
 $injector.require("nativescript-cli", "./nativescript-cli");
 
 $injector.require("projectService", "./services/project-service");
+$injector.require("androidProjectService", "./services/project-service");
+$injector.require("iOSProjectService", "./services/project-service");
 $injector.require("projectTemplatesService", "./services/project-templates-service");
+$injector.require("platformService", "./services/platform-service");
 
-$injector.requireCommand("create", "./commands/create-project-command");
+$injector.requireCommand("create", "./commands/create-project");
+$injector.requireCommand("platform|*list", "./commands/list-platforms");
+$injector.requireCommand("platform|add", "./commands/add-platform");
+$injector.requireCommand("run", "./commands/run");
+$injector.requireCommand("prepare", "./commands/prepare");
+$injector.requireCommand("build", "./commands/build");
 
 $injector.require("npm", "./node-package-manager");
+$injector.require("propertiesParser", "./properties-parser");

lib/commands/add-platform.ts

@@ -0,0 +1,12 @@
+///<reference path="../.d.ts"/>
+
+export class AddPlatformCommand implements ICommand {
+	constructor(private $platformService: IPlatformService) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.addPlatforms(args).wait();
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("platform|add", AddPlatformCommand);

lib/commands/build.ts

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

lib/commands/list-platforms.ts

@@ -0,0 +1,20 @@
+///<reference path="../.d.ts"/>
+import helpers = require("./../common/helpers");
+
+export class ListPlatformsCommand implements ICommand {
+	constructor(private $platformService: IPlatformService,
+		private $logger: ILogger) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			var availablePlatforms = this.$platformService.getAvailablePlatforms().wait();
+			this.$logger.out("Available platforms: %s", helpers.formatListOfNames(availablePlatforms));
+
+			var installedPlatforms = this.$platformService.getInstalledPlatforms().wait();
+			this.$logger.out("Installed platforms %s", helpers.formatListOfNames(installedPlatforms));
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("platform|*list", ListPlatformsCommand);
+
+

lib/commands/prepare.ts

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

lib/commands/run.ts

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

lib/declarations.ts

@@ -1,5 +1,9 @@
 interface INodePackageManager {
-    cache: string;
-    load(config?: any): IFuture<void>;
-    install(where: string, what: string): IFuture<any>;
+	cache: string;
+	load(config?: any): IFuture<void>;
+	install(where: string, what: string): IFuture<any>;
+}
+
+interface IPropertiesParser {
+	createEditor(filePath: string): IFuture<any>;
 }

lib/definitions/platform.d.ts

@@ -0,0 +1,12 @@
+interface IPlatformService {
+	addPlatforms(platforms: string[]): IFuture<void>;
+	getInstalledPlatforms(): IFuture<string[]>;
+	getAvailablePlatforms(): IFuture<string[]>;
+	runPlatform(platform: string): IFuture<void>;
+	preparePlatform(platform: string): IFuture<void>;
+	buildPlatform(platform: string): IFuture<void>;
+}
+
+interface IPlatformCapabilities {
+	targetedOS?: string[];
+}

lib/definitions/project.d.ts

@@ -1,7 +1,26 @@
 interface IProjectService {
 	createProject(projectName: string, projectId: string): IFuture<void>;
+	createPlatformSpecificProject(platform: string): IFuture<void>;
+	prepareProject(normalizedPlatformName: string, platforms: string[]): IFuture<void>;
+	buildProject(platform: string): IFuture<void>;
+	ensureProject(): void;
+	projectData: IProjectData;
+}
+
+interface IPlatformProjectService {
+	createProject(projectData: IProjectData): IFuture<void>;
+	buildProject(projectData: IProjectData): IFuture<void>;
+}
+
+interface IProjectData {
+	projectDir: string;
+	platformsDir: string;
+	projectFilePath: string;
+	projectId?: string;
+	projectName?: string;
 }
 
 interface IProjectTemplatesService {
 	defaultTemplatePath: IFuture<string>;
+	installAndroidFramework(whereToInstall: string): IFuture<string>
 }

lib/definitions/properties-parser.d.ts

@@ -0,0 +1,3 @@
+declare module "properties-parser" {
+	function createEditor(path: string, callback: (err: IErrors, data: any) => void);
+}

lib/definitions/shelljs.d.ts

@@ -2,4 +2,5 @@ declare module "shelljs" {
 	function cp(arg: string, sourcePath: string, destinationPath: string): void;
 	function sed(arg: string, oldValue: any, newValue: string, filePath: string): void;
 	function mv(source: string[], destination: string);
+	function grep(what: any, where: string): any;
 }

lib/nativescript-cli.ts

@@ -1,16 +1,16 @@
 ///<reference path=".d.ts"/>
+"use strict";
 
-import Fiber = require("fibers");
-import Future = require("fibers/future");
 import path = require("path");
 
+require("./common/extensions");
 require("./bootstrap");
 require("./options");
 
 import errors = require("./common/errors");
 errors.installUncaughtExceptionListener();
 
-$injector.register("config", {"CI_LOGGER": false});
+$injector.register("config", {"CI_LOGGER": false, PROJECT_FILE_NAME: ".tnsproject", "DEBUG": process.env.NATIVESCRIPT_DEBUG});
 
 var dispatcher = $injector.resolve("dispatcher");
-dispatcher.runMainFiber();
+dispatcher.runMainFiber();

lib/node-package-manager.ts

@@ -33,4 +33,4 @@ export class NodePackageManager implements INodePackageManager {
 		return future;
 	}
 }
-$injector.register("npm", NodePackageManager);
+$injector.register("npm", NodePackageManager);

lib/options.ts

@@ -10,6 +10,7 @@ var knownOpts:any = {
 		"path" : String,
 		"copy-from": String,
 		"link-to": String,
+		"release": String,
 		"version": Boolean,
 		"help": Boolean
 	},

lib/properties-parser.ts

@@ -0,0 +1,20 @@
+///<reference path=".d.ts"/>
+
+import propertiesParser = require("properties-parser");
+import Future = require("fibers/future");
+
+export class PropertiesParser implements IPropertiesParser {
+	public createEditor(filePath: string) {
+		var future = new Future<any>();
+		propertiesParser.createEditor(filePath,  (err, data) => {
+			if(err) {
+				future.throw(err);
+			} else {
+				future.return(data);
+			}
+		});
+
+		return future;
+	}
+}
+$injector.register("propertiesParser", PropertiesParser);

lib/services/platform-service.ts

@@ -0,0 +1,147 @@
+///<reference path="../.d.ts"/>
+
+import path = require("path");
+import util = require("util");
+import helpers = require("./../common/helpers");
+
+export class PlatformService implements IPlatformService {
+	private platformCapabilities: { [key: string]: IPlatformCapabilities } = {
+		ios: {
+			targetedOS: ['darwin']
+		},
+		android: {
+		}
+	};
+
+	private platformNames = [];
+
+	constructor(private $errors: IErrors,
+				private $fs: IFileSystem,
+				private $projectService: IProjectService) {
+		this.platformNames = Object.keys(this.platformCapabilities);
+	}
+
+	public getCapabilities(platform: string): IPlatformCapabilities {
+		return this.platformCapabilities[platform];
+	}
+
+	public addPlatforms(platforms: string[]): IFuture<void> {
+		return (() => {
+			if(!platforms || platforms.length === 0) {
+				this.$errors.fail("No platform specified. Please specify a platform to add");
+			}
+
+			this.$projectService.ensureProject();
+
+			var platformsDir = this.$projectService.projectData.platformsDir;
+			this.$fs.ensureDirectoryExists(platformsDir).wait();
+
+			_.each(platforms, platform => {
+				this.addPlatform(platform.toLowerCase()).wait();
+			});
+
+		}).future<void>()();
+	}
+
+	private addPlatform(platform: string): IFuture<void> {
+		return(() => {
+			platform = platform.split("@")[0];
+
+			this.validatePlatform(platform);
+
+			var platformPath = path.join(this.$projectService.projectData.platformsDir, platform);
+
+			// TODO: Check for version compatability if the platform is in format platform@version. This should be done in PR for semanting versioning
+
+			if (this.$fs.exists(platformPath).wait()) {
+				this.$errors.fail("Platform %s already added", platform);
+			}
+
+			// Copy platform specific files in platforms dir
+			this.$projectService.createPlatformSpecificProject(platform).wait();
+
+		}).future<void>()();
+	}
+
+	public getInstalledPlatforms(): IFuture<string[]> {
+		return(() => {
+			if(!this.$fs.exists(this.$projectService.projectData.platformsDir).wait()) {
+				return [];
+			}
+
+			var subDirs = this.$fs.readDirectory(this.$projectService.projectData.platformsDir).wait();
+			return _.filter(subDirs, p => { return this.platformNames.indexOf(p) > -1; });
+		}).future<string[]>()();
+	}
+
+	public getAvailablePlatforms(): IFuture<string[]> {
+		return (() => {
+			var installedPlatforms = this.getInstalledPlatforms().wait();
+			return _.filter(this.platformNames, p => {
+				return installedPlatforms.indexOf(p) < 0 && this.isPlatformSupportedForOS(p); // Only those not already installed
+			});
+		}).future<string[]>()();
+	}
+
+	public runPlatform(platform: string): IFuture<void> {
+		return (() => {
+
+		}).future<void>()();
+	}
+
+	public preparePlatform(platform: string): IFuture<void> {
+		return (() => {
+			platform = platform.toLowerCase();
+			this.validatePlatform(platform);
+			var normalizedPlatformName = this.normalizePlatformName(platform);
+
+			this.$projectService.prepareProject(normalizedPlatformName, this.platformNames).wait();
+		}).future<void>()();
+	}
+
+	public buildPlatform(platform: string): IFuture<void> {
+		return (() => {
+			platform = platform.toLocaleLowerCase();
+			this.validatePlatform(platform);
+
+			this.$projectService.buildProject(platform).wait();
+		}).future<void>()();
+	}
+
+	private validatePlatform(platform: string): void {
+		if (!this.isValidPlatform(platform)) {
+			this.$errors.fail("Invalid platform %s. Valid platforms are %s.", platform, helpers.formatListOfNames(this.platformNames));
+		}
+
+		if (!this.isPlatformSupportedForOS(platform)) {
+			this.$errors.fail("Applications for platform %s can not be built on this OS - %s", platform, process.platform);
+		}
+	}
+
+	private isValidPlatform(platform: string) {
+		return this.platformCapabilities[platform];
+	}
+
+	private isPlatformSupportedForOS(platform: string): boolean {
+		var platformCapabilities = this.getCapabilities(platform);
+		var targetedOS = platformCapabilities.targetedOS;
+
+		if(!targetedOS || targetedOS.indexOf("*") >= 0 || targetedOS.indexOf(process.platform) >= 0) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private normalizePlatformName(platform: string): string {
+		switch(platform) {
+			case "android":
+				return "Android";
+			case "ios":
+				return "iOS";
+		}
+
+		return undefined;
+	}
+}
+$injector.register("platformService", PlatformService);