aliasing, repeat(times) { } as control_repeat.

Author: takaokouji

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

@@ -1,5 +1,14 @@
 /* global Opal */
 
+/* eslint-disable no-invalid-this */
+const createControlRepeatBlock = function (times, body) {
+    const block = this._createBlock('control_repeat', 'statement');
+    this._addNumberInput(block, 'TIMES', 'math_whole_number', times, 10);
+    this._addSubstack(block, body);
+    return block;
+};
+/* eslint-enable no-invalid-this */
+
 /**
  * Control converter
  */
@@ -15,6 +24,12 @@ const ControlConverter = {
                     this._addNumberInput(block, 'DURATION', 'math_positive_number', args[0], 1);
                 }
                 break;
+            case 'repeat':
+                if (args.length === 1 && this._isNumberOrBlock(args[0]) &&
+                    rubyBlockArgs && rubyBlockArgs.length === 0) {
+                    block = createControlRepeatBlock.call(this, args[0], rubyBlock);
+                }
+                break;
             }
         } else if (this._isNumberOrBlock(receiver)) {
             switch (name) {
@@ -24,9 +39,7 @@ const ControlConverter = {
                     rubyBlock && rubyBlock.length >= 1) {
                     const waitBlock = this._popWaitBlock(rubyBlock);
                     if (waitBlock) {
-                        block = this._createBlock('control_repeat', 'statement');
-                        this._addNumberInput(block, 'TIMES', 'math_whole_number', receiver, 10);
-                        this._addSubstack(block, rubyBlock);
+                        block = createControlRepeatBlock.call(this, receiver, rubyBlock);
                     }
                 }
                 break;

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

@@ -581,11 +581,15 @@ class RubyToBlocksConverter {
         let prevBlock = null;
         const blocks = [];
         let terminated = false;
+        let firstBlock;
         node.children.forEach(childNode => {
             const block = this._process(childNode);
             if (!block) {
                 return;
             }
+            if (!firstBlock) {
+                firstBlock = block;
+            }
             switch (this._getBlockType(block)) {
             case 'statement':
                 if (prevBlock) {
@@ -616,6 +620,12 @@ class RubyToBlocksConverter {
                 break;
             }
         });
+        if (blocks.length === 0 && firstBlock) {
+            if (/^value/.test(this._getBlockType(firstBlock))) {
+                firstBlock.topLevel = false;
+            }
+            blocks.push(firstBlock);
+        }
         return blocks;
     }
 
@@ -628,7 +638,10 @@ class RubyToBlocksConverter {
     _onSend (node, rubyBlockArgsNode, rubyBlockNode) {
         const saved = this._saveContext();
 
-        const receiver = this._process(node.children[0]);
+        let receiver = this._process(node.children[0]);
+        if (_.isArray(receiver) && receiver.length === 1) {
+            receiver = receiver[0];
+        }
         const name = node.children[1].toString();
         const args = node.children.slice(2).map(childNode => this._process(childNode));
 

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

@@ -182,6 +182,105 @@ describe('RubyToBlocksConverter/Control', () => {
                 expect(res).toBeTruthy();
             });
         });
+
+        describe('repeat', () => {
+            test('number', () => {
+                code = 'repeat(10) { move(10) }';
+                expected = [
+                    {
+                        opcode: 'control_repeat',
+                        inputs: [
+                            {
+                                name: 'TIMES',
+                                block: expectedInfo.makeNumber(10, 'math_whole_number')
+                            }
+                        ],
+                        branches: [
+                            rubyToExpected(converter, target, 'move(10)')[0]
+                        ]
+                    }
+                ];
+                convertAndExpectToEqualBlocks(converter, target, code, expected);
+
+                code = 'repeat(10) { move(10); bounce_if_on_edge }';
+                expected = [
+                    {
+                        opcode: 'control_repeat',
+                        inputs: [
+                            {
+                                name: 'TIMES',
+                                block: expectedInfo.makeNumber(10, 'math_whole_number')
+                            }
+                        ],
+                        branches: [
+                            rubyToExpected(converter, target, 'move(10); bounce_if_on_edge')[0]
+                        ]
+                    }
+                ];
+                convertAndExpectToEqualBlocks(converter, target, code, expected);
+            });
+
+            test('value block', () => {
+                code = 'repeat(x) { move(10) }';
+                expected = [
+                    {
+                        opcode: 'control_repeat',
+                        inputs: [
+                            {
+                                name: 'TIMES',
+                                block: rubyToExpected(converter, target, 'x')[0],
+                                shadow: expectedInfo.makeNumber(10, 'math_whole_number')
+                            }
+                        ],
+                        branches: [
+                            rubyToExpected(converter, target, 'move(10)')[0]
+                        ]
+                    }
+                ];
+                convertAndExpectToEqualBlocks(converter, target, code, expected);
+            });
+
+            test('boolean block', () => {
+                code = 'repeat(touching?("_edge_")) { move(10) }';
+                expected = [
+                    {
+                        opcode: 'control_repeat',
+                        inputs: [
+                            {
+                                name: 'TIMES',
+                                block: rubyToExpected(converter, target, 'touching?("_edge_")')[0],
+                                shadow: expectedInfo.makeNumber(10, 'math_whole_number')
+                            }
+                        ],
+                        branches: [
+                            rubyToExpected(converter, target, 'move(10)')[0]
+                        ]
+                    }
+                ];
+                convertAndExpectToEqualBlocks(converter, target, code, expected);
+            });
+
+            test('invalid', () => {
+                [
+                    'repeat(10)',
+                    'repeat(10, 1)'
+                ].forEach(c => {
+                    convertAndExpectToEqualRubyStatement(converter, target, c, c);
+                });
+
+                [
+                    'repeat(10) { |i| }',
+                    'repeat("10") { }'
+                ].forEach(c => {
+                    const res = converter.targetCodeToBlocks(target, c);
+                    expect(converter.errors).toHaveLength(0);
+                    const scriptIds = Object.keys(converter.blocks).filter(id => converter.blocks[id].topLevel);
+                    expect(scriptIds).toHaveLength(1);
+                    expect(converter.blocks[scriptIds[0]]).toHaveProperty('opcode', 'ruby_statement_with_block');
+                    expect(res).toBeTruthy();
+                });
+            });
+        });
     });
 
     test('control_forever', () => {