event_whenkeypressed

Author: takaokouji

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

@@ -1,25 +1,75 @@
 /* global Opal */
 import _ from 'lodash';
 
+const KeyOptions = [
+    'space',
+    'left arrow',
+    'right arrow',
+    'down arrow',
+    'up arrow',
+    'any',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9'
+];
+
 /**
  * Event converter
  */
 const EventConverter = {
     // eslint-disable-next-line no-unused-vars
     onSend: function (receiver, name, args, rubyBlockArgs, rubyBlock) {
         let block;
-        if (this._isSelf(receiver) || receiver === Opal.nil) {
-            switch (name) {
-            case 'when':
+        if ((this._isSelf(receiver) || receiver === Opal.nil) &&
+            name === 'when' &&
+            args.length >= 1 && args[0].type === 'sym' &&
+            rubyBlockArgs && rubyBlockArgs.length === 0 &&
+            rubyBlock) {
+            switch (args[0].value) {
+            case 'flag_clicked':
                 if (args.length === 1) {
-                    if (args[0].type === 'sym' && args[0].value === 'flag_clicked' &&
-                        rubyBlockArgs && rubyBlockArgs.length === 0) {
-                        block = this._createBlock('event_whenflagclicked', 'hat');
-                        if (this._isBlock(rubyBlock)) {
-                            rubyBlock.parent = block.id;
-                            block.next = rubyBlock.id;
-                        }
-                    }
+                    block = this._createBlock('event_whenflagclicked', 'hat');
+                    this._setParent(rubyBlock, block);
+                }
+                break;
+            case 'key_pressed':
+                if (args.length === 2 && this._isString(args[1]) && KeyOptions.indexOf(args[1].toString()) >= 0) {
+                    block = this._createBlock('event_whenkeypressed', 'hat');
+                    this._addField(block, 'KEY_OPTION', args[1]);
+                    this._setParent(rubyBlock, block);
                 }
                 break;
             }

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

@@ -603,6 +603,13 @@ class RubyToBlocksConverter {
         return true;
     }
 
+    _setParent (block, parent) {
+        if (this._isBlock(block)) {
+            block.parent = parent.id;
+            parent.next = block.id;
+        }
+    }
+
     _matchRubyExpression (block, regexp) {
         if (!this._isBlock(block) || block.opcode !== 'ruby_expression') {
             return false;

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

@@ -88,4 +88,97 @@ describe('RubyToBlocksConverter/Event', () => {
             expect(res).toBeFalsy();
         });
     });
+
+    describe('event_whenkeypressed', () => {
+        test('normal', () => {
+            code = 'self.when(:key_pressed, "space") { bounce_if_on_edge }';
+            expected = [
+                {
+                    opcode: 'event_whenkeypressed',
+                    fields: [
+                        {
+                            name: 'KEY_OPTION',
+                            value: 'space'
+                        }
+                    ],
+                    next: {
+                        opcode: 'motion_ifonedgebounce'
+                    }
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+
+            code = 'self.when(:key_pressed, "space") { bounce_if_on_edge; move(10) }';
+            expected = [
+                {
+                    opcode: 'event_whenkeypressed',
+                    fields: [
+                        {
+                            name: 'KEY_OPTION',
+                            value: 'space'
+                        }
+                    ],
+                    next: rubyToExpected(converter, target, 'bounce_if_on_edge; move(10)')[0]
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('hat', () => {
+            code = `
+                bounce_if_on_edge
+                self.when(:key_pressed, "space") do
+                end
+                bounce_if_on_edge
+            `;
+            expected = [
+                rubyToExpected(converter, target, 'bounce_if_on_edge')[0],
+                {
+                    opcode: 'event_whenkeypressed',
+                    fields: [
+                        {
+                            name: 'KEY_OPTION',
+                            value: 'space'
+                        }
+                    ]
+                },
+                rubyToExpected(converter, target, 'bounce_if_on_edge')[0]
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('invalid', () => {
+            [
+                'self.when(:key_pressed)',
+                'self.when("space")',
+                'self.when(:key_pressed, "space", 1)',
+                'self.when(:key_pressed, "invalid key")'
+            ].forEach(c => {
+                convertAndExpectToEqualRubyStatement(converter, target, c, c);
+            });
+
+            [
+                'self.when(:key_pressed) { bounce_if_on_edge }',
+                'self.when(:key_pressed, "space", 1) { bounce_if_on_edge }',
+                'self.when(:key_pressed, "invalid key") { bounce_if_on_edge }'
+            ].forEach(c => {
+                expect(converter.targetCodeToBlocks(target, c)).toBeTruthy();
+                const blockId = Object.keys(converter.blocks).filter(id => converter.blocks[id].topLevel)[0];
+                expect(converter.blocks[blockId].opcode).toEqual('ruby_statement_with_block');
+            });
+        });
+
+        test('error', () => {
+            code = `
+                forever do
+                  self.when(:key_pressed, "space") do
+                  end
+                end
+            `;
+            const res = converter.targetCodeToBlocks(target, code);
+            expect(converter.errors).toHaveLength(1);
+            expect(converter.errors[0].row).toEqual(2);
+            expect(res).toBeFalsy();
+        });
+    });
 });