Refactor project and platform services

Author: Fatme

lib/bootstrap.ts

@@ -6,8 +6,12 @@ $injector.require("projectData", "./services/project-service");
 $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("platformsData", "./services/platform-service");
 $injector.require("platformService", "./services/platform-service");
+$injector.require("platformProjectService", "./services/platform-service");
 
 $injector.requireCommand("create", "./commands/create-project");
 $injector.requireCommand("platform|*list", "./commands/list-platforms");

lib/declarations.ts

@@ -2,6 +2,8 @@ interface INodePackageManager {
 	cache: string;
 	load(config?: any): IFuture<void>;
 	install(where: string, what: string): IFuture<any>;
+	tryExecuteAction(action: any, args?: any[]): IFuture<void>;
+	downloadNpmPackage(packageName: string, pathToSave?: string): IFuture<string>;
 }
 
 interface IPropertiesParser {

lib/definitions/platform.d.ts

@@ -7,6 +7,15 @@ interface IPlatformService {
 	buildPlatform(platform: string): IFuture<void>;
 }
 
-interface IPlatformCapabilities {
+interface IPlatformData {
+	frameworkPackageName: string;
+	platformProjectService: IPlatformSpecificProjectService;
+	projectRoot: string;
 	targetedOS?: string[];
-}
+}
+
+interface IPlatformsData {
+	platformsNames: string[];
+	getPlatformData(platform: string): IPlatformData;
+}
+

lib/definitions/project.d.ts

@@ -1,25 +1,29 @@
 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;
 }
 
-interface IPlatformProjectService {
-	createProject(): IFuture<void>;
-	buildProject(): IFuture<void>;
-}
-
 interface IProjectData {
 	projectDir: string;
+	projectName: string;
 	platformsDir: string;
 	projectFilePath: string;
 	projectId?: string;
-	projectName?: string;
 }
 
 interface IProjectTemplatesService {
 	defaultTemplatePath: IFuture<string>;
-	installAndroidFramework(whereToInstall: string): IFuture<string>
+}
+
+interface IPlatformProjectService {
+	createProject(platform: string): IFuture<void>;
+	buildProject(platform: string): IFuture<void>;
+}
+
+interface IPlatformSpecificProjectService {
+	validate(): void;
+	checkRequirements(): IFuture<void>;
+	createProject(projectRoot: string, frameworkDir: string): IFuture<void>;
+	interpolateData(projectRoot: string): void;
+	executePlatformSpecificAction(projectRoot: string, frameworkDir: string): void;
 }

lib/node-package-manager.ts

@@ -3,8 +3,14 @@
 import npm = require("npm");
 import Future = require("fibers/future");
 import shell = require("shelljs");
+import path = require("path");
 
 export class NodePackageManager implements INodePackageManager {
+	private static NPM_LOAD_FAILED = "Failed to retrieve data from npm. Please try again a little bit later.";
+
+	constructor(private $logger: ILogger,
+		private $errors: IErrors) { }
+
 	public get cache(): string {
 		return npm.cache;
 	}
@@ -32,5 +38,30 @@ export class NodePackageManager implements INodePackageManager {
 		});
 		return future;
 	}
+
+	public tryExecuteAction(action: any, args?: any[]): IFuture<void> {
+		return (() => {
+			try {
+				this.load().wait(); // It's obligatory to execute load before whatever npm function
+				action(args);
+			} catch(error) {
+				this.$logger.debug(error);
+				this.$errors.fail(NodePackageManager.NPM_LOAD_FAILED);
+			}
+		}).future<void>()();
+	}
+
+	public downloadNpmPackage(packageName: string, pathToSave?: string): IFuture<string> {
+		return (() => {
+			var action = (packageName: string) => {
+				this.install(pathToSave || npm.cache, packageName).wait();
+			};
+
+			this.tryExecuteAction(action, [packageName]).wait();
+
+			return path.join(pathToSave || npm.cache, "node_modules", packageName);
+
+		}).future<string>()();
+	}
 }
 $injector.register("npm", NodePackageManager);

lib/services/platform-service.ts

@@ -4,26 +4,43 @@ import path = require("path");
 import util = require("util");
 import helpers = require("./../common/helpers");
 
