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);