Merge pull request #1324 from Icenium/kerezov/sb-0.0.12

Upgrade Screen Builder to latest version

Author: Mitko-Kerezov

config/dependency-config.json

@@ -1,10 +1,9 @@
 {
 	"appScaffolding": {
-		"version": "0.0.10"
+		"version": "0.0.12"
 	},
 	"generators": [{
 		"name": "generator-kendo-ui-mobile",
-		"version": "0.0.10",
-		"alias": "H"
+		"version": "0.0.12"
 	}]
 }

lib/bootstrap.ts

@@ -17,7 +17,6 @@ $injector.require("platformMigrator", "./services/platform-migration");
 $injector.require("templatesService", "./templates-service");
 $injector.require("serverExtensionsService", "./services/server-extensions");
 $injector.require("appScaffoldingExtensionsService", "./services/app-scaffolding-extensions-service");
-$injector.require("generatorExtensionsService", "./services/generator-extensions-service");
 $injector.require("screenBuilderService", "./services/screen-builder-service");
 
 $injector.require("cordovaPluginsService", "./services/cordova-plugins");

lib/commands/project/create-project.ts

@@ -6,13 +6,14 @@ export class CreateProjectCommand extends ProjectCommandBaseLib.ProjectCommandBa
 	constructor($errors: IErrors,
 		private frameworkIdentifier: string,
 		private $nameCommandParameter: ICommandParameter,
+		private $options: IOptions,
 		$project: Project.IProject) {
 		super($errors, $project);
 	}
 
 	public execute(args: string[]): IFuture<void> {
 		this.validateProjectData();
-		return this.$project.createNewProject(args[0], this.frameworkIdentifier);
+		return this.$project.createNewProject(args[0], this.frameworkIdentifier, this.$options.template);
 	}
 
 	allowedParameters = [this.$nameCommandParameter];

lib/commands/project/create.ts

