check argument type in My Blocks.

Author: takaokouji

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

@@ -407,7 +407,14 @@ class RubyToBlocksConverter {
             );
         }
         procedure = {
-            id: Blockly.utils.genUid()
+            id: Blockly.utils.genUid(),
+            name: name,
+            procCode: [name],
+            argumentNames: [],
+            argumentDefaults: [],
+            argumentIds: [],
+            argumentVariables: [],
+            argumentBlocks: []
         };
         this._context.procedures[name] = procedure;
         return procedure;
@@ -859,12 +866,16 @@ class RubyToBlocksConverter {
                         args.forEach((arg, i) => {
                             const argumentId = procedure.argumentIds[i];
                             if (this._isFalseOrBooleanBlock(arg)) {
-                                if (arg !== false) {
-                                    this._addInput(block, argumentId, arg, null);
+                                if (procedure.argumentVariables[i].isBoolean ||
+                                    this._changeToBooleanArgument(procedure.argumentNames[i])) {
+                                    if (arg !== false) {
+                                        this._addInput(block, argumentId, arg, null);
+                                    }
+                                    return;
                                 }
-                                this._changeToBooleanArgument(procedure.argumentNames[i]);
-                                return;
-                            } else if (this._isNumberOrBlock(arg) || this._isStringOrBlock(arg)) {
+                            }
+                            if (!procedure.argumentVariables[i].isBoolean &&
+                                (this._isNumberOrBlock(arg) || this._isStringOrBlock(arg))) {
                                 this._addTextInput(block, argumentId, _.isNumber(arg) ? arg.toString() : arg, '');
                                 return;
                             }
@@ -1463,20 +1474,16 @@ class RubyToBlocksConverter {
                 topLevel: true
             });
             const procedure = this._createProcedure(procedureName);
-            procedure.procCode = [procedureName];
 
             const customBlock = this._createBlock('procedures_prototype', 'statement', {
                 shadow: true
             });
             this._addInput(block, 'custom_block', customBlock);
 
-            procedure.argumentNames = this._process(node.children[2]);
-            procedure.argumentDefaults = [];
-            procedure.argumentIds = [];
-            procedure.argumentVariables = [];
-            procedure.argumentBlocks = [];
             this._context.localVariables = {};
-            procedure.argumentNames.forEach(n => {
+            this._process(node.children[2]).forEach(n => {
+                n = n.toString();
+                procedure.argumentNames.push(n);
                 procedure.argumentVariables.push(this._findOrCreateVariable(n));
                 procedure.procCode.push('%s');
                 procedure.argumentDefaults.push('');

test/unit/lib/ruby-to-blocks-converter/my-blocks.test.js

@@ -14,6 +14,32 @@ describe('RubyToBlocksConverter/My Blocks', () => {
         target = null;
     });
 
+    test('procedures_definition,procedures_prototype no arguments', () => {
+        const code = `
+            def self.made_block
+            end
+        `;
+        const expected = [
+            {
+                opcode: 'procedures_definition',
+                inputs: [
+                    {
+                        name: 'custom_block',
+                        block: {
+                            opcode: 'procedures_prototype',
+                            mutation: {
+                                proccode: 'made_block',
+                                arguments: []
+                            },
+                            shadow: true
+                        }
+                    }
+                ]
+            }
+        ];
+        convertAndExpectToEqualBlocks(converter, target, code, expected);
+    });
+
     test('procedures_definition,procedures_prototype', () => {
         const code = `
             def self.made_block(arg1, arg2)
@@ -577,17 +603,33 @@ describe('RubyToBlocksConverter/My Blocks', () => {
         convertAndExpectToEqualBlocks(converter, target, code, expected);
     });
 
-    test.only('error if argument type miss match', () => {
-        const code = `
-            def self.made_block(arg1)
-              if arg1
-              end
-            end
+    describe('error if argument type miss match', () => {
+        test('defined string_number, call boolean', () => {
+            const code = `
+                def self.made_block(arg1, arg2)
+                  if arg2
+                  end
+                end
 
-            made_block(12)
-        `;
-        const res = converter.targetCodeToBlocks(target, code);
-        expect(converter.errors).toHaveLength(1);
-        expect(res).toBeFalsy();
+                made_block(12, 34)
+            `;
+            const res = converter.targetCodeToBlocks(target, code);
+            expect(converter.errors).toHaveLength(1);
+            expect(converter.errors[0].text).toMatch(/invalid type of My Block "made_block" argument #2/);
+            expect(res).toBeFalsy();
+        });
+
+        test('defined boolean, call string_number', () => {
+            const code = `
+                def self.made_block(arg1, arg2)
+                end
+
+                made_block(false, 1)
+            `;
+            const res = converter.targetCodeToBlocks(target, code);
+            expect(converter.errors).toHaveLength(1);
+            expect(converter.errors[0].text).toMatch(/invalid type of My Block "made_block" argument #1/);
+            expect(res).toBeFalsy();
+        });
     });
 });