Store modules with double extension: .robot.json, .mechanism.json, .opmode.json.

Add getModuleType(modulePath) to names.ts.

Author: lizlooney

src/storage/client_side_storage.ts

@@ -21,6 +21,7 @@
 
 import * as commonStorage from './common_storage';
 import * as storageModuleContent from './module_content';
+import * as storageNames from './names';
 
 // Functions for saving blocks modules to client side storage.
 
@@ -57,7 +58,62 @@ export async function openClientSideStorage(): Promise<commonStorage.Storage> {
     };
     openRequest.onsuccess = () => {
       const db = openRequest.result;
-      resolve(ClientSideStorage.create(db));
+      fixOldModules(db).then(() => {
+        resolve(ClientSideStorage.create(db));
+      })
+    };
+  });
+}
+
+// The following function allows Alan and Liz to load older projects.
+// TODO(lizlooney): Remove this function.
+async function fixOldModules(db: IDBDatabase): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction([MODULES_STORE_NAME], 'readwrite');
+    transaction.oncomplete = () => {
+      resolve();
+    };
+    transaction.onabort = () => {
+      console.log('IndexedDB transaction aborted.');
+      reject(new Error('IndexedDB transaction aborted.'));
+    };
+    const modulesObjectStore = transaction.objectStore(MODULES_STORE_NAME);
+    const openCursorRequest = modulesObjectStore.openCursor();
+    openCursorRequest.onerror = () => {
+      console.log('IndexedDB openCursor request failed. openCursorRequest.error is...');
+      console.log(openCursorRequest.error);
+      reject(new Error('IndexedDB openCursor request failed.'));
+    };
+    openCursorRequest.onsuccess = () => {
+      const cursor = openCursorRequest.result;
+      if (cursor) {
+        const value = cursor.value;
+        const regexForOldModulePath = new RegExp('^([A-Z][A-Za-z0-9]*)/([A-Z][A-Za-z0-9]*).json$');
+        const result = regexForOldModulePath.exec(value.path);
+        if (result) {
+          const oldModulePath = value.path;
+          const projectName = result[1];
+          const className = result[2];
+          const moduleType = storageModuleContent.parseModuleContentText(value.content).getModuleType();
+          value.path = storageNames.makeModulePath(projectName, className, moduleType);
+          const putRequest = modulesObjectStore.put(value);
+          putRequest.onerror = () => {
+           console.log('IndexedDB put request failed. putRequest.error is...');
+            console.log(putRequest.error);
+            throw new Error('IndexedDB put request failed.');
+          };
+          const deleteRequest = modulesObjectStore.delete(oldModulePath);
+          deleteRequest.onerror = () => {
+            console.log('IndexedDB delete request failed. deleteRequest.error is...');
+            console.log(deleteRequest.error);
+            throw new Error('IndexedDB delete request failed.');
+          };
+        }
+        cursor.continue();
+      } else {
+        // The cursor is done. We have finished reading all the modules.
+        resolve();
+      }
     };
   });
 }
@@ -257,8 +313,6 @@ class ClientSideStorage implements commonStorage.Storage {
         console.log(deleteRequest.error);
         throw new Error('IndexedDB delete request failed.');
       };
-      deleteRequest.onsuccess = () => {
-      };
     });
   }
 }

src/storage/names.ts

@@ -28,17 +28,18 @@ export const CLASS_NAME_TELEOP = 'Teleop';
 export const JSON_FILE_EXTENSION = '.json';
 export const UPLOAD_DOWNLOAD_FILE_EXTENSION = '.blocks';
 