@@ -5,7 +5,8 @@ import * as path from "path";
 import ProjectCommandBaseLib = require("./project-command-base");
 
 export class CreateCommand extends ProjectCommandBaseLib.ProjectCommandBase {
-	constructor(private $fs: IFileSystem,
+	constructor(private $config: IConfiguration,
+		private $fs: IFileSystem,
 		private $logger: ILogger,
 		private $nameCommandParameter: ICommandParameter,
 		private $options: IOptions,
@@ -23,9 +24,11 @@ export class CreateCommand extends ProjectCommandBaseLib.ProjectCommandBase {
 			this.validateProjectData();
 
 			let projectName = args[0];
-			let projectPath = path.resolve(this.$options.path ? this.$project.getNewProjectDir() : path.join(this.$project.getNewProjectDir(), projectName));
+			let newProjectDir = this.$project.getNewProjectDir();
+			let projectPath = path.resolve(this.$options.path ? newProjectDir : path.join(newProjectDir, projectName));
 
-			this.$project.createTemplateFolder(projectPath).wait();
+			this.$project.createNewProject(projectName, this.$projectConstants.TARGET_FRAMEWORK_IDENTIFIERS.Cordova, this.$config.DEFAULT_CORDOVA_PROJECT_TEMPLATE).wait();
+			_.each(this.$screenBuilderService.screenBuilderSpecificFiles, fileName => this.$fs.deleteFile(path.join(projectPath, fileName)).wait());
 
 			let screenBuilderOptions = this.$screenBuilderService.composeScreenBuilderOptions(this.$options.answers, {
 				projectPath: projectPath,
@@ -35,10 +38,8 @@ export class CreateCommand extends ProjectCommandBaseLib.ProjectCommandBase {
 			}).wait();
 
 			try {
-				this.$screenBuilderService.prepareAndGeneratePrompt(this.$screenBuilderService.generatorName, this.$options.path, screenBuilderOptions).wait();
-				this.$screenBuilderService.installAppDependencies(screenBuilderOptions, this.$options.path).wait();
 
-				this.$project.initializeProjectFromExistingFiles(this.$projectConstants.TARGET_FRAMEWORK_IDENTIFIERS.Cordova, projectPath, projectName).wait();
+				this.$screenBuilderService.prepareAndGeneratePrompt(projectPath, this.$screenBuilderService.generatorFullName, screenBuilderOptions).wait();
 			} catch(err) {
 				this.$logger.trace(err);
 				this.$fs.deleteDirectory(projectPath).wait();

lib/common

@@ -368,36 +368,49 @@ interface IServerExtensionsService extends IExtensionsServiceBase {
 	prepareExtension(packageName: string, beforeDownloadPackageAction: () => void): IFuture<void>;
 }
 
-interface IDependencyExtensionsServiceBase extends IExtensionsServiceBase {
-	prepareDependencyExtension(dependencyExtensionName: string, dependencyConfig: IDependencyConfig, afterPrepareAction: () => IFuture<void>): IFuture<void>;
-}
-
-interface IGeneratorExtensionsService {
-	prepareGenerator(generatorName: string): IFuture<void>;
-}
-
 interface IAppScaffoldingExtensionsService {
 	appScaffoldingPath: string;
 	prepareAppScaffolding(afterPrepareAction?: () => void): IFuture<void>;
 }
 
 interface IScreenBuilderService {
-	generatorName: string;
+	generatorFullName: string;
 	commandsPrefix: string;
-	prepareAndGeneratePrompt(generatorName: string, projectPath: string, screenBuilderOptions?: IScreenBuilderOptions): IFuture<boolean>;
-	allSupportedCommands(generatorName?: string): IFuture<string[]>;
-	generateAllCommands(generatorName: string): IFuture<void>;
-	installAppDependencies(screenBuilderOptions: IScreenBuilderOptions, projectPath: string): IFuture<void>;
+	screenBuilderSpecificFiles: string[];
+	prepareAndGeneratePrompt(projectPath: string, generatorName?: string, screenBuilderOptions?: IScreenBuilderOptions): IFuture<boolean>;
+	allSupportedCommands(projectPath: string, generatorName?: string): IFuture<string[]>;
+	generateAllCommands(projectPath: string, generatorName?: string): IFuture<void>;
 	composeScreenBuilderOptions(answers: string, bacisSceenBuilderOptions?: IScreenBuilderOptions): IFuture<IScreenBuilderOptions>;
-	ensureScreenBuilderProject(projectDir: string): IFuture<void>;
+	ensureScreenBuilderProject(projectPath: string): IFuture<void>;
 	shouldUpgrade(projectPath: string): IFuture<boolean>;
 	upgrade(projectPath: string): IFuture<void>;
 }
 
+/**
+ * Defines a DTO for migrating from older versions of Screen Builder to the newest one.
+ */
+interface IScreenBuilderMigrationData {
+	/**
+	 * States whether the app is already at the latest Screen Builder version.
+	 * @type {boolean}
+	 */
+	wasMigrated: boolean;
+	/**
+	 * States whether the user chose to upgrade the app to the latest Screen Builder version.
+	 * @type {boolean}
+	 */
+	didMigrate: boolean;
+}
+
 interface IScreenBuilderOptions {
 	type?: string;
 	answers?: IScreenBuilderAnswer;
 	projectPath?: string;
+	/**
+	 * States whether the ScreenBuilder command is synchronous. If it is then no callback will be passed to the app-scaffolder package.
+	 * @type {boolean}
+	 */
+	isSync?: boolean;
 }
 
 interface IScreenBuilderAnswer {

lib/declarations.d.ts

@@ -227,14 +227,14 @@ export class Project implements Project.IProject {
 		}).future<void>()();
 	}
 
-	public createNewProject(projectName: string, framework: string): IFuture<void> {
+	public createNewProject(projectName: string, framework: string, template?: string): IFuture<void> {
 		if(!projectName) {
 			this.$errors.fail("No project name specified.");
 		}
 
 		let projectDir = this.getNewProjectDir();
 		this.frameworkProject = this.$frameworkProjectResolver.resolve(framework);
-		return this.createFromTemplate(projectName, projectDir);
+		return this.createFromTemplate(projectName, projectDir, template);
 	}
 
 	public initializeProjectFromExistingFiles(framework: string, projectDir?: string, appName?: string): IFuture<void> {
@@ -744,11 +744,11 @@ export class Project implements Project.IProject {
 		}).future<void>()();
 	}
 
-	private createFromTemplate(appname: string, projectDir: string): IFuture<void> {
+	private createFromTemplate(appname: string, projectDir: string, template?: string): IFuture<void> {
 		return (() => {
 			let templatesDir = this.$templatesService.projectTemplatesDir;
-			let selectedTemplate = this.$options.template || this.frameworkProject.defaultProjectTemplate;
-			let template = Project.UI_TEMPLATE_NAMES[selectedTemplate.toLowerCase()] || selectedTemplate;
+			let selectedTemplate = template || this.frameworkProject.defaultProjectTemplate;
+			template = Project.UI_TEMPLATE_NAMES[selectedTemplate.toLowerCase()] || selectedTemplate;
 			let templateFileName = path.join(templatesDir, this.frameworkProject.getTemplateFilename(template));
 
 			this.$logger.trace("Using template '%s'", templateFileName);

lib/project.ts

@@ -8,7 +8,7 @@ declare module Project {
 		projectConfigFiles: Project.IConfigurationFile[];
 		startPackageActivity: string;
 
-		createNewProject(projectName: string, framework: string): IFuture<void>;
+		createNewProject(projectName: string, framework: string, template?: string): IFuture<void>;
 		initializeProjectFromExistingFiles(framework: string, projectDir?: string, appName?: string): IFuture<void>;
 		createProjectFile(projectDir: string, properties: any): IFuture<void>;
 		createTemplateFolder(projectDir: string): IFuture<void>;

lib/project/project.d.ts

@@ -42,11 +42,11 @@ class CommandsServiceProvider implements ICommandsServiceProvider {
 	}
 
 	public getDynamicCommands(): IFuture<string[]> {
-		return this.$screenBuilderService.allSupportedCommands(this.$screenBuilderService.generatorName);
+		return this.$screenBuilderService.allSupportedCommands(this.$injector.resolve("project").getProjectDir().wait(), this.$screenBuilderService.generatorFullName);
 	}
 
 	public generateDynamicCommands(): IFuture<void> {
-		return this.$screenBuilderService.generateAllCommands(this.$screenBuilderService.generatorName);
+		return this.$screenBuilderService.generateAllCommands(this.$injector.resolve("project").getProjectDir().wait(), this.$screenBuilderService.generatorFullName);
 	}
 
 	public registerDynamicSubCommands(): void {

lib/providers/commands-service-provider.ts

@@ -1,22 +1,24 @@
 ///<reference path="../.d.ts"/>
 "use strict";
 
-import * as dependencyExtensionsServiceLib from "./dependency-extensions-service-base";
+import {ExtensionsServiceBase} from "./extensions-service-base";
 import * as path from "path";
 import Future = require("fibers/future");
 
-export class AppScaffoldingExtensionsService extends dependencyExtensionsServiceLib.DependencyExtensionsServiceBase implements IAppScaffoldingExtensionsService {
+export class AppScaffoldingExtensionsService extends ExtensionsServiceBase implements IAppScaffoldingExtensionsService {
 	private static APP_SCAFFOLDING_NAME = "app-scaffolding";
+	private static SCREEN_BUILDER_BUCKET_NAME = "http://s3.amazonaws.com/screenbuilder-cli";
+	private static DEFAULT_CACHED_VERSION = "0.0.0";
 
-	constructor($fs: IFileSystem,
-		$httpClient: Server.IHttpClient,
-		$logger: ILogger,
-		$progressIndicator: IProgressIndicator,
-		$config: IConfiguration,
-		protected $childProcess: IChildProcess,
-		protected $dependencyConfigService: IDependencyConfigService,
-		$options: IOptions) {
-		super($options.screenBuilderCacheDir, $fs, $httpClient, $logger, $options, $progressIndicator, $config); // We should pass here the correct profileDir
+	constructor(private $childProcess: IChildProcess,
+		private $config: IConfiguration,
+		private $dependencyConfigService: IDependencyConfigService,
+		private $progressIndicator: IProgressIndicator,
+		protected $fs: IFileSystem,
+		protected $httpClient: Server.IHttpClient,
+		protected $logger: ILogger,
+		protected $options: IOptions) {
+		super($options.screenBuilderCacheDir, $fs, $httpClient, $logger, $options);
 	}
 
 	public get appScaffoldingPath(): string {
@@ -29,7 +31,11 @@ export class AppScaffoldingExtensionsService extends dependencyExtensionsService
 			appScaffoldingConfig.pathToSave = this.$options.screenBuilderCacheDir;
 			let afterPrepareAction = () => {
 				return (() => {
-					this.npmInstall("[email protected]").wait(); // HACK: With this we are able to make paths shorter with 20 symbols.
+					// HACK: Some of screen builder's dependencies generate paths which are too long for Windows OS to handle
+					// this is why we pre-install them so that they're at the highest point in the dependency depth.
+					// This leads to shortening the paths just enough to be safe about it.
+					// Note that if one of these modules' versions is changed this needs to be reflected in the code too!
+					["[email protected]", "[email protected]"].forEach(dependency => { this.npmInstall(dependency).wait(); });
 
 					let generatorBaseDependencies = require(path.join(this.appScaffoldingPath, "node_modules", "screen-builder-base-generator", "package.json")).dependencies;
 					Future.wait(_.map(generatorBaseDependencies, (value, key) => this.npmInstall(`${key}@${value}`)));
@@ -41,6 +47,30 @@ export class AppScaffoldingExtensionsService extends dependencyExtensionsService
 		}).future<void>()();
 	}
 
+	public prepareDependencyExtension(dependencyExtensionName: string, dependencyConfig: IDependencyConfig, afterPrepareAction?: () => IFuture<void>): IFuture<void> {
+		return (() => {
+			let extensionVersion = this.getExtensionVersion(dependencyExtensionName);
+			let cachedVersion = extensionVersion || AppScaffoldingExtensionsService.DEFAULT_CACHED_VERSION;
+			let downloadUrl = this.$config.ON_PREM ? `${this.$config.AB_SERVER}/downloads/sb/generators/${dependencyExtensionName}/${dependencyConfig.version}` : `${AppScaffoldingExtensionsService.SCREEN_BUILDER_BUCKET_NAME}/v${dependencyConfig.version}/${dependencyExtensionName}.zip`;
+
+			this.$logger.trace("prepareDependencyExtension: Download url: %s, cached version: %s", downloadUrl, cachedVersion);
+
+			if (this.shouldUpdatePackage(cachedVersion, dependencyConfig.version)) {
+				this.$logger.out("Please, wait while Screen Builder and its dependencies are being configured.");
+				this.$logger.out("Preparing %s", dependencyExtensionName);
+
+				let dependencyExtensionData = {
+					packageName: dependencyExtensionName,
+					version: dependencyConfig.version,
+					downloadUri: downloadUrl,
+					pathToSave: dependencyConfig.pathToSave
+				};
+
+				this.$progressIndicator.showProgressIndicator(this.prepareExtensionBase(dependencyExtensionData, cachedVersion, {afterDownloadAction: () => this.$progressIndicator.showProgressIndicator(afterPrepareAction(), 100)}), 5000).wait();
+			}
+		}).future<void>()();
+	}
+
 	protected npmInstall(packageToInstall?: string): IFuture<void> {
 		packageToInstall = packageToInstall || "";
 		let command = `npm install ${packageToInstall} --production`;