Set current version to 0.0.2.

Added privateComponents to module content.
We can use this to get the private components from a mechanism without having to
use a headless blockly workspace to process the blocks.
Added code to upgrade projects to version 0.0.2, which involves updating the
mrc_mechanism_component_holder block in the robot and adding privateComponents
in module content.

Author: lizlooney

src/storage/module_content.ts

@@ -60,16 +60,18 @@ export type Event = {
 };
 
 function startingBlocksToModuleContentText(
-    module: storageModule.Module, startingBlocks: { [key: string]: any }): string {
+    module: storageModule.Module, startingBlocks: {[key: string]: any}): string {
   const mechanisms: MechanismInRobot[] = [];
   const components: Component[] = [];
+  const privateComponents: Component[] = [];
   const events: Event[] = [];
   const methods: Method[] = [];
   return makeModuleContentText(
       module,
       startingBlocks,
       mechanisms,
       components,
+      privateComponents,
       events,
       methods);
 }
@@ -125,9 +127,10 @@ export function newOpModeContent(projectName: string, opModeClassName: string):
  */
 export function makeModuleContentText(
     module: storageModule.Module,
-    blocks: { [key: string]: any },
+    blocks: {[key: string]: any},
     mechanisms: MechanismInRobot[],
     components: Component[],
+    privateComponents: Component[],
     events: Event[],
     methods: Method[]): string {
   if (!module.moduleId) {
@@ -139,6 +142,7 @@ export function makeModuleContentText(
       blocks,
       mechanisms,
       components,
+      privateComponents,
       events,
       methods);
   return moduleContent.getModuleContentText();
@@ -151,6 +155,7 @@ export function parseModuleContentText(moduleContentText: string): ModuleContent
       !('blocks' in parsedContent) ||
       !('mechanisms' in parsedContent) ||
       !('components' in parsedContent) ||
+      !('privateComponents' in parsedContent) ||
       !('events' in parsedContent) ||
       !('methods' in parsedContent)) {
     throw new Error('Module content text is not valid.');
@@ -161,6 +166,7 @@ export function parseModuleContentText(moduleContentText: string): ModuleContent
       parsedContent.blocks,
       parsedContent.mechanisms,
       parsedContent.components,
+      parsedContent.privateComponents,
       parsedContent.events,
       parsedContent.methods);
 }
@@ -169,9 +175,10 @@ export class ModuleContent {
   constructor(
       private moduleType: storageModule.ModuleType,
       private moduleId: string,
-      private blocks : { [key: string]: any },
+      private blocks : {[key: string]: any},
       private mechanisms: MechanismInRobot[],
       private components: Component[],
+      private privateComponents: Component[],
       private events: Event[],
       private methods: Method[]) {
   }
@@ -188,10 +195,14 @@ export class ModuleContent {
     return this.moduleId;
   }
 
-  getBlocks(): { [key: string]: any } {
+  getBlocks(): {[key: string]: any} {
     return this.blocks;
   }
 
+  setBlocks(blocks: {[key: string]: any}): void {
+    this.blocks = blocks;
+  }
+
   getMechanisms(): MechanismInRobot[] {
     return this.mechanisms;
   }
@@ -200,6 +211,10 @@ export class ModuleContent {
     return this.components;
   }
 
+  getPrivateComponents(): Component[] {
+    return this.privateComponents;
+  }
+
   getEvents(): Event[] {
     return this.events;
   }
@@ -252,3 +267,15 @@ export class ModuleContent {
     }
   }
 }
+
+/**
+ * Add privateComponents field.
+ * This function should only called when upgrading old projects.
+ */
+export function addPrivateComponents(moduleContentText: string): string {
+  const parsedContent = JSON.parse(moduleContentText);
+  if (!('privateComponents' in parsedContent)) {
+    parsedContent.privateComponents = [];
+  }
+  return JSON.stringify(parsedContent, null, 2);
+}

src/storage/project.ts

@@ -37,9 +37,9 @@ export type Project = {
 };
 
 const NO_VERSION = '0.0.0';
-export const CURRENT_VERSION = '0.0.1';
+export const CURRENT_VERSION = '0.0.2';
 
-type ProjectInfo = {
+export type ProjectInfo = {
   version: string,
 };
 

src/storage/upgrade_project.ts

@@ -20,8 +20,13 @@
  */
 
 import * as semver from 'semver';
+import * as Blockly from 'blockly/core';
 
+import * as mechanismComponentHolder from '../blocks/mrc_mechanism_component_holder';
 import * as commonStorage from './common_storage';
+import * as storageModule from './module';
+import * as storageModuleContent from './module_content';
+import * as storageNames from './names';
 import * as storageProject from './project';
 
 
@@ -30,12 +35,60 @@ export async function upgradeProjectIfNecessary(
   const projectInfo = await storageProject.fetchProjectInfo(storage, projectName);
   if (semver.lt(projectInfo.version, storageProject.CURRENT_VERSION)) {
     switch (projectInfo.version) {
+      // @ts-ignore
       case '0.0.0':
-        // Project was saved without a project.info.json file.
-        // Nothing needs to be done to upgrade to '0.0.1';
-        projectInfo.version = '0.0.1';
-        break;
+        upgradeFrom_000_to_001(storage, projectName, projectInfo)
+        // Intentional fallthrough
+      case '0.0.1':
+        upgradeFrom_001_to_002(storage, projectName, projectInfo);
     }
     await storageProject.saveProjectInfo(storage, projectName);
   }
 }
+
+async function upgradeFrom_000_to_001(
+    _storage: commonStorage.Storage,
+    _projectName: string,
+    projectInfo: storageProject.ProjectInfo): Promise<void> {
+  // Project was saved without a project.info.json file.
+  // Nothing needs to be done to upgrade to '0.0.1';
+  projectInfo.version = '0.0.1';
+}
+
+async function upgradeFrom_001_to_002(
+    storage: commonStorage.Storage,
+    projectName: string,
+    projectInfo: storageProject.ProjectInfo): Promise<void> {
+  // Modules were saved without private components.
+  // The Robot's mrc_mechanism_component_holder block was saved without hidePrivateComponents.
+  const projectFileNames: string[] = await storage.list(
+    storageNames.makeProjectDirectoryPath(projectName));
+  for (const projectFileName of projectFileNames) {
+    const modulePath = storageNames.makeFilePath(projectName, projectFileName);
+    let moduleContentText = await storage.fetchFileContentText(modulePath);
+
+    // Add private components to the module content.
+    moduleContentText = storageModuleContent.addPrivateComponents(moduleContentText);
+
+    if (storageNames.getModuleType(modulePath) === storageModule.ModuleType.ROBOT) {
+      // If this module is the robot, hide the private components part of the
+      // mrc_mechanism_component_holder block.
+      const moduleContent = storageModuleContent.parseModuleContentText(moduleContentText);
+      let blocks = moduleContent.getBlocks();
+      // Create a temporary workspace to upgrade the blocks.
+      const headlessWorkspace = new Blockly.Workspace();
+      try {
+        Blockly.serialization.workspaces.load(blocks, headlessWorkspace);
+        mechanismComponentHolder.hidePrivateComponents(headlessWorkspace);
+        blocks = Blockly.serialization.workspaces.save(headlessWorkspace);
+      } finally {
+        headlessWorkspace.dispose();
+      }
+      moduleContent.setBlocks(blocks);
+      moduleContentText = moduleContent.getModuleContentText();
+    }
+
+    await storage.saveFile(modulePath, moduleContentText);
+  }
+  projectInfo.version = '0.0.2';
+}