Skip to content

Commit 4b2b6b2

Browse files
takaokoujitakaokouji
authored
Merge pull request #329 from smalruby/309-stop-self-when-2
feat: some extension blocks convert ruby to block #309
2 parents 2b8056c + 93f9cfb commit 4b2b6b2

16 files changed

+1278
-621
lines changed

‎src/lib/ruby-generator/microbit.js

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,10 @@ export default function (Generator) {
2323

2424
Generator.microbit_displaySymbol = function (block) {
2525
let matrix = Generator.valueToCode(block, 'MATRIX', Generator.ORDER_NONE) || null;
26-
matrix = Generator.prefixLines(matrix, Generator.INDENT);
27-
return `microbit.display(\n${matrix}\n)\n`;
26+
if (matrix.indexOf('\n') >= 0) {
27+
matrix = `\n${Generator.prefixLines(matrix, Generator.INDENT)}\n`;
28+
}
29+
return `microbit.display(${matrix})\n`;
2830
};
2931

3032
Generator.microbit_displayText = function (block) {

‎src/lib/ruby-generator/microbit_more.js

Lines changed: 90 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -6,163 +6,190 @@
66
export default function (Generator) {
77
Generator.microbitMore_whenButtonPressed = function (block) {
88
block.isStatement = true;
9-
const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || null;
10-
return `${Generator.spriteName()}.when(:mbit_more_button_pressed, ${btn}) do\n`;
9+
const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || Generator.quote_('A');
10+
return `microbit_more.when_button_pressed(${btn}) do\n`;
1111
};
1212

1313
Generator.microbitMore_isButtonPressed = function (block) {
14-
const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || null;
15-
return `mbit_more.button_pressed?(${btn})\n`;
14+
const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || Generator.quote_('A');
15+
return [`microbit_more.button_pressed?(${btn})`, Generator.ORDER_FUNCTION_CALL];
1616
};
1717

1818
Generator.microbitMore_whenGesture = function (block) {
1919
block.isStatement = true;
20-
const gesture = Generator.valueToCode(block, 'GESTURE', Generator.ORDER_NONE) || null;
21-
return `${Generator.spriteName()}.when(:mbit_more_gesture, ${gesture}) do\n`;
20+
const gesture = Generator.valueToCode(block, 'GESTURE', Generator.ORDER_NONE) || Generator.quote_('moved');
21+
return `microbit_more.when(${gesture}) do\n`;
2222
};
2323

24+
const makeMatrixArgs = function (matrix) {
25+
matrix = matrix.replace(/0/g, '.');
26+
matrix = matrix.match(/.{5}/g).map(s => Generator.quote_(s));
27+
return matrix.join(',\n');
28+
};
2429
Generator.microbitMore_displaySymbol = function (block) {
25-
let matrix = Generator.valueToCode(block, 'MATRIX', Generator.ORDER_NONE) || null;
26-
matrix = Generator.prefixLines(matrix, Generator.INDENT);
27-
return `mbit_more.display(\n${matrix}\n)\n`;
30+
let matrix = Generator.valueToCode(block, 'MATRIX', Generator.ORDER_NONE);
31+
if (!matrix) {
32+
matrix = makeMatrixArgs('0101010101100010101000100');
33+
}
34+
if (matrix.indexOf('\n') >= 0) {
35+
matrix = `\n${Generator.prefixLines(matrix, Generator.INDENT)}\n`;
36+
}
37+
return `microbit_more.display(${matrix})\n`;
2838
};
2939

3040
Generator.microbitMore_displayText = function (block) {
31-
const text = Generator.valueToCode(block, 'TEXT', Generator.ORDER_NONE) || null;
32-
return `mbit_more.display_text(${text})\n`;
41+
const text = Generator.valueToCode(block, 'TEXT', Generator.ORDER_NONE) || Generator.quote_('Hello!');
42+
return `microbit_more.display_text(${text})\n`;
3343
};
3444

3545
Generator.microbitMore_displayClear = function () {
36-
return `mbit_more.clear_display\n`;
46+
return `microbit_more.clear_display\n`;
3747
};
3848

3949
Generator.microbitMore_whenTilted = function (block) {
4050
block.isStatement = true;
4151
const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null;
42-
return `${Generator.spriteName()}.when(:mbit_more_tilted, ${direction}) do\n`;
52+
return `microbit_more.when_tilted(${direction}) do\n`;
4353
};
4454

4555
Generator.microbitMore_isTilted = function (block) {
4656
const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null;
47-
return [`mbit_more.tilted?(${direction})`, Generator.ORDER_ATOMIC];
57+
return [`microbit_more.tilted?(${direction})`, Generator.ORDER_ATOMIC];
4858
};
4959

5060
Generator.microbitMore_getTiltAngle = function (block) {
5161
const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null;
52-
return [`mbit_more.tilt_angle(${direction})`, Generator.ORDER_ATOMIC];
62+
return [`microbit_more.tilt_angle(${direction})`, Generator.ORDER_ATOMIC];
5363
};
5464

5565
Generator.microbitMore_whenPinConnected = function (block) {
5666
block.isStatement = true;
5767
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
58-
return `${Generator.spriteName()}.when(:mbit_more_pin_connected, ${pin}) do\n`;
68+
return `microbit_more.when_pin_connected(${pin}) do\n`;
5969
};
6070

6171
Generator.microbitMore_isPinConnected = function (block) {
6272
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
63-
return `mbit_more.pin_connected?(${pin})\n`;
73+
return [`microbit_more.pin_connected?(${pin})`, Generator.ORDER_FUNCTION_CALL];
6474
};
6575

6676
Generator.microbitMore_getLightLevel = function () {
67-
return `mbit_more.light_level\n`;
77+
return ['microbit_more.light_intensity', Generator.ORDER_FUNCTION_CALL];
6878
};
6979

7080
Generator.microbitMore_getTemperature = function () {
71-
return `mbit_more.temperature\n`;
81+
return ['microbit_more.temperature', Generator.ORDER_FUNCTION_CALL];
7282
};
7383

7484
Generator.microbitMore_getCompassHeading = function () {
75-
return `mbit_more.compass_heading\n`;
85+
return ['microbit_more.angle_with_the_north', Generator.ORDER_FUNCTION_CALL];
7686
};
7787

7888
Generator.microbitMore_getPitch = function () {
79-
return `mbit_more.pitch\n`;
89+
return ['microbit_more.pitch', Generator.ORDER_FUNCTION_CALL];
8090
};
8191

8292
Generator.microbitMore_getRoll = function () {
83-
return `mbit_more.roll\n`;
93+
return ['microbit_more.roll', Generator.ORDER_FUNCTION_CALL];
8494
};
8595

86-
Generator.microbitMore_getMagneticForce = function (block) {
87-
const axis = Generator.valueToCode(block, 'AXIS', Generator.ORDER_NONE) || null;
88-
return `mbit_more.get_magnetic_force(${axis})\n`;
96+
Generator.microbitMore_getMagneticForce = function () {
97+
return ['microbit_more.magnetic_force', Generator.ORDER_FUNCTION_CALL];
8998
};
9099

91100
Generator.microbitMore_getAcceleration = function (block) {
92101
const axis = Generator.valueToCode(block, 'AXIS', Generator.ORDER_NONE) || null;
93-
return `mbit_more.get_acceleration(${axis})\n`;
102+
return [`microbit_more.acceleration(${axis})`, Generator.ORDER_FUNCTION_CALL];
94103
};
95104

96105
Generator.microbitMore_getAnalogValue = function (block) {
97106
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
98-
return `mbit_more.get_analog_value(${pin})\n`;
107+
return [`microbit_more.analog_value_of_pin(${pin})`, Generator.ORDER_FUNCTION_CALL];
99108
};
100109

101110
Generator.microbitMore_getDigitalValue = function (block) {
102111
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
103-
return `mbit_more.get_digital_value(${pin})\n`;
112+
return [`microbit_more.digital_value_of_pin(${pin})`, Generator.ORDER_FUNCTION_CALL];
104113
};
105114

115+
const PinModeLabel = {
116+
pullNone: 'none',
117+
pullUp: 'up',
118+
pullDown: 'down'
119+
};
106120
Generator.microbitMore_setPinMode = function (block) {
107-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
108-
const mode = Generator.quote_(Generator.getFieldValue(block, 'MODE')) || null;
109-
return `mbit_more.set_pin_mode(${pin}, ${mode})\n`;
121+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
122+
const mode = Generator.getFieldValue(block, 'MODE') || 'pullUp';
123+
const modeLabel = Generator.quote_(PinModeLabel[mode]);
124+
return `microbit_more.set_pin_to_input_pull(${pin}, ${modeLabel})\n`;
110125
};
111126

112127
Generator.microbitMore_setOutput = function (block) {
113-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
114-
const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || null;
115-
return `mbit_more.set_output(${pin}, ${level})\n`;
128+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
129+
const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || 0;
130+
return `microbit_more.set_digital(${pin}, ${level})\n`;
116131
};
117132

118133
Generator.microbitMore_setPWM = function (block) {
119-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
120-
const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || null;
121-
return `mbit_more.set_pwm(${pin}, ${level})\n`;
134+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
135+
const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || 0;
136+
return `microbit_more.set_pwm(${pin}, ${level})\n`;
122137
};
123138

124139
Generator.microbitMore_setServo = function (block) {
125-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
126-
const angle = Generator.valueToCode(block, 'ANGLE', Generator.ORDER_NONE) || null;
127-
const range = Generator.valueToCode(block, 'RANGE', Generator.ORDER_NONE) || 2000;
128-
const center = Generator.valueToCode(block, 'CENTER', Generator.ORDER_NONE) || 1500;
129-
return `mbit_more.set_servo(${pin}, ${angle}, ${range}, ${center})\n`;
140+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
141+
const angle = Generator.valueToCode(block, 'ANGLE', Generator.ORDER_NONE) || 0;
142+
return `microbit_more.set_servo(${pin}, ${angle})\n`;
130143
};
131144

145+
const EventTypeLabel = {
146+
0: 'none',
147+
1: 'edge',
148+
2: 'pulse'
149+
};
132150
Generator.microbitMore_setPinEventType = function (block) {
133-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
134-
const eventType = Generator.getFieldValue(block, 'EVENT_TYPE') || null;
135-
return `mbit_more.set_pin_event_type(${pin}, ${eventType})\n`;
151+
const eventType = Generator.getFieldValue(block, 'EVENT_TYPE') || 0;
152+
const eventTypeLabel = Generator.quote_(EventTypeLabel[eventType]);
153+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
154+
return `microbit_more.catch_event_on(${eventTypeLabel}, ${pin})\n`;
136155
};
137156

157+
const EventLabel = {
158+
5: 'low pulse',
159+
4: 'high pulse',
160+
3: 'fall',
161+
2: 'rise'
162+
};
138163
Generator.microbitMore_whenPinEvent = function (block) {
139164
block.isStatement = true;
140-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
141-
const event = Generator.getFieldValue(block, 'EVENT') || null;
142-
return `${Generator.spriteName()}.when(:mbit_more_pin_event, ${pin}, ${event}) do\n`;
165+
const event = Generator.getFieldValue(block, 'EVENT') || 5;
166+
const eventLabel = Generator.quote_(EventLabel[event]);
167+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
168+
return `microbit_more.when_catch_at_pin(${eventLabel}, ${pin}) do\n`;
143169
};
144170

145171
Generator.microbitMore_getPinEventTimestamp = function (block) {
146-
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null;
147-
const event = Generator.getFieldValue(block, 'EVENT') || null;
148-
return `mbit_more.get_pin_event_timestamp(${pin}, ${event})\n`;
172+
const event = Generator.getFieldValue(block, 'EVENT') || 5;
173+
const eventLabel = Generator.quote_(EventLabel[event]);
174+
const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0;
175+
return `microbit_more.timestamp_of(${eventLabel}, ${pin})\n`;
149176
};
150177

151178
Generator.microbitMore_getSharedData = function (block) {
152-
const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || null;
153-
return `mbit_more.get_shared_data(${index})\n`;
179+
const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || 0;
180+
return [`microbit_more.shared_data[${index}]`, Generator.ORDER_FUNCTION_CALL];
154181
};
155182

156183
Generator.microbitMore_setSharedData = function (block) {
157-
const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || null;
158-
const value = Generator.valueToCode(block, 'VALUE', Generator.ORDER_NONE) || null;
159-
return `mbit_more.set_shared_data(${index}, ${value})\n`;
184+
const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || 0;
185+
const value = Generator.valueToCode(block, 'VALUE', Generator.ORDER_NONE) || 0;
186+
return `microbit_more.shared_data[${index}] = ${value}\n`;
160187
};
161188

162189
Generator.microbitMore_whenConnectionChanged = function (block) {
163190
block.isStatement = true;
164-
const state = Generator.getFieldValue(block, 'STATE') || null;
165-
return `${Generator.spriteName()}.when(:mbit_more_connection_changed, ${state}) do\n`;
191+
const state = Generator.quote_(Generator.getFieldValue(block, 'STATE') || 'connected');
192+
return `microbit_more.when_microbit(${state}) do\n`;
166193
};
167194

168195
Generator.microbitMore_menu_buttons = function (block) {
@@ -196,7 +223,7 @@ export default function (Generator) {
196223
};
197224

198225
Generator.microbitMore_menu_axis = function (block) {
199-
const axis = Generator.quote_(Generator.getFieldValue(block, 'axis') || 'absolute');
226+
const axis = Generator.quote_(Generator.getFieldValue(block, 'axis') || 'x');
200227
return [axis, Generator.ORDER_ATOMIC];
201228
};
202229

@@ -205,42 +232,19 @@ export default function (Generator) {
205232
return [analogIn, Generator.ORDER_ATOMIC];
206233
};
207234

208-
Generator.microbitMore_menu_pinMode = function (block) {
209-
const pinMode = Generator.quote_(Generator.getFieldValue(block, 'pinMode') || 'pullUp');
210-
return [pinMode, Generator.ORDER_ATOMIC];
211-
};
212-
213235
Generator.microbitMore_menu_digitalValue = function (block) {
214236
const digitalValue = Generator.getFieldValue(block, 'digitalValue') || 0;
215237
return [digitalValue, Generator.ORDER_ATOMIC];
216238
};
217239

218-
Generator.microbitMore_menu_pinEventTypeMenu = function (block) {
219-
const pinEventTypeMenu = Generator.getFieldValue(block, 'pinEventTypeMenu') || 0;
220-
return [pinEventTypeMenu, Generator.ORDER_ATOMIC];
221-
};
222-
223-
Generator.microbitMore_menu_pinEventTimestampMenu = function (block) {
224-
const pinEventTimestampMenu = Generator.getFieldValue(block, 'pinEventTimestampMenu') || 5;
225-
return [pinEventTimestampMenu, Generator.ORDER_ATOMIC];
226-
};
227-
228240
Generator.microbitMore_menu_sharedDataIndex = function (block) {
229-
const sharedDataIndex = Generator.quote_(Generator.getFieldValue(block, 'sharedDataIndex') || 'absolute');
230-
return [sharedDataIndex, Generator.ORDER_ATOMIC];
231-
};
232-
233-
Generator.microbitMore_menu_connectionStateMenu = function (block) {
234-
const connectionStateMenu =
235-
Generator.quote_(Generator.getFieldValue(block, 'connectionStateMenu') || 'connected');
236-
return [connectionStateMenu, Generator.ORDER_ATOMIC];
241+
const index = Generator.getFieldValue(block, 'sharedDataIndex') || 0;
242+
return [index, Generator.ORDER_ATOMIC];
237243
};
238244

239245
Generator.matrix = function (block) {
240-
let matrix = Generator.getFieldValue(block, 'MATRIX') || '0000000000000000000000000';
241-
matrix = matrix.replace(/0/g, '.');
242-
matrix = matrix.match(/.{5}/g).map(s => Generator.quote_(s));
243-
return [matrix.join(',\n'), Generator.ORDER_ATOMIC];
246+
const matrix = Generator.getFieldValue(block, 'MATRIX') || '0000000000000000000000000';
247+
return [makeMatrixArgs(matrix), Generator.ORDER_ATOMIC];
244248
};
245249

246250
return Generator;

‎src/lib/ruby-generator/text2speech.js

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,12 @@
66
export default function (Generator) {
77
Generator.text2speech_speakAndWait = function (block) {
88
const words = Generator.valueToCode(block, 'WORDS', Generator.ORDER_NONE) || null;
9-
return `text2speech_speak(${words})\n`;
9+
return `text2speech.speak(${words})\n`;
1010
};
1111

1212
Generator.text2speech_setVoice = function (block) {
1313
const voice = Generator.valueToCode(block, 'VOICE', Generator.ORDER_NONE);
14-
return `self.text2speech_voice = ${voice}\n`;
14+
return `text2speech.voice = ${voice}\n`;
1515
};
1616

1717
Generator.text2speech_menu_voices = function (block) {
@@ -21,7 +21,7 @@ export default function (Generator) {
2121

2222
Generator.text2speech_setLanguage = function (block) {
2323
const language = Generator.valueToCode(block, 'LANGUAGE', Generator.ORDER_NONE);
24-
return `self.text2speech_language = ${language}\n`;
24+
return `text2speech.language = ${language}\n`;
2525
};
2626

2727
Generator.text2speech_menu_languages = function (block) {

0 commit comments

Comments
 (0)