Merge branch 'main' of github.com:alan412/systemcore-blocks-interface into pr_try_steps_block

Author: alan412

docs/testing_before_pr_checklist.md

@@ -0,0 +1,22 @@
+For each PR, make sure each of these works
+
+# New items
+* [ ] Make a new project and make sure you can edit in Robot and TeleOp
+* [ ] Add an opmode "Auto" from the + next to Tabs
+* [ ] Add a mechanism "Arm" from the + next to Tabs
+# Using robot
+* [ ] Add a component to the Robot
+* [ ] Add a mechanism to the Robot
+* [ ] When editing an OpMode, make sure the component shows up in the toolbox Robot -> Components ->
+* [ ] When editing an OpMode, make sure the mechanism shows up in the toolbox Robot -> Mechanisms -> my_arm
+# Events
+* [ ] Add an event to the Mechanism
+* [ ] In Robot, make sure you can see the event handler in the toolbox Robot -> Mechanisms -> my_arm -> Events
+* [ ] In Opmode, make sure you can see the event handler in the toolbox Robot -> Mechanisms -> my_arm -> Events
+# Mechanims
+* [ ] Add a public component to the mechanism
+* [ ] Add a private component to the mechanism
+* [ ] Make sure that in the Robot you can see the public component (and not the private one) in the toolbox
+# Code Generation
+* [ ] Generate code (right now "Deploy") and make sure there are no errors in the console
+* [ ] Check that the deploy zip file contains robot.py, teleop.py, auto.py, and arm.py.

src/blocks/mrc_call_python_function.ts