-const REGEX_PROJECT_OR_CLASS_NAME_PART = '[A-Z][A-Za-z0-9]*';
-const REGEX_CLASS_NAME = '^' + REGEX_PROJECT_OR_CLASS_NAME_PART + '$';
-const REGEX_MODULE_PATH = '^(' + REGEX_PROJECT_OR_CLASS_NAME_PART + ')/(' +
-    REGEX_PROJECT_OR_CLASS_NAME_PART + ')' + escapeRegExp(JSON_FILE_EXTENSION) + '$';
+const REGEX_PROJECT_NAME_PART = '[A-Z][A-Za-z0-9]*';
+const REGEX_CLASS_NAME_PART = '[A-Z][A-Za-z0-9]*';
+const REGEX_MODULE_TYPE = '\.(robot|mechanism|opmode)';
+const REGEX_MODULE_PATH = '^(' + REGEX_PROJECT_NAME_PART + ')/(' + REGEX_CLASS_NAME_PART + ')' +
+    REGEX_MODULE_TYPE + escapeRegExp(JSON_FILE_EXTENSION) + '$';
 
 /**
  * Returns true if the given name is a valid class name.
  */
 export function isValidClassName(name: string): boolean {
   if (name) {
-    return new RegExp(REGEX_CLASS_NAME).test(name);
+    return new RegExp('^' + REGEX_CLASS_NAME_PART + '$').test(name);
   }
   return false;
 }
@@ -82,8 +83,8 @@ export function snakeCaseToPascalCase(snakeCaseName: string): string {
  * Returns the module path regex pattern for modules in the given project.
  */
 export function makeModulePathRegexPattern(projectName: string): string {
-  return '^' + escapeRegExp(projectName) + '/' + REGEX_PROJECT_OR_CLASS_NAME_PART +
-      escapeRegExp(JSON_FILE_EXTENSION) + '$';
+  return '^' + escapeRegExp(projectName) + '/' + REGEX_CLASS_NAME_PART +
+      REGEX_MODULE_TYPE + escapeRegExp(JSON_FILE_EXTENSION) + '$';
 }
 
 function escapeRegExp(text: string): string {
@@ -94,8 +95,8 @@ function escapeRegExp(text: string): string {
  * Returns the module path for the given project name and class name.
  */
 export function makeModulePath(
-    projectName: string, className: string, _moduleType: storageModule.ModuleType): string {
-  return projectName + '/' + className + JSON_FILE_EXTENSION;
+    projectName: string, className: string, moduleType: storageModule.ModuleType): string {
+  return projectName + '/' + className + '.' + moduleType + JSON_FILE_EXTENSION;
 }
 
 /**
@@ -129,6 +130,25 @@ export function getClassName(modulePath: string): string {
   return result[2];
 }
 
+/**
+ * Returns the module type for given module path.
+ */
+export function getModuleType(modulePath: string): storageModule.ModuleType {
+  const regex = new RegExp(REGEX_MODULE_PATH);
+  const result = regex.exec(modulePath)
+  if (!result) {
+    throw new Error('Unable to extract the module type from "' + modulePath + '"');
+  }
+
+  const str = result[2];
+  const moduleType = storageModule.ModuleType[str as keyof typeof storageModule.ModuleType];
+  if (!Object.values(storageModule.ModuleType).includes(moduleType)) {
+    throw new Error('Unable to extract the module type from "' + modulePath + '"');
+  }
+
+  return moduleType;
+}
+
 /**
  * Makes a unique name given a list of existing names
  */

src/storage/project.ts

@@ -38,15 +38,15 @@ export type Project = {
 export async function listProjects(storage: commonStorage.Storage): Promise<Project[]> {
   const pathToModuleContent = await storage.listModules();
 
-  const projects: {[key: string]: Project} = {}; // key is project name, value is Project
+  const projects: {[projectName: string]: Project} = {};
   // The mechanisms and opModes variables hold any Mechanisms and OpModes that
-  // are read before the Project to which they belong is read.
-  const mechanisms: {[key: string]: storageModule.Mechanism[]} = {}; // key is project name, value is list of Mechanisms
-  const opModes: {[key: string]: storageModule.OpMode[]} = {}; // key is project name, value is list of OpModes
+  // are read before the Robot of the Project to which they belong is read.
+  const mechanisms: {[projectName: string]: storageModule.Mechanism[]} = {};
+  const opModes: {[projectName: string]: storageModule.OpMode[]} = {};
 
   for (const modulePath in pathToModuleContent) {
     const moduleContent = pathToModuleContent[modulePath];
-    const moduleType = moduleContent.getModuleType();
+    const moduleType = storageNames.getModuleType(modulePath);
     const dateModifiedMillis = await storage.fetchModuleDateModifiedMillis(modulePath);
     const module: storageModule.Module = {
       modulePath: modulePath,