Limit Jump to step to be within steps

Author: alan412

src/blocks/mrc_jump_to_step.ts

@@ -25,14 +25,19 @@ import {Order} from 'blockly/python';
 import {ExtendedPythonGenerator} from '../editor/extended_python_generator';
 import {createFieldNonEditableText} from '../fields/FieldNonEditableText';
 import {MRC_STYLE_VARIABLES} from '../themes/styles';
+import {BLOCK_NAME as MRC_STEPS, StepsBlock} from './mrc_steps'
 
 export const BLOCK_NAME = 'mrc_jump_to_step';
 
 const FIELD_STEP_NAME = 'STEP_NAME';
 
+const WARNING_ID_NOT_IN_STEP = 'not in step';
+
+
 type JumpToStepBlock = Blockly.Block & Blockly.BlockSvg & JumpToStepMixin;
 
 interface JumpToStepMixin extends JumpToStepMixinType {
+  mrcHasWarning: boolean,
 }
 
 type JumpToStepMixinType = typeof JUMP_TO_STEP_BLOCK;
@@ -50,6 +55,39 @@ const JUMP_TO_STEP_BLOCK = {
     this.setStyle(MRC_STYLE_VARIABLES);
     this.setTooltip('Jump to the specified step.');          
   },
+      /**
+         * mrcOnMove is called when an EventBlock is moved.
+         */
+        mrcOnMove: function(this: JumpToStepBlock, _reason: string[]): void {
+          this.checkBlockPlacement();
+        },
+        mrcOnAncestorMove: function(this: JumpToStepBlock): void {
+          this.checkBlockPlacement();
+        },
+        checkBlockPlacement: function(this: JumpToStepBlock): void {
+          const legalStepNames: string[] = [];
+      
+          const rootBlock: Blockly.Block | null = this.getRootBlock();
+          if (rootBlock.type === MRC_STEPS) {
+            // This block is within a class method definition.
+            const stepsBlock = rootBlock as StepsBlock;
+            // Add the method's parameter names to legalStepNames.
+            legalStepNames.push(...stepsBlock.mrcGetStepNames());
+          } 
+      
+          if (legalStepNames.includes(this.getFieldValue(FIELD_STEP_NAME))) {
+            // If this blocks's parameter name is in legalParameterNames, it's good.
+            this.setWarningText(null, WARNING_ID_NOT_IN_STEP);
+            this.mrcHasWarning = false;
+          } else {
+            // Otherwise, add a warning to this block.
+            if (!this.mrcHasWarning) {
+              this.setWarningText(Blockly.Msg.JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK, WARNING_ID_NOT_IN_STEP);
+              this.getIcon(Blockly.icons.IconType.WARNING)!.setBubbleVisible(true);
+              this.mrcHasWarning = true;
+            }
+          }
+        },
 };
 
 export const setup = function() {
@@ -60,8 +98,9 @@ export const pythonFromBlock = function(
     block: JumpToStepBlock,
     _generator: ExtendedPythonGenerator,
 ) {
-  // TODO (Alan) : Specify the type here as well
-  const code = '# TODO: Jump to step ' + block.getFieldValue(FIELD_STEP_NAME) + '\n';
+  let code = 'self.current_step_index = self.mrc_step_name_to_index["' +
+      block.getFieldValue(FIELD_STEP_NAME) + '"]\n';
+  code += 'return\n';
 
-  return [code, Order.ATOMIC];
+  return code;
 };

src/blocks/mrc_steps.ts

@@ -24,13 +24,21 @@ import {Order} from 'blockly/python';
 
 import { MRC_STYLE_STEPS } from '../themes/styles';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
-import { createStepFieldFlydown } from '../fields/field_flydown';
+import { createStepFieldFlydown, FieldFlydown } from '../fields/field_flydown';
 import * as stepContainer from './mrc_step_container'
 
 export const BLOCK_NAME = 'mrc_steps';
 // const MUTATOR_BLOCK_NAME = 'steps_mutatorarg';
 
 
+/** Extra state for serialising call_python_* blocks. */
+type StepsExtraState = {
+  /**
+   * The steps
+   */
+  stepNames: string[],
+};
+
 export type StepsBlock = Blockly.Block & StepsMixin & Blockly.BlockSvg;
 interface StepsMixin extends StepsMixinType {
     mrcStepNames: string[];
@@ -50,6 +58,17 @@ const STEPS = {
         this.setMutator(stepContainer.getMutatorIcon(this));
         this.updateShape_();
     },
+    saveExtraState: function (this: StepsBlock): StepsExtraState{
+        return {
+            stepNames: this.mrcStepNames,
+        };
+    },
+    loadExtraState: function (this: StepsBlock, state: StepsExtraState): void {
+        if (state && state.stepNames) {
+            this.mrcStepNames = state.stepNames;
+            this.updateShape_();
+        }
+    },
     compose: function (this: StepsBlock, containerBlock: Blockly.Block) {
         if (containerBlock.type !== stepContainer.STEP_CONTAINER_BLOCK_NAME) {
             throw new Error('compose: containerBlock.type should be ' + stepContainer.STEP_CONTAINER_BLOCK_NAME);
@@ -80,6 +99,30 @@ const STEPS = {
     },
     mrcOnChange: function(this: StepsBlock): void {
 
+    },
+    mrcUpdateStepName: function(this: StepsBlock, step : number, newName: string) : string {
+        const otherNames = this.mrcStepNames.filter((_name, index) => index !== step);
+        let currentName = newName;
+      
+        // Make name unique if it conflicts
+        while (otherNames.includes(currentName)) {
+            // Check if currentName ends with a number
+            const match = currentName.match(/^(.*?)(\d+)$/);
+            if (match) {
+                // If it ends with a number, increment it
+                const baseName = match[1];
+                const number = parseInt(match[2], 10);
+                currentName = baseName + (number + 1);
+            } else {
+                // If it doesn't end with a number, append 2
+                currentName = currentName + '2';
+            }
+        }
+        this.mrcStepNames[step] = currentName;
+        // TODO: Rename any jump blocks that refer to this step
+
+        
+        return currentName;
     },
     updateShape_: function (this: StepsBlock): void {
         // some way of knowing what was there before and what is there now
@@ -91,13 +134,19 @@ const STEPS = {
             i++;
         }
         for (let j = 0; j < this.mrcStepNames.length; j++) {
+            const fieldFlydown = createStepFieldFlydown(this.mrcStepNames[j], true);
+            
+            fieldFlydown.setValidator(this.mrcUpdateStepName.bind(this, j));
             this.appendValueInput('CONDITION_' + j)
-                .appendField(createStepFieldFlydown(this.mrcStepNames[j], true))
+                .appendField(fieldFlydown)
                 .setCheck('Boolean')
                 .appendField(Blockly.Msg.REPEAT_UNTIL);    
             this.appendStatementInput('STEP_' + j);
         }
     },
+    mrcGetStepNames: function(this: StepsBlock): string[] {
+        return this.mrcStepNames;
+    }
 };
 
 export const setup = function () {

src/blocks/tokens.ts

@@ -131,6 +131,7 @@ export function customTokens(t: (key: string) => string): typeof Blockly.Msg {
     COMMENT_DEFAULT_TEXT: t('BLOCKLY.COMMENT_DEFAULT_TEXT'),
     STEPS: t('BLOCKLY.STEPS'),
     REPEAT_UNTIL: t('BLOCKLY.REPEAT_UNTIL'),
+    JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK: t('BLOCKLY.JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK'),
   }
 };
 

src/i18n/locales/en/translation.json

@@ -124,6 +124,7 @@
         "PARAMETER": "parameter",
         "PARAMETERS": "Parameters",
         "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "Parameters can only go in their method's block",
+        "JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK": "Jump can only go in their step's block",
         "EVENT_HANDLER_ALREADY_ON_WORKSPACE": "This event handler is already on the workspace.",
         "EVENT_HANDLER_ROBOT_EVENT_NOT_FOUND": "This block is an event handler for an event that no longer exists.",
         "EVENT_HANDLER_MECHANISM_EVENT_NOT_FOUND": "This block is an event handler for an event that no longer exists.",

src/i18n/locales/es/translation.json

@@ -125,7 +125,8 @@
         "PARAMETER": "parámetro",
         "PARAMETERS": "Parámetros",
         "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "Los parámetros solo pueden ir en el bloque de su método",
-        "EVENT_HANDLER_ALREADY_ON_WORKSPACE": "Este controlador de eventos ya está en el área de trabajo.",
+        "JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK": "El salto solo puede ir en el bloque de su paso",
+        "EVENT_HANDLER_ALREADY_ON_WORKSPACE": "Este controlador de eventos ya está en el espacio de trabajo.",
         "EVENT_HANDLER_ROBOT_EVENT_NOT_FOUND": "Este bloque es un controlador de eventos para un evento que ya no existe.",
         "EVENT_HANDLER_MECHANISM_EVENT_NOT_FOUND": "Este bloque es un controlador de eventos para un evento que ya no existe.",
         "EVENT_HANDLER_MECHANISM_NOT_FOUND": "Este bloque es un controlador de eventos para un evento en un mecanismo que ya no existe.",

src/i18n/locales/he/translation.json

@@ -123,8 +123,9 @@
     "WHEN": "כאשר",
     "PARAMETER": "פרמטר",
     "PARAMETERS": "פרמטרים",
-    "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "פרמטרים יכולים להופיע רק בתוך הבלוק של המתודה שלהם.",
-    "EVENT_HANDLER_ALREADY_ON_WORKSPACE": "מנהל האירועים הזה כבר נמצא בסביבת העבודה.",
+    "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "פרמטרים יכולים ללכת רק בבלוק השיטה שלהם",
+    "JUMP_CAN_ONLY_GO_IN_THEIR_STEPS_BLOCK": "קפיצה יכולה ללכת רק בבלוק הצעד שלה",
+    "EVENT_HANDLER_ALREADY_ON_WORKSPACE": "מטפל אירועים זה כבר נמצא במרחב העבודה.",
     "EVENT_HANDLER_ROBOT_EVENT_NOT_FOUND": "הבלוק הזה הוא מנהל אירועים לאירוע שכבר לא קיים.",
     "EVENT_HANDLER_MECHANISM_EVENT_NOT_FOUND": "הבלוק הזה הוא מנהל אירועים לאירוע שכבר לא קיים.",
     "EVENT_HANDLER_MECHANISM_NOT_FOUND": "הבלוק הזה הוא מנהל אירועים לאירוע במנגנון שכבר לא קיים.",