Change type of moduleType variables from string to storageModule.ModuleType.

Add _moduleType parameter to storageNames.makeModulePath. It is currently unused.

Author: lizlooney

src/blocks/mrc_component.ts

@@ -217,7 +217,8 @@ export const pythonFromBlock = function (
   return code;
 }
 
-export function getAllPossibleComponents(moduleType: string): toolboxItems.ContentsType[] {
+export function getAllPossibleComponents(
+    moduleType: storageModule.ModuleType): toolboxItems.ContentsType[] {
   const contents: toolboxItems.ContentsType[] = [];
   // Iterate through all the components subclasses and add definition blocks.
   const componentTypes = getSubclassNames('component.Component');
@@ -244,7 +245,10 @@ export function getAllPossibleComponents(moduleType: string): toolboxItems.Conte
 }
 
 function createComponentBlock(
-    componentName: string, classData: ClassData, staticFunctionData: FunctionData, moduleType: string): toolboxItems.Block {
+    componentName: string,
+    classData: ClassData,
+    staticFunctionData: FunctionData,
+    moduleType: storageModule.ModuleType): toolboxItems.Block {
   const extraState: ComponentExtraState = {
     importModule: classData.moduleName,
     staticFunctionName: staticFunctionData.functionName,

src/editor/editor.ts

@@ -227,11 +227,11 @@ export class Editor {
     return this.blocklyWorkspace;
   }
 
-  public getCurrentModuleType(): string {
+  public getCurrentModuleType(): storageModule.ModuleType | null {
     if (this.currentModule) {
       return this.currentModule.moduleType;
     }
-    return '';
+    return null;
   }
 
   private getModuleContentText(): string {

src/editor/extended_python_generator.ts

@@ -147,7 +147,7 @@ export class ExtendedPythonGenerator extends PythonGenerator {
     return code;
   }
 
-  getModuleType(): string | null {
+  getModuleType(): storageModule.ModuleType | null {
     if (this.context) {
       return this.context.getModuleType();
     }

src/editor/generator_context.ts

@@ -34,7 +34,7 @@ export class GeneratorContext {
     this.module = module;
   }
 
-  getModuleType(): string | null {
+  getModuleType(): storageModule.ModuleType | null {
     if (this.module) {
       return this.module.moduleType;
     }

src/storage/module.ts

@@ -29,7 +29,7 @@ export enum ModuleType {
 
 export type Module = {
   modulePath: string,
-  moduleType: string,
+  moduleType: ModuleType,
   moduleId: string,
   projectName: string, // For example, WackyWheelerRobot
   className: string,   // For example, GamePieceShooter.

src/storage/module_content.ts

@@ -95,7 +95,7 @@ export function newRobotContent(projectName: string): string {
  */
 export function newMechanismContent(projectName: string, mechanismClassName: string): string {
   const module: storageModule.Mechanism = {
-    modulePath: storageNames.makeModulePath(projectName, mechanismClassName),
+    modulePath: storageNames.makeModulePath(projectName, mechanismClassName, storageModule.ModuleType.MECHANISM),
     moduleType: storageModule.ModuleType.MECHANISM,
     moduleId: Blockly.utils.idGenerator.genUid(),
     projectName: projectName,
@@ -111,7 +111,7 @@ export function newMechanismContent(projectName: string, mechanismClassName: str
  */
 export function newOpModeContent(projectName: string, opModeClassName: string): string {
   const module: storageModule.OpMode = {
-    modulePath: storageNames.makeModulePath(projectName, opModeClassName),
+    modulePath: storageNames.makeModulePath(projectName, opModeClassName, storageModule.ModuleType.OPMODE),
     moduleType: storageModule.ModuleType.OPMODE,
     moduleId: Blockly.utils.idGenerator.genUid(),
     projectName: projectName,
@@ -194,7 +194,7 @@ function fixOldParsedContent(parsedContent: any): void {
 
 export class ModuleContent {
   constructor(
-      private moduleType: string,
+      private moduleType: storageModule.ModuleType,
       private moduleId: string,
       private blocks : { [key: string]: any },
       private mechanisms: MechanismInRobot[],
@@ -207,7 +207,7 @@ export class ModuleContent {
     return JSON.stringify(this, null, 2);
   }
 
-  getModuleType(): string {
+  getModuleType(): storageModule.ModuleType {
     return this.moduleType;
   }
 

src/storage/names.ts

@@ -19,6 +19,9 @@
  * @author [email protected] (Liz Looney)
  */
 
+import * as storageModule from './module';
+
+
 export const CLASS_NAME_ROBOT = 'Robot';
 export const CLASS_NAME_TELEOP = 'Teleop';
 
@@ -90,15 +93,16 @@ function escapeRegExp(text: string): string {
 /**
  * Returns the module path for the given project name and class name.
  */
-export function makeModulePath(projectName: string, className: string): string {
+export function makeModulePath(
+    projectName: string, className: string, _moduleType: storageModule.ModuleType): string {
   return projectName + '/' + className + JSON_FILE_EXTENSION;
 }
 
 /**
  * Returns the robot module path for the given project names.
  */
 export function makeRobotPath(projectName: string): string {
-  return makeModulePath(projectName, CLASS_NAME_ROBOT);
+  return makeModulePath(projectName, CLASS_NAME_ROBOT, storageModule.ModuleType.ROBOT);
 }
 
 /**

src/storage/project.ts

@@ -132,8 +132,10 @@ export async function createProject(
   const robotContent = storageModuleContent.newRobotContent(newProjectName);
   await storage.saveModule(modulePath, robotContent);
 
-  const opmodePath = storageNames.makeModulePath(newProjectName, storageNames.CLASS_NAME_TELEOP);
-  const opmodeContent = storageModuleContent.newOpModeContent(newProjectName, storageNames.CLASS_NAME_TELEOP);
+  const opmodePath = storageNames.makeModulePath(
+      newProjectName, storageNames.CLASS_NAME_TELEOP, storageModule.ModuleType.OPMODE);
+  const opmodeContent = storageModuleContent.newOpModeContent(
+      newProjectName, storageNames.CLASS_NAME_TELEOP);
   await storage.saveModule(opmodePath, opmodeContent);
 }
 
@@ -169,7 +171,8 @@ async function renameOrCopyProject(
 
   for (const modulePath in pathToModuleContent) {
     const className = storageNames.getClassName(modulePath);
-    const newModulePath = storageNames.makeModulePath(newProjectName, className);
+    const moduleType = pathToModuleContent[modulePath].getModuleType()
+    const newModulePath = storageNames.makeModulePath(newProjectName, className, moduleType);
     const moduleContentText = pathToModuleContent[modulePath].getModuleContentText();
     await storage.saveModule(newModulePath, moduleContentText);
     if (rename) {
@@ -202,8 +205,11 @@ export async function deleteProject(
  * @param newClassName The name of the class. For example, GamePieceShooter.
  */
 export async function addModuleToProject(
-  storage: commonStorage.Storage, project: Project, moduleType: string, newClassName: string): Promise<void> {
-  const newModulePath = storageNames.makeModulePath(project.projectName, newClassName);
+    storage: commonStorage.Storage,
+    project: Project,
+    moduleType: storageModule.ModuleType,
+    newClassName: string): Promise<void> {
+  const newModulePath = storageNames.makeModulePath(project.projectName, newClassName, moduleType);
 
   switch (moduleType) {
     case storageModule.ModuleType.MECHANISM:
@@ -295,7 +301,7 @@ export async function copyModuleInProject(
 async function renameOrCopyModule(
     storage: commonStorage.Storage, project: Project, newClassName: string,
     oldModule: storageModule.Module, rename: boolean): Promise<string> {
-  const newModulePath = storageNames.makeModulePath(project.projectName, newClassName);
+  const newModulePath = storageNames.makeModulePath(project.projectName, newClassName, oldModule.moduleType);
   let moduleContentText = await storage.fetchModuleContentText(oldModule.modulePath);
   if (!rename) {
     // Change the ids in the module.
@@ -448,20 +454,26 @@ export function makeUploadProjectName(
 export async function uploadProject(
     storage: commonStorage.Storage, projectName: string, blobUrl: string): Promise<void> {
   // Process the uploaded blob to get the module types and contents.
-  const classNameToModuleContentText = await processUploadedBlob(blobUrl);
+  const classNameToModuleContentText: { [className: string]: string } = {}; // value is module content text.
+  const classNameToModuleType: { [className: string]: storageModule.ModuleType } = {};
+  await processUploadedBlob(blobUrl, classNameToModuleContentText, classNameToModuleType);
 
   // Save each module.
   for (const className in classNameToModuleContentText) {
     const moduleContentText = classNameToModuleContentText[className];
-    const modulePath = storageNames.makeModulePath(projectName, className);
+    const moduleType = classNameToModuleType[className];
+    const modulePath = storageNames.makeModulePath(projectName, className, moduleType);
     await storage.saveModule(modulePath, moduleContentText);
   }
 }
 
 /**
  * Process the uploaded blob to get the module class names and contents.
  */
-async function processUploadedBlob(blobUrl: string): Promise<{ [className: string]: string }> {
+async function processUploadedBlob(
+    blobUrl: string,
+    classNameToModuleContentText: { [className: string]: string }, // value is module content text.
+    classNameToModuleType: { [className: string]: storageModule.ModuleType }): Promise<void> {
 
   const prefix = 'data:application/octet-stream;base64,';
   if (!blobUrl.startsWith(prefix)) {
@@ -488,7 +500,6 @@ async function processUploadedBlob(blobUrl: string): Promise<{ [className: strin
 
   // Process each module's content.
   let foundRobot = false;
-  const classNameToModuleContentText: { [className: string]: string } = {}; // value is module content text
   for (const filename in files) {
     const className = filename;
     if (className === storageNames.CLASS_NAME_ROBOT) {
@@ -497,11 +508,10 @@ async function processUploadedBlob(blobUrl: string): Promise<{ [className: strin
     // Make sure we can parse the content.
     const moduleContent = storageModuleContent.parseModuleContentText(files[filename]);
     classNameToModuleContentText[className] = moduleContent.getModuleContentText();
+    classNameToModuleType[className] = moduleContent.getModuleType();
   }
 
   if (!foundRobot) {
     throw new Error('Uploaded file did not contain a Robot.');
   }
-
-  return classNameToModuleContentText;
 }

src/toolbox/hardware_category.ts

@@ -42,11 +42,11 @@ export function getHardwareCategory(
         name: Blockly.Msg['MRC_CATEGORY_HARDWARE'],
         contents: [
           getRobotMechanismsCategory(editor),
-          getComponentsCategory(editor),
+          getComponentsCategory(editor, moduleType),
         ],
       };
     case storageModule.ModuleType.MECHANISM:
-      return getComponentsCategory(editor);
+      return getComponentsCategory(editor, moduleType);
     case storageModule.ModuleType.OPMODE:
       return {
         kind: 'category',
@@ -168,7 +168,9 @@ function getRobotMethodsCategory(editor: Editor): toolboxItems.Category {
   };
 }
 
-function getComponentsCategory(editor: Editor): toolboxItems.Category {
+function getComponentsCategory(
+    editor: Editor,
+    moduleType: storageModule.ModuleType): toolboxItems.Category {
   // getComponentsCategory is called when the user is editing the robot or a
   // mechanism. It allows the user to add a component or use an existing component.
 
@@ -178,7 +180,7 @@ function getComponentsCategory(editor: Editor): toolboxItems.Category {
   contents.push({
     kind: 'category',
     name: Blockly.Msg['MRC_CATEGORY_ADD_COMPONENT'],
-    contents: getAllPossibleComponents(editor.getCurrentModuleType()),
+    contents: getAllPossibleComponents(moduleType),
   });
 
   // Get components from the current workspace.