Merge pull request #34 from wpilibsuite/methods

Adding methods

Author: alan412

src/App.tsx

@@ -237,6 +237,7 @@ const App: React.FC = () => {
   const [treeExpandedKeys, setTreeExpandedKeys] = useState<React.Key[]>([]);
   const [treeSelectedKey, setTreeSelectedKey] = useState<React.Key>('');
   const [currentModulePath, setCurrentModulePath] = useState('');
+  const [currentModule, setCurrentModule] = useState<commonStorage.Module | null>(null);
   const [renameTooltip, setRenameTooltip] = useState('Rename');
   const [copyTooltip, setCopyTooltip] = useState('Copy');
   const [deleteTooltip, setDeleteTooltip] = useState('Delete');
@@ -404,38 +405,47 @@ const App: React.FC = () => {
 
   // When a module path has become the current module path (either by fetching
   // the most recent module path (soon after the app is loaded) or by the user
-  // selecting it in the tree, set the current workspace, expend the
-  // workspace node in the tree.
+  // selecting it in the tree, set the current module, update some tooltips, and
+  // load the module into the blockly editor.
   useEffect(() => {
     if (ignoreEffect()) {
       return;
     }
-    if (currentModulePath && modules.length > 0) {
-      const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      const workspacePath = commonStorage.makeModulePath(workspaceName, workspaceName);
 
-      if (currentModulePath === workspacePath) {
+    const module = (modules.length > 0 && currentModulePath)
+        ? commonStorage.findModule(modules, currentModulePath)
+        : null;
+    setCurrentModule(module);
+
+    if (module != null) {
+      if (module.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
         setRenameTooltip('Rename Workspace');
         setCopyTooltip('Copy Workspace');
         setDeleteTooltip('Delete Workspace');
-      } else {
+      } else if (module.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
         setRenameTooltip('Rename OpMode');
         setCopyTooltip('Copy OpMode');
         setDeleteTooltip('Delete OpMode');
+      } else if (module.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
+        setRenameTooltip('Rename Mechanism');
+        setCopyTooltip('Copy Mechanism');
+        setDeleteTooltip('Delete Mechanism');
       }
 
       storage.saveEntry('mostRecentModulePath', currentModulePath);
       if (blocksEditor.current) {
-        blocksEditor.current.loadModuleBlocks(currentModulePath, workspacePath);
+        blocksEditor.current.loadModuleBlocks(module);
       }
     } else {
+      setCurrentModule(null);
+
       setRenameTooltip('Rename');
       setCopyTooltip('Copy');
       setDeleteTooltip('Delete');
 
       storage.saveEntry('mostRecentModulePath', '');
       if (blocksEditor.current) {
-        blocksEditor.current.loadModuleBlocks('', '');
+        blocksEditor.current.loadModuleBlocks(null);
       }
     }
   }, [currentModulePath]);
@@ -540,9 +550,9 @@ const App: React.FC = () => {
   };
 
   const handleNewWorkspaceNameOk = (newWorkspaceName: string) => {
-    const newWorkspacePath = commonStorage.makeModulePath(newWorkspaceName, newWorkspaceName);
+    const newWorkspacePath = commonStorage.makeWorkspacePath(newWorkspaceName);
     if (newWorkspaceNameModalPurpose === 'NewWorkspace') {
-      const workspaceContent = commonStorage.newModuleContent();
+      const workspaceContent = commonStorage.newWorkspaceContent(newWorkspaceName);
       storage.createModule(
           commonStorage.MODULE_TYPE_WORKSPACE, newWorkspacePath, workspaceContent,
           (success: boolean, errorMessage: string) => {
@@ -595,10 +605,14 @@ const App: React.FC = () => {
     });
   };
 
+  // Provide a callback so the NewOpModeNameModal will know what the current
+  // workspace name is.
   const getCurrentWorkspaceName = (): string => {
-    return commonStorage.getWorkspaceName(currentModulePath);
+    return currentModule ? currentModule.workspaceName : '';
   };
 
+  // Provide a callback so the NewOpModeNameModal will know what the existing
+  // OpMode names are in the current workspace.
   const getOpModeNames = (workspaceName: string): string[] => {
     const opModeNames: string[] = [];
     for (const workspace of modules) {
@@ -615,7 +629,7 @@ const App: React.FC = () => {
   const handleNewOpModeNameOk = (workspaceName: string, newOpModeName: string) => {
     const newOpModePath = commonStorage.makeModulePath(workspaceName, newOpModeName);
     if (newOpModeNameModalPurpose === 'NewOpMode') {
-      const opModeContent = commonStorage.newModuleContent();
+      const opModeContent = commonStorage.newOpModeContent(workspaceName, newOpModeName);
       storage.createModule(
           commonStorage.MODULE_TYPE_OPMODE, newOpModePath, opModeContent,
           (success: boolean, errorMessage: string) => {
@@ -685,61 +699,70 @@ const App: React.FC = () => {
 
   const handleRenameClicked = () => {
     checkIfBlocksWereModified(() => {
-      const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      const moduleName = commonStorage.getModuleName(currentModulePath);
-      if (workspaceName === moduleName) {
+      if (!currentModule) {
+        return;
+      }
+      if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
         // This is a workspace.
         setNewWorkspaceNameModalPurpose('RenameWorkspace');
-        setNewWorkspaceNameModalInitialValue(workspaceName);
+        setNewWorkspaceNameModalInitialValue(currentModule.workspaceName);
         setNewWorkspaceNameModalIsOpen(true);
-      } else {
+      } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
         // This is an OpMode.
         setNewOpModeNameModalPurpose('RenameOpMode');
-        setNewOpModeNameModalInitialValue(moduleName);
+        setNewOpModeNameModalInitialValue(currentModule.moduleName);
         setNewOpModeNameModalIsOpen(true);
       }
     });
   };
 
   const handleCopyClicked = () => {
     checkIfBlocksWereModified(() => {
-      const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      const moduleName = commonStorage.getModuleName(currentModulePath);
-      if (workspaceName === moduleName) {
+      if (!currentModule) {
+        return;
+      }
+      if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
         // This is a workspace.
         setNewWorkspaceNameModalPurpose('CopyWorkspace');
-        setNewWorkspaceNameModalInitialValue(workspaceName + '_copy');
+        setNewWorkspaceNameModalInitialValue(currentModule.workspaceName + '_copy');
         setNewWorkspaceNameModalIsOpen(true);
-      } else {
+      } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
         // This is an OpMode.
         setNewOpModeNameModalPurpose('CopyOpMode');
-        setNewOpModeNameModalInitialValue(moduleName + '_copy');
+        setNewOpModeNameModalInitialValue(currentModule.moduleName + '_copy');
         setNewOpModeNameModalIsOpen(true);
       }
     });
   };
 
   const handleDeleteClicked = () => {
-    const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-    const moduleName = commonStorage.getModuleName(currentModulePath);
-
+    if (!currentModule) {
+      return;
+    }
     // Show a bubble confirmation box to ask the user if they are sure.
     setPopconfirmTitle('Are you sure?');
-    if (workspaceName === moduleName) {
+    if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
       setPopconfirmDescription('Press ok to delete this Workspace');
-    } else {
+    } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
       setPopconfirmDescription('Press ok to delete this OpMode');
+    } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
+      // TODO: delete the mechanism.
+      return;
     }
     // Set the function to be executed if the user clicks 'ok'.
     afterPopconfirmOk.current = () => {
       setOpenPopconfirm(false);
       checkIfBlocksWereModified(() => {
-        if (workspaceName === moduleName) {
+        if (!currentModule) {
+          return;
+        }
+        if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
           // This is a workspace.
           // Before deleting it, select another workspace, if there is one.
+          const workspaceNameToDelete = currentModule.workspaceName;
           let foundAnotherWorkspace = false;
           for (const workspace of modules) {
-            if (workspace.workspaceName !== workspaceName) {
+            if (workspace.workspaceName !== workspaceNameToDelete) {
               setCurrentModulePath(workspace.modulePath);
               foundAnotherWorkspace = true;
               break;
@@ -748,7 +771,7 @@ const App: React.FC = () => {
           if (!foundAnotherWorkspace) {
             setCurrentModulePath('');
           }
-          storage.deleteWorkspace(workspaceName,
+          storage.deleteWorkspace(workspaceNameToDelete,
             (success: boolean, errorMessage: string) => {
               if (success) {
                 setTriggerListModules(!triggerListModules);
@@ -757,11 +780,12 @@ const App: React.FC = () => {
                 setAlertErrorVisible(true);
               }
             });
-        } else {
+        } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
           // This is an OpMode.
-          const workspacePath = commonStorage.makeModulePath(workspaceName, workspaceName);
+          const modulePathToDelete = currentModulePath;
+          const workspacePath = commonStorage.makeWorkspacePath(currentModule.workspaceName);
           setCurrentModulePath(workspacePath);
-          storage.deleteOpMode(currentModulePath,
+          storage.deleteOpMode(modulePathToDelete,
             (success: boolean, errorMessage: string) => {
               if (success) {
                 setTriggerListModules(!triggerListModules);

src/blocks/mrc_call_python_function.ts

@@ -25,7 +25,8 @@ import { Order, PythonGenerator } from 'blockly/python';
 
 import * as pythonUtils from './utils/generated/python';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
-import { getAllowedTypesForSetCheck, getOutputCheck, addImport } from './utils/python';
+import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { MRC_STYLE_FUNCTIONS } from '../themes/styles'
 
 // A block to call a python function.
@@ -258,11 +259,11 @@ export const setup = function() {
 
 export const pythonFromBlock = function(
     block: Blockly.Block,
-    generator: PythonGenerator,
+    generator: ExtendedPythonGenerator,
 ) {
   const callPythonFunctionBlock = block as CallPythonFunctionBlock;
   if (callPythonFunctionBlock.mrcImportModule) {
-    addImport(generator, callPythonFunctionBlock.mrcImportModule);
+    generator.addImport(callPythonFunctionBlock.mrcImportModule);
   }
   let code;
   let argStartIndex = 0;
@@ -311,7 +312,7 @@ export const pythonFromBlock = function(
 
 function generateCodeForArguments(
     block: CallPythonFunctionBlock,
-    generator: PythonGenerator,
+    generator: ExtendedPythonGenerator,
     startIndex: number) {
   let code = '';
   if (block.mrcArgs.length - startIndex === 1) {

src/blocks/mrc_class_method_def.ts

@@ -91,6 +91,7 @@ const CLASS_METHOD_DEF = {
         this.setOutput(false);
         this.setStyle(MRC_STYLE_CLASS_BLOCKS);
         this.appendStatementInput('STACK').appendField('');
+        this.mrcParameters = [];
     },
     /**
        * Returns the state of this block as a JSON serializable object.
@@ -153,8 +154,8 @@ const CLASS_METHOD_DEF = {
         }
         else {
             input.insertFieldAt(0, createFieldNonEditableText(name), 'NAME');
-            //TODO: This should turn it off, but I have an outstanding question on blockly mailing list on how to do that in typescript
-            // this.setMutator( null );
+            //Case because a current bug in blockly where it won't allow passing null to Blockly.Block.setMutator makes it necessary.
+            (this as Blockly.BlockSvg).setMutator( null );
         }
         this.setDeletable(this.mrcCanDelete);
         this.mrcUpdateParams();
@@ -345,7 +346,6 @@ export const setup = function() {
 };
 
 import { Order, PythonGenerator } from 'blockly/python';
-import { Block } from 'src/Blockly';
 
 export const pythonFromBlock = function (
     block: ClassMethodDefBlock,

src/blocks/mrc_get_python_enum_value.ts

@@ -26,7 +26,8 @@ import { Order, PythonGenerator } from 'blockly/python';
 import * as pythonUtils from './utils/generated/python';
 import { createFieldDropdown } from '../fields/FieldDropdown';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
-import { getOutputCheck, addImport } from './utils/python';
+import { getOutputCheck } from './utils/python';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { MRC_STYLE_ENUM } from '../themes/styles'
 
 
@@ -137,13 +138,13 @@ export const setup = function() {
 
 export const pythonFromBlock = function(
     block: Blockly.Block,
-    generator: PythonGenerator,
+    generator: ExtendedPythonGenerator,
 ) {
   const getPythonEnumValueBlock = block as GetPythonEnumValueBlock;
   const enumClassName = block.getFieldValue(pythonUtils.FIELD_ENUM_CLASS_NAME);
   const enumValue = block.getFieldValue(pythonUtils.FIELD_ENUM_VALUE);
   if (getPythonEnumValueBlock.mrcImportModule) {
-    addImport(generator, getPythonEnumValueBlock.mrcImportModule);
+    generator.addImport(getPythonEnumValueBlock.mrcImportModule);
   }
   const code = enumClassName + '.' + enumValue;
   return [code, Order.MEMBER];

src/blocks/mrc_get_python_variable.ts

@@ -26,7 +26,9 @@ import { Order, PythonGenerator } from 'blockly/python';
 import * as pythonUtils from './utils/generated/python';
 import { createFieldDropdown } from '../fields/FieldDropdown';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
-import { getAllowedTypesForSetCheck, getOutputCheck, addImport } from './utils/python';
+import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
+
 import { MRC_STYLE_VARIABLES } from '../themes/styles';
 // A block to get a python variable.
 
@@ -255,7 +257,7 @@ export const setup = function() {
 
 export const pythonFromBlock = function(
     block: Blockly.Block,
-    generator: PythonGenerator,
+    generator: ExtendedPythonGenerator,
 ) {
   const getPythonVariableBlock = block as GetPythonVariableBlock;
   const varName = getPythonVariableBlock.mrcActualVariableName
@@ -265,15 +267,15 @@ export const pythonFromBlock = function(
     case VAR_KIND_MODULE: {
       const moduleName = block.getFieldValue(pythonUtils.FIELD_MODULE_OR_CLASS_NAME);
       if (getPythonVariableBlock.mrcImportModule) {
-        addImport(generator, getPythonVariableBlock.mrcImportModule);
+        generator.addImport(getPythonVariableBlock.mrcImportModule);
       }
       const code = moduleName + '.' + varName;
       return [code, Order.MEMBER];
     }
     case VAR_KIND_CLASS: {
       const className = block.getFieldValue(pythonUtils.FIELD_MODULE_OR_CLASS_NAME);
       if (getPythonVariableBlock.mrcImportModule) {
-        addImport(generator, getPythonVariableBlock.mrcImportModule);
+        generator.addImport(getPythonVariableBlock.mrcImportModule);        
       }
       const code = className + '.' + varName;
       return [code, Order.MEMBER];

src/blocks/mrc_set_python_variable.ts

@@ -26,7 +26,8 @@ import { Order, PythonGenerator } from 'blockly/python';
 import * as pythonUtils from './utils/generated/python';
 import { createFieldDropdown } from '../fields/FieldDropdown';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
-import { getAllowedTypesForSetCheck, getOutputCheck, addImport } from './utils/python';
+import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { MRC_STYLE_VARIABLES } from '../themes/styles';
 
 // A block to set a python variable.
@@ -256,7 +257,7 @@ export const setup = function() {
 
 export const pythonFromBlock = function(
     block: Blockly.Block,
-    generator: PythonGenerator,
+    generator: ExtendedPythonGenerator,
 ) {
   const setPythonVariableBlock = block as SetPythonVariableBlock;
   const varName = setPythonVariableBlock.mrcActualVariableName
@@ -267,7 +268,7 @@ export const pythonFromBlock = function(
       const moduleName = block.getFieldValue(pythonUtils.FIELD_MODULE_OR_CLASS_NAME);
       const value = generator.valueToCode(block, 'VALUE', Order.NONE);
       if (setPythonVariableBlock.mrcImportModule) {
-        addImport(generator, setPythonVariableBlock.mrcImportModule);
+        generator.addImport(setPythonVariableBlock.mrcImportModule);
       }
       const code = moduleName + '.' + varName + ' = ' + value + ';\n';
       return code;
@@ -276,7 +277,7 @@ export const pythonFromBlock = function(
       const className = block.getFieldValue(pythonUtils.FIELD_MODULE_OR_CLASS_NAME);
       const value = generator.valueToCode(block, 'VALUE', Order.NONE);
       if (setPythonVariableBlock.mrcImportModule) {
-        addImport(generator, setPythonVariableBlock.mrcImportModule);
+        generator.addImport(setPythonVariableBlock.mrcImportModule);
       }
       const code = className + '.' + varName + ' = ' + value + ';\n';
       return code;

src/blocks/utils/python.ts

@@ -19,7 +19,6 @@
  * @author [email protected] (Liz Looney)
  */
 
-import { PythonGenerator } from 'blockly/python';
 import * as pythonUtils from './generated/python';
 
 export const RETURN_TYPE_NONE = 'None';
@@ -94,13 +93,6 @@ export function getOutputCheck(type: string): string {
   return type;
 }
 
-// Functions used in python code generation for multiple python blocks.
-
-export function addImport(generator: PythonGenerator, importModule: string): void {
-  (generator as any).definitions_['import_' + importModule] =
-      'import ' + importModule;
-}
-
 // Function to return a legal name based off of proposed names and making sure it doesn't conflict
 // This is a legal name for python methods and variables. 
 export function getLegalName(proposedName: string, existingNames: string[]){