List platforms command

Author: Fatme

lib/commands/platform-command.ts

@@ -1,22 +1,29 @@
 ///<reference path="../.d.ts"/>
+import helpers = require("./../common/helpers");
 
 export class ListPlatformsCommand implements ICommand {
-	constructor(private $platformService: IPlatformService) { }
+	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);
 
 export class AddPlatformCommand implements ICommand {
-    constructor(private $platformService: IPlatformService) { }
+	constructor(private $platformService: IPlatformService) { }
 
-    execute(args: string[]): IFuture<void> {
-        return (() => {
-            this.$platformService.addPlatforms(args).wait();
-        }).future<void>()();
-    }
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.addPlatforms(args).wait();
+		}).future<void>()();
+	}
 }
 $injector.registerCommand("platform|add", AddPlatformCommand);

lib/definitions/platform.d.ts

@@ -1,8 +1,10 @@
 interface IPlatformService {
-    addPlatforms(platforms: string[]): IFuture<any>;
+	addPlatforms(platforms: string[]): IFuture<any>;
+	getInstalledPlatforms(): IFuture<string[]>;
+	getAvailablePlatforms(): IFuture<string[]>;
 }
 
 interface IPlatformCapabilities {
-    targetedOS?: string[];
-    frameworkUrl: string;
+	targetedOS?: string[];
+	frameworkUrl: string;
 }

lib/definitions/project.d.ts

@@ -2,7 +2,7 @@ interface IProjectService {
 	createProject(projectName: string, projectId: string): IFuture<void>;
 	createPlatformSpecificProject(platform: string): IFuture<void>;
 	ensureProject(): void;
-    projectData: IProjectData;
+	projectData: IProjectData;
 }
 
 interface IAndroidProjectService {
@@ -14,8 +14,8 @@ interface IiOSProjectService {
 }
 
 interface IProjectData {
-    projectDir: string;
-    platformsDir: string;
+	projectDir: string;
+	platformsDir: string;
 	projectFilePath: string;
 	projectId?: string;
 	projectName?: string;

lib/services/platform-service.ts

@@ -4,45 +4,65 @@ import path = require("path");
 import helpers = require("./../common/helpers");
 
 export class PlatformService implements IPlatformService {
-    constructor(private $errors: IErrors,
-        private $fs: IFileSystem,
-        private $projectService: IProjectService) { }
-
-    private platformCapabilities: { [key: string]: IPlatformCapabilities } = {
-        ios: {
-            targetedOS: ['darwin'],
-            frameworkUrl: ""
-        },
-        android: {
-            frameworkUrl: ""
-        }
-    };
-
-    public getCapabilities(platform: string): IPlatformCapabilities {
-        return this.platformCapabilities[platform];
-    }
-
-    public addPlatforms(platforms: string[]): IFuture<any> {
-        return (() => {
+	constructor(private $errors: IErrors,
+		private $fs: IFileSystem,
+		private $projectService: IProjectService) { }
+
+	private platformCapabilities: { [key: string]: IPlatformCapabilities } = {
+		ios: {
+			targetedOS: ['darwin'],
+			frameworkUrl: ""
+		},
+		android: {
+			frameworkUrl: ""
+		}
+	};
+
+	public getCapabilities(platform: string): IPlatformCapabilities {
+		return this.platformCapabilities[platform];
+	}
+
+	public addPlatforms(platforms: string[]): IFuture<any> {
+		return (() => {
 			this.$projectService.ensureProject();
 
-            if(!platforms || platforms.length === 0) {
-                this.$errors.fail("No platform specified. Please specify a platform to add");
-            }
+			if(!platforms || platforms.length === 0) {
+				this.$errors.fail("No platform specified. Please specify a platform to add");
+			}
 
-            var platformsDir = this.$projectService.projectData.platformsDir;
-            if(!this.$fs.exists(platformsDir).wait()) {
-                this.$fs.createDirectory(platformsDir).wait();
-            }
+			var platformsDir = this.$projectService.projectData.platformsDir;
+			if(!this.$fs.exists(platformsDir).wait()) {
+				this.$fs.createDirectory(platformsDir).wait();
+			}
 
-            _.each(platforms, platform => {
-                this.addPlatform(platform.toLowerCase()).wait();
-            });
+			_.each(platforms, platform => {
+				this.addPlatform(platform.toLowerCase()).wait();
+			});
 
-        }).future<any>()();
-    }
+		}).future<any>()();
+	}
 
-    private addPlatform(platform: string): IFuture<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 Object.keys(this.platformCapabilities).indexOf(p) > -1; });
+		}).future<string[]>()();
+	}
+
+	public getAvailablePlatforms(): IFuture<string[]> {
+		return (() => {
+			var installedPlatforms = this.getInstalledPlatforms().wait();
+			return _.filter(_.keys(this.platformCapabilities), p => {
+				return installedPlatforms.indexOf(p) < 0 && this.isPlatformSupportedForOS(p); // Only those not already installed
+			});
+		}).future<string[]>()();
+	}
+
+	private addPlatform(platform: string): IFuture<void> {
 		return(() => {
 			platform = platform.split("@")[0];
 			var platformPath = path.join(this.$projectService.projectData.platformsDir, platform);
@@ -65,21 +85,21 @@ export class PlatformService implements IPlatformService {
 			this.$projectService.createPlatformSpecificProject(platform).wait();
 
 		}).future<void>()();
-    }
+	}
 
 	private isValidPlatform(platform: string) {
 		return this.platformCapabilities[platform];
 	}
 
 	private isPlatformSupportedForOS(platform: string): boolean {
-        var platformCapabilities = this.getCapabilities(platform);
-        var targetedOS = platformCapabilities.targetedOS;
+		var platformCapabilities = this.getCapabilities(platform);
+		var targetedOS = platformCapabilities.targetedOS;
 
-        if(!targetedOS || targetedOS.indexOf("*") >= 0 || targetedOS.indexOf(process.platform) >= 0) {
-            return true;
-        }
+		if(!targetedOS || targetedOS.indexOf("*") >= 0 || targetedOS.indexOf(process.platform) >= 0) {
+			return true;
+		}
 
-        return false;
-    }
+		return false;
+	}
 }
 $injector.register("platformService", PlatformService);