feat: complete registerOnXxx infrastructure migration

This commit completes the refactoring of Ruby-to-blocks converter by:

- Remove legacy onXxx functions from migrated converters:
  - control.js: onIf, onUntil
  - motion.js: onOpAsgn
  - my-blocks.js: onVar, onDefs
  - operators.js: onAnd, onOr
  - variables.js: onOpAsgn, onVar, onVasgn

- Remove legacy _converters array infrastructure
- Replace with targeted legacy support for unmigrated converters
- Maintain backward compatibility for looks, sound, pen, music converters
- All tests pass, ensuring functionality is preserved

Closes #399

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: takaokouji

src/lib/ruby-to-blocks-converter/control.js

@@ -20,36 +20,6 @@ const StopOptions = [
  */
 const ControlConverter = {
 
-    onIf: function (cond, statement, elseStatement) {
-        const block = this._createBlock('control_if', 'statement');
-        if (!this._isFalse(cond)) {
-            this._addInput(block, 'CONDITION', cond);
-        }
-        this._addSubstack(block, statement);
-        if (elseStatement) {
-            block.opcode = 'control_if_else';
-            this._addSubstack(block, elseStatement, 2);
-        }
-        return block;
-    },
-
-    onUntil: function (cond, statement) {
-        statement = this._removeWaitBlocks(statement);
-
-        let opcode;
-        if (statement === null) {
-            opcode = 'control_wait_until';
-        } else {
-            opcode = 'control_repeat_until';
-        }
-        const block = this._createBlock(opcode, 'statement');
-        if (!this._isFalse(cond)) {
-            this._addInput(block, 'CONDITION', cond);
-        }
-        this._addSubstack(block, statement);
-        return block;
-    },
-
     register: function (converter) {
         // sleep(duration) - control_wait
         converter.registerCallMethod('self', 'sleep', 1, params => {

src/lib/ruby-to-blocks-converter/index.js

@@ -89,25 +89,6 @@ class RubyToBlocksConverter {
     constructor (vm) {
         this.vm = vm;
         this._translator = message => message.defaultMessage;
-        this._converters = [
-            MusicConverter,
-            PenConverter,
-            EV3Converter,
-            GdxForConverter,
-            SmalrubotS1Converter,
-            BoostConverter,
-            TranslateConverter,
-            MakeyMakeyConverter,
-
-            MotionConverter,
-            LooksConverter,
-            SoundConverter,
-            ControlConverter,
-            SensingConverter,
-            OperatorsConverter,
-            VariablesConverter,
-            MyBlocksConverter
-        ];
         this._receiverToMethods = {};
         this._receiverToMyBlocks = {};
         this._onIfHandlers = [];
@@ -593,16 +574,31 @@ class RubyToBlocksConverter {
             }
         }
 
-        // Then, check legacy converter objects
-        for (let i = 0; i < this._converters.length; i++) {
-            const converter = this._converters[i];
+        // Then, check legacy converter objects for remaining unmigrated handlers
+        const legacyConverters = [
+            MusicConverter,
+            PenConverter,
+            EV3Converter,
+            GdxForConverter,
+            SmalrubotS1Converter,
+            BoostConverter,
+            TranslateConverter,
+            MakeyMakeyConverter,
+            LooksConverter,
+            SoundConverter,
+            SensingConverter
+        ];
+        
+        for (let i = 0; i < legacyConverters.length; i++) {
+            const converter = legacyConverters[i];
             if (Object.prototype.hasOwnProperty.call(converter, handlerName)) {
                 const block = converter[handlerName].apply(this, args);
                 if (block) {
                     return block;
                 }
             }
         }
+
         return null;
     }
 

src/lib/ruby-to-blocks-converter/motion.js

@@ -164,31 +164,6 @@ const MotionConverter = {
             }
             return block;
         });
-    },
-
-    // Handle compound assignments like x += value, y += value
-    onOpAsgn: function (lh, operator, rh) {
-        let block;
-        if (this._isBlock(lh) && operator === '+' && this._isNumberOrBlock(rh)) {
-            let xy;
-            switch (lh.opcode) {
-            case 'motion_xposition':
-            case 'motion_yposition':
-                // All Motion blocks are sprite-only
-                if (this._isStage()) {
-                    throw new RubyToBlocksConverterError(lh.node, 'Stage selected: no motion blocks');
-                }
-                if (lh.opcode === 'motion_xposition') {
-                    xy = 'x';
-                } else {
-                    xy = 'y';
-                }
-                block = this._changeBlock(lh, `motion_change${xy}by`, 'statement');
-                this._addNumberInput(block, `D${_.toUpper(xy)}`, 'math_number', rh, 10);
-                break;
-            }
-        }
-        return block;
     }
 };
 

src/lib/ruby-to-blocks-converter/my-blocks.js

@@ -180,134 +180,6 @@ const MyBlocksConverter = {
 
             return block;
         });
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onVar: function (scope, variable) {
-        let block;
-        if (scope === 'local') {
-            let opcode;
-            let blockType;
-            if (variable.isBoolean) {
-                opcode = 'argument_reporter_boolean';
-                blockType = 'value_boolean';
-            } else {
-                opcode = 'argument_reporter_string_number';
-                blockType = 'value';
-            }
-            // Use normalized variable name (should already be in snake_case lowercase)
-            const normalizedName = this._toSnakeCaseLowercase(variable.name);
-            block = this._createBlock(opcode, blockType, {
-                fields: {
-                    VALUE: {
-                        name: 'VALUE',
-                        value: normalizedName
-                    }
-                }
-            });
-            if (Object.prototype.hasOwnProperty.call(this._context.argumentBlocks, variable.id)) {
-                this._context.argumentBlocks[variable.id].push(block.id);
-            } else {
-                this._context.argumentBlocks[variable.id] = [block.id];
-            }
-        }
-        return block;
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onDefs: function (node, saved) {
-        const receiver = this._process(node.children[0]);
-        if (!this._isSelf(receiver)) {
-            return null;
-        }
-
-        const procedureName = node.children[1].toString();
-        const block = this._createBlock('procedures_definition', 'hat', {
-            topLevel: true
-        });
-        const procedure = this._createProcedure(procedureName);
-
-        const customBlock = this._createBlock('procedures_prototype', 'statement', {
-            shadow: true
-        });
-        this._addInput(block, 'custom_block', customBlock);
-
-        this._context.localVariables = {};
-        this._process(node.children[2]).forEach(n => {
-            const originalName = n.toString();
-            // Convert argument name to snake_case lowercase
-            const normalizedName = this._toSnakeCaseLowercase(originalName);
-
-            procedure.argumentNames.push(normalizedName);
-            procedure.argumentVariables.push(this._lookupOrCreateVariable(normalizedName));
-            procedure.procCode.push('%s');
-            procedure.argumentDefaults.push('');
-            const inputId = Blockly.utils.genUid();
-            procedure.argumentIds.push(inputId);
-            const inputBlock = this._createBlock('argument_reporter_string_number', 'value', {
-                fields: {
-                    VALUE: {
-                        name: 'VALUE',
-                        value: normalizedName
-                    }
-                },
-                shadow: true
-            });
-            this._addInput(customBlock, inputId, inputBlock);
-            procedure.argumentBlocks.push(inputBlock);
-        });
-
-        let body = this._process(node.children[3]);
-        if (!_.isArray(body)) {
-            body = [body];
-        }
-        if (this._isBlock(body[0])) {
-            block.next = body[0].id;
-            body[0].parent = block.id;
-        }
-
-        const booleanIndexes = [];
-        procedure.argumentVariables.forEach((v, i) => {
-            if (v.isBoolean) {
-                booleanIndexes.push(i);
-                procedure.procCode[i + 1] = '%b';
-                procedure.argumentDefaults[i] = 'false';
-                procedure.argumentBlocks[i].opcode = 'argument_reporter_boolean';
-                this._setBlockType(procedure.argumentBlocks[i], 'value_boolean');
-            }
-        });
-
-        if (booleanIndexes.length > 0 &&
-            Object.prototype.hasOwnProperty.call(this._context.procedureCallBlocks, procedure.id)) {
-            this._context.procedureCallBlocks[procedure.id].forEach(id => {
-                const b = this._context.blocks[id];
-                b.mutation.proccode = procedure.procCode.join(' ');
-                booleanIndexes.forEach(booleanIndex => {
-                    const input = b.inputs[procedure.argumentIds[booleanIndex]];
-                    const inputBlock = this._context.blocks[input.block];
-                    if (inputBlock) {
-                        if (!inputBlock.shadow && input.shadow) {
-                            delete this._context.blocks[input.shadow];
-                            input.shadow = null;
-                        }
-                    }
-                });
-            });
-        }
-
-        customBlock.mutation = {
-            argumentdefaults: JSON.stringify(procedure.argumentDefaults),
-            argumentids: JSON.stringify(procedure.argumentIds),
-            argumentnames: JSON.stringify(procedure.argumentNames),
-            children: [],
-            proccode: procedure.procCode.join(' '),
-            tagName: 'mutation',
-            warp: 'false'
-        };
-
-        this._restoreContext({localVariables: saved.localVariables});
-
-        return block;
     }
 };
 

src/lib/ruby-to-blocks-converter/operators.js

@@ -254,40 +254,6 @@ const OperatorsConverter = {
             }
             return block;
         });
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onAnd: function (operands) {
-        const block = this._createBlock('operator_and', 'value_boolean');
-        operands.forEach(o => {
-            if (o) {
-                o.parent = block.id;
-            }
-        });
-        if (!this._isFalse(operands[0])) {
-            this._addInput(block, 'OPERAND1', this._createTextBlock(operands[0]));
-        }
-        if (!this._isFalse(operands[1])) {
-            this._addInput(block, 'OPERAND2', this._createTextBlock(operands[1]));
-        }
-        return block;
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onOr: function (operands) {
-        const block = this._createBlock('operator_or', 'value_boolean');
-        operands.forEach(o => {
-            if (o) {
-                o.parent = block.id;
-            }
-        });
-        if (!this._isFalse(operands[0])) {
-            this._addInput(block, 'OPERAND1', this._createTextBlock(operands[0]));
-        }
-        if (!this._isFalse(operands[1])) {
-            this._addInput(block, 'OPERAND2', this._createTextBlock(operands[1]));
-        }
-        return block;
     }
 };
 