-export class PlatformService implements IPlatformService {
-	private platformCapabilities: { [key: string]: IPlatformCapabilities } = {
+class PlatformsData implements IPlatformsData {
+	private platformsData: { [key: string]: IPlatformData } = {
 		ios: {
+			frameworkPackageName: "tns-ios",
+			platformProjectService: $injector.resolve("iOSProjectService"),
+			projectRoot: "",
 			targetedOS: ['darwin']
 		},
 		android: {
+			frameworkPackageName: "tns-android",
+			platformProjectService: $injector.resolve("androidProjectService"),
+			projectRoot: ""
 		}
 	};
 
-	private platformNames = [];
+	constructor($projectData: IProjectData) {
+		this.platformsData["ios"].projectRoot = "";
+		this.platformsData["android"].projectRoot = path.join($projectData.platformsDir, "android");
+	}
+
+	public get platformsNames() {
+		return Object.keys(this.platformsData);
+	}
+
+	public getPlatformData(platform): IPlatformData {
+		return this.platformsData[platform];
+	}
+}
+$injector.register("platformsData", PlatformsData);
 
+export class PlatformService implements IPlatformService {
 	constructor(private $errors: IErrors,
 		private $fs: IFileSystem,
 		private $projectService: IProjectService,
-		private $projectData: IProjectData) {
-		this.platformNames = Object.keys(this.platformCapabilities);
-	}
-
-	public getCapabilities(platform: string): IPlatformCapabilities {
-		return this.platformCapabilities[platform];
+		private $platformProjectService: IPlatformProjectService,
+		private $projectData: IProjectData,
+		private $platformsData: IPlatformsData) {
 	}
 
 	public addPlatforms(platforms: string[]): IFuture<void> {
@@ -59,7 +76,7 @@ export class PlatformService implements IPlatformService {
 			}
 
 			// Copy platform specific files in platforms dir
-			this.$projectService.createPlatformSpecificProject(platform).wait();
+			this.$platformProjectService.createProject(platform).wait();
 
 		}).future<void>()();
 	}
@@ -71,14 +88,14 @@ export class PlatformService implements IPlatformService {
 			}
 
 			var subDirs = this.$fs.readDirectory(this.$projectData.platformsDir).wait();
-			return _.filter(subDirs, p => { return this.platformNames.indexOf(p) > -1; });
+			return _.filter(subDirs, p => { return this.$platformsData.platformsNames.indexOf(p) > -1; });
 		}).future<string[]>()();
 	}
 
 	public getAvailablePlatforms(): IFuture<string[]> {
 		return (() => {
 			var installedPlatforms = this.getInstalledPlatforms().wait();
-			return _.filter(this.platformNames, p => {
+			return _.filter(this.$platformsData.platformsNames, p => {
 				return installedPlatforms.indexOf(p) < 0 && this.isPlatformSupportedForOS(p); // Only those not already installed
 			});
 		}).future<string[]>()();
@@ -96,7 +113,7 @@ export class PlatformService implements IPlatformService {
 			this.validatePlatform(platform);
 			var normalizedPlatformName = this.normalizePlatformName(platform);
 
-			this.$projectService.prepareProject(normalizedPlatformName, this.platformNames).wait();
+			//this.$projectService.prepareProject(normalizedPlatformName, this.platformNames).wait();
 		}).future<void>()();
 	}
 
@@ -105,13 +122,13 @@ export class PlatformService implements IPlatformService {
 			platform = platform.toLocaleLowerCase();
 			this.validatePlatform(platform);
 
-			this.$projectService.buildProject(platform).wait();
+			this.$platformProjectService.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));
+			this.$errors.fail("Invalid platform %s. Valid platforms are %s.", platform, helpers.formatListOfNames(this.$platformsData.platformsNames));
 		}
 
 		if (!this.isPlatformSupportedForOS(platform)) {
@@ -120,12 +137,11 @@ export class PlatformService implements IPlatformService {
 	}
 
 	private isValidPlatform(platform: string) {
-		return this.platformCapabilities[platform];
+		return this.$platformsData.getPlatformData(platform);
 	}
 
 	private isPlatformSupportedForOS(platform: string): boolean {
-		var platformCapabilities = this.getCapabilities(platform);
-		var targetedOS = platformCapabilities.targetedOS;
+		var targetedOS = this.$platformsData.getPlatformData(platform).targetedOS;
 
 		if(!targetedOS || targetedOS.indexOf("*") >= 0 || targetedOS.indexOf(process.platform) >= 0) {
 			return true;
@@ -145,4 +161,4 @@ export class PlatformService implements IPlatformService {
 		return undefined;
 	}
 }
-$injector.register("platformService", PlatformService);
+$injector.register("platformService", PlatformService);