@@ -211,22 +211,22 @@ const CALL_PYTHON_FUNCTION = {
         }
         case FunctionKind.EVENT: {
           const eventName = this.getFieldValue(FIELD_EVENT_NAME);
-          tooltip = Blockly.Msg.CALL_INSTANCE_METHOD_WITHIN_TOOLTIP;
+          tooltip = Blockly.Msg.FIRE_EVENT_TOOLTIP;
           tooltip = tooltip.replace('{{eventName}}', eventName);
           break;
         }
         case FunctionKind.INSTANCE_COMPONENT: {
           const className = this.mrcComponentClassName;
           const functionName = this.getFieldValue(FIELD_FUNCTION_NAME);
           if (this.mrcMechanismId) {
-            tooltip = Blockly.Msg.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD;
+            tooltip = Blockly.Msg.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_TOOLTIP;
             tooltip = tooltip
                 .replace('{{className}}', className)
                 .replace('{{functionName}}', functionName)
                 .replace('{{componentName}}', this.getFieldValue(FIELD_COMPONENT_NAME))
                 .replace('{{mechanismName}}', this.getFieldValue(FIELD_MECHANISM_NAME));
           } else {
-            tooltip = Blockly.Msg.CALL_COMPONENT_INSTANCE_METHOD;
+            tooltip = Blockly.Msg.CALL_COMPONENT_INSTANCE_METHOD_TOOLTIP;
             tooltip = tooltip
                 .replace('{{className}}', className)
                 .replace('{{functionName}}', functionName)
@@ -236,18 +236,18 @@ const CALL_PYTHON_FUNCTION = {
         }
         case FunctionKind.INSTANCE_ROBOT: {
           const functionName = this.getFieldValue(FIELD_FUNCTION_NAME);
-          tooltip = Blockly.Msg.CALL_INSTANCE_METHOD_WITHIN_TOOLTIP;
+          tooltip = Blockly.Msg.CALL_ROBOT_INSTANCE_METHOD_TOOLTIP;
           tooltip = tooltip.replace('{{functionName}}', functionName);
           break;
         }
         case FunctionKind.INSTANCE_MECHANISM: {
           const className = this.mrcMechanismClassName;
           const functionName = this.getFieldValue(FIELD_FUNCTION_NAME);
-            tooltip = Blockly.Msg.CALL_MECHANISM_INSTANCE_METHOD;
-            tooltip = tooltip
-                .replace('{{className}}', className)
-                .replace('{{functionName}}', functionName)
-                .replace('{{mechanismName}}', this.getFieldValue(FIELD_MECHANISM_NAME));
+          tooltip = Blockly.Msg.CALL_MECHANISM_INSTANCE_METHOD_TOOLTIP;
+          tooltip = tooltip
+              .replace('{{className}}', className)
+              .replace('{{functionName}}', functionName)
+              .replace('{{mechanismName}}', this.getFieldValue(FIELD_MECHANISM_NAME));
           break;
         }
         default:
@@ -436,7 +436,7 @@ const CALL_PYTHON_FUNCTION = {
         case FunctionKind.INSTANCE_ROBOT: {
           this.appendDummyInput(INPUT_TITLE)
               .appendField(Blockly.Msg.CALL)
-              .appendField(createFieldNonEditableText(Blockly.Msg.ROBOT))
+              .appendField(createFieldNonEditableText(Blockly.Msg.ROBOT_LOWER_CASE))
               .appendField('.')
               .appendField(createFieldNonEditableText(''), FIELD_FUNCTION_NAME);
           break;
@@ -549,66 +549,59 @@ const CALL_PYTHON_FUNCTION = {
     }
     this.updateBlock_();
   },
-  getComponents: function(this: CallPythonFunctionBlock): storageModuleContent.Component[] {
+  getComponents: function(this: CallPythonFunctionBlock, editor: Editor): storageModuleContent.Component[] {
     // Get the list of components whose type matches this.mrcComponentClassName.
     const components: storageModuleContent.Component[] = [];
-    const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);
-    if (editor) {
-      let componentsToConsider: storageModuleContent.Component[] = [];
-      if (this.mrcMechanismId) {
-        // Only consider components that belong to the mechanism.
-        // this.mrcMechanismId is the mechanismId from the MechanismInRobot.
-        // We need to get the MechanismInRobot with that id, then get the mechanism, and then get
-        // the public components defined in that mechanism.
-        for (const mechanismInRobot of editor.getMechanismsFromRobot()) {
-          if (mechanismInRobot.mechanismId === this.mrcMechanismId) {
-            for (const mechanism of editor.getMechanisms()) {
-              if (mechanism.moduleId === mechanismInRobot.moduleId) {
-                componentsToConsider = editor.getComponentsFromMechanism(mechanism);
-                break;
-              }
+    let componentsToConsider: storageModuleContent.Component[] = [];
+    if (this.mrcMechanismId) {
+      // Only consider components that belong to the mechanism.
+      // this.mrcMechanismId is the mechanismId from the MechanismInRobot.
+      // We need to get the MechanismInRobot with that id, then get the mechanism, and then get
+      // the public components defined in that mechanism.
+      for (const mechanismInRobot of editor.getMechanismsFromRobot()) {
+        if (mechanismInRobot.mechanismId === this.mrcMechanismId) {
+          for (const mechanism of editor.getMechanisms()) {
+            if (mechanism.moduleId === mechanismInRobot.moduleId) {
+              componentsToConsider = editor.getComponentsFromMechanism(mechanism);
+              break;
             }
-            break;
           }
+          break;
         }
-      } else if (editor.getModuleType() === storageModule.ModuleType.MECHANISM) {
-        // Only consider components (regular and private) in the current workspace.
-        componentsToConsider = editor.getAllComponentsFromWorkspace();
-      } else {
-        // Only consider components in the robot.
-        componentsToConsider = editor.getComponentsFromRobot();
       }
-      componentsToConsider.forEach(component => {
-        if (component.className === this.mrcComponentClassName) {
-          components.push(component);
-        }
-      });
+    } else if (editor.getModuleType() === storageModule.ModuleType.MECHANISM) {
+      // Only consider components (regular and private) in the current workspace.
+      componentsToConsider = editor.getAllComponentsFromWorkspace();
+    } else {
+      // Only consider components in the robot.
+      componentsToConsider = editor.getComponentsFromRobot();
     }
+    componentsToConsider.forEach(component => {
+      if (component.className === this.mrcComponentClassName) {
+        components.push(component);
+      }
+    });
     return components;
   },
 
   /**
    * mrcOnModuleCurrent is called for each CallPythonFunctionBlock when the module becomes the current module.
    */
-  mrcOnModuleCurrent: function(this: CallPythonFunctionBlock): void {
-    this.checkFunction();
+  mrcOnModuleCurrent: function(this: CallPythonFunctionBlock, editor: Editor): void {
+    this.checkFunction(editor);
   },
   /**
    * mrcOnLoad is called for each CallPythonFunctionBlock when the blocks are loaded in the blockly
    * workspace.
    */
-  mrcOnLoad: function(this: CallPythonFunctionBlock): void {
-    this.checkFunction();
+  mrcOnLoad: function(this: CallPythonFunctionBlock, editor: Editor): void {
+    this.checkFunction(editor);
   },
   /**
    * checkFunction checks the block, updates it, and/or adds a warning balloon if necessary.
    * It is called from mrcOnModuleCurrent and mrcOnLoad above.
    */
-  checkFunction: function(this: CallPythonFunctionBlock): void {
-    const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);
-    if (!editor) {
-      return;
-    }
+  checkFunction: function(this: CallPythonFunctionBlock, editor: Editor): void {
     const warnings: string[] = [];
 
     // If this block is calling a component method, check whether the component
@@ -621,7 +614,7 @@ const CALL_PYTHON_FUNCTION = {
     if (this.mrcFunctionKind === FunctionKind.INSTANCE_COMPONENT) {
       const componentNames: string[] = [];
       this.mrcMapComponentNameToId = {}
-      this.getComponents().forEach(component => {
+      this.getComponents(editor).forEach(component => {
         componentNames.push(component.name);
         this.mrcMapComponentNameToId[component.name] = component.componentId;
       });
@@ -865,7 +858,7 @@ export function pythonFromBlock(
     generator: ExtendedPythonGenerator,
 ) {
   if (block.mrcImportModule) {
-    generator.addImport(block.mrcImportModule);
+    generator.importModule(block.mrcImportModule);
   }
   let code = '';
   let needOpenParen = true;

src/blocks/mrc_component.ts

@@ -26,6 +26,7 @@ import { MRC_STYLE_COMPONENTS } from '../themes/styles'
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
 import { Editor } from '../editor/editor';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
+import { getModuleTypeForWorkspace } from './utils/workspaces';
 import { getAllowedTypesForSetCheck, getClassData, getSubclassNames } from './utils/python';
 import * as toolboxItems from '../toolbox/items';
 import * as storageModule from '../storage/module';
@@ -142,8 +143,8 @@ const COMPONENT = {
    * Update the block to reflect the newly loaded extra state.
    */
   updateBlock_: function (this: ComponentBlock): void {
-    const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);
-    if (editor && editor.getModuleType() === storageModule.ModuleType.ROBOT) {
+    const moduleType = getModuleTypeForWorkspace(this.workspace);
+    if (moduleType === storageModule.ModuleType.ROBOT) {
       // Add input sockets for the arguments.
       for (let i = 0; i < this.mrcArgs.length; i++) {
         const input = this.appendValueInput('ARG' + i)
@@ -192,7 +193,7 @@ const COMPONENT = {
   /**
    * mrcOnLoad is called for each ComponentBlock when the blocks are loaded in the blockly workspace.
    */
-  mrcOnLoad: function(this: ComponentBlock): void {
+  mrcOnLoad: function(this: ComponentBlock, _editor: Editor): void {
     this.checkBlockIsInHolder();
   },
   /**
@@ -246,7 +247,7 @@ export const pythonFromBlock = function (
   generator: ExtendedPythonGenerator,
 ) {
   if (block.mrcImportModule) {
-    generator.addImport(block.mrcImportModule);
+    generator.importModule(block.mrcImportModule);
   }
   let code = 'self.' + block.getFieldValue(FIELD_NAME) + ' = ' + block.getFieldValue(FIELD_TYPE) + "(";
 

src/blocks/mrc_event.ts

@@ -24,6 +24,7 @@ import * as Blockly from 'blockly';
 import { MRC_STYLE_EVENTS } from '../themes/styles'
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
 import { Parameter } from './mrc_class_method_def';
+import { Editor } from '../editor/editor';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import * as paramContainer from './mrc_param_container'
 import {
@@ -196,7 +197,7 @@ const EVENT = {
   /**
    * mrcOnLoad is called for each EventBlock when the blocks are loaded in the blockly workspace.
    */
-  mrcOnLoad: function(this: EventBlock): void {
+  mrcOnLoad: function(this: EventBlock, _editor: Editor): void {
     this.checkBlockIsInHolder();
   },
   /**