src/lib/ruby-to-blocks-converter/variables.js

@@ -249,66 +249,6 @@ const VariablesConverter = {
             }
             return null;
         });
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onOpAsgn: function (lh, operator, rh) {
-        let block;
-        if (operator === '+' && this._isString(lh) && this._isNumberOrBlock(rh)) {
-            const variable = this._lookupOrCreateVariable(lh);
-            if (variable.scope !== 'local') {
-                block = this._createBlock('data_changevariableby', 'statement', {
-                    fields: {
-                        VARIABLE: {
-                            name: 'VARIABLE',
-                            id: variable.id,
-                            value: variable.name,
-                            variableType: variable.type
-                        }
-                    }
-                });
-                this._addNumberInput(block, 'VALUE', 'math_number', rh, 1);
-            }
-        }
-        return block;
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onVar: function (scope, variable) {
-        if (scope === 'global' || scope === 'instance') {
-            return this._createBlock('data_variable', 'value_variable', {
-                fields: {
-                    VARIABLE: {
-                        name: 'VARIABLE',
-                        id: variable.id,
-                        value: variable.name,
-                        variableType: variable.type
-                    }
-                }
-            });
-        }
-        return null;
-    },
-
-    // eslint-disable-next-line no-unused-vars
-    onVasgn: function (scope, variable, rh) {
-        if (scope === 'global' || scope === 'instance') {
-            if (this._isNumberOrBlock(rh) || this._isStringOrBlock(rh)) {
-                const block = this._createBlock('data_setvariableto', 'statement', {
-                    fields: {
-                        VARIABLE: {
-                            name: 'VARIABLE',
-                            id: variable.id,
-                            value: variable.name,
-                            variableType: variable.type
-                        }
-                    }
-                });
-                this._addTextInput(block, 'VALUE', this._isNumber(rh) ? rh.toString() : rh, '0');
-                return block;
-            }
-        }
-        return null;
     }
 };