looks_say

src/lib/ruby-generator/looks.js

@@ -7,23 +7,23 @@ export default function (Generator) {
     Generator.looks_sayforsecs = function (block) {
         const message = Generator.valueToCode(block, 'MESSAGE', Generator.ORDER_NONE) || Generator.quote_('');
         const secs = Generator.valueToCode(block, 'SECS', Generator.ORDER_NONE) || '0';
-        return `say(message: ${message}, second: ${secs})\n`;
+        return `say(${message}, ${secs})\n`;
     };
 
     Generator.looks_say = function (block) {
         const message = Generator.valueToCode(block, 'MESSAGE', Generator.ORDER_NONE) || Generator.quote_('');
-        return `say(message: ${message})\n`;
+        return `say(${message})\n`;
     };
 
     Generator.looks_thinkforsecs = function (block) {
         const message = Generator.valueToCode(block, 'MESSAGE', Generator.ORDER_NONE) || Generator.quote_('');
         const secs = Generator.valueToCode(block, 'SECS', Generator.ORDER_NONE) || '0';
-        return `think(message: ${message}, second: ${secs})\n`;
+        return `think(${message}, ${secs})\n`;
     };
 
     Generator.looks_think = function (block) {
         const message = Generator.valueToCode(block, 'MESSAGE', Generator.ORDER_NONE) || Generator.quote_('');
-        return `think(message: ${message})\n`;
+        return `think(${message})\n`;
     };
 
     Generator.looks_switchcostumeto = function (block) {

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

@@ -5,6 +5,7 @@ import Blockly from 'scratch-blocks';
 import RubyParser from '../ruby-parser';
 import Variable from 'scratch-vm/src/engine/variable';
 
+import LooksConverter from './looks';
 import ControlConverter from './control';
 
 /**
@@ -29,6 +30,7 @@ class RubyToBlocksConverter {
     constructor (vm) {
         this.vm = vm;
         this._converters = [
+            LooksConverter,
             ControlConverter
         ];
         this.reset();
@@ -534,6 +536,10 @@ class RubyToBlocksConverter {
         return _.isString(stringOrBlock) || this._isValueBlock(stringOrBlock);
     }
 
+    _isNumberOrStringOrBlock (block) {
+        return _.isNumber(block) || _.isString(block) || this._isValueBlock(block);
+    }
+
     _changeToBooleanArgument (varName) {
         varName = varName.toString();
         const variable = this._context.localVariables[varName];

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

@@ -0,0 +1,25 @@
+/* global Opal */
+import _ from 'lodash';
+
+/**
+ * Looks converter
+ */
+const LooksConverter = {
+    // 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 'say':
+                if (args.length === 1 && this._isNumberOrStringOrBlock(args[0])) {
+                    block = this._createBlock('looks_say', 'statement');
+                    this._addTextInput(block, 'MESSAGE', _.isNumber(args[0]) ? args[0].toString() : args[0], 'Hello!');
+                }
+                break;
+            }
+        }
+        return block;
+    }
+};
+
+export default LooksConverter;

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

@@ -0,0 +1,83 @@
+import RubyToBlocksConverter from '../../../../src/lib/ruby-to-blocks-converter';
+import {
+    convertAndExpectToEqualBlocks,
+    convertAndExpectToEqualRubyStatement,
+    rubyToExpected,
+    expectedInfo
+} from '../../../helpers/expect-to-equal-blocks';
+
+describe('RubyToBlocksConverter/Looks', () => {
+    let converter;
+    let target;
+    let code;
+    let expected;
+
+    beforeEach(() => {
+        converter = new RubyToBlocksConverter(null);
+        target = null;
+        code = null;
+        expected = null;
+    });
+
+    describe('looks_say', () => {
+        test('string', () => {
+            code = 'say("Hello!")';
+            expected = [
+                {
+                    opcode: 'looks_say',
+                    inputs: [
+                        {
+                            name: 'MESSAGE',
+                            block: expectedInfo.makeText('Hello!')
+                        }
+                    ]
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('number', () => {
+            code = 'say(1)';
+            expected = [
+                {
+                    opcode: 'looks_say',
+                    inputs: [
+                        {
+                            name: 'MESSAGE',
+                            block: expectedInfo.makeText('1')
+                        }
+                    ]
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('block', () => {
+            code = 'say(x)';
+            expected = [
+                {
+                    opcode: 'looks_say',
+                    inputs: [
+                        {
+                            name: 'MESSAGE',
+                            block: rubyToExpected(converter, target, 'x')[0],
+                            shadow: expectedInfo.makeText('Hello!')
+                        }
+                    ]
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('invalid', () => {
+            [
+                'say',
+                'say(false)',
+                'say(true)',
+                'say(1, 2, 1)'
+            ].forEach(c => {
+                convertAndExpectToEqualRubyStatement(converter, target, c, c);
+            });
+        });
+    });
+});