diff --git a/.circleci/config.yml b/.circleci/config.yml index 0946e0bd968..1e1d59ee868 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -167,7 +167,7 @@ jobs: path: dist integration: <<: *defaults - parallelism: 1 + parallelism: 2 environment: JEST_JUNIT_OUTPUT_NAME: results.txt steps: @@ -201,6 +201,19 @@ jobs: - run: npm run deploy -- -x -r https://${GH_TOKEN}@github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME.git - run: npm run deploy:smalruby.app -- -x -r https://${GH_TOKEN}@github.com/$CIRCLE_PROJECT_USERNAME/smalruby.app.git + deploy-gh-pages-branch: + <<: *defaults + steps: + - *restore_git_cache + - checkout + - *restore_npm_cache + - *restore_build_cache + - run: | + git config --global user.email $(git log --pretty=format:"%ae" -n1) + git config --global user.name $(git log --pretty=format:"%an" -n1) + - run: npm run deploy -- -x -r https://${GH_TOKEN}@github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME.git -e $CIRCLE_BRANCH + - run: npm run deploy:smalruby.app -- -x -r https://${GH_TOKEN}@github.com/$CIRCLE_PROJECT_USERNAME/smalruby.app.git -e $CIRCLE_BRANCH + workflows: version: 2 commitlint: @@ -236,7 +249,6 @@ workflows: only: - master - develop - - beta - /^hotfix\/.*/ - lint: context: @@ -268,7 +280,6 @@ workflows: only: - master - develop - - beta - /^hotfix\/.*/ - store_dist: context: @@ -280,7 +291,6 @@ workflows: only: - master - develop - - beta - /^hotfix\/.*/ - deploy-gh-pages: context: @@ -290,6 +300,53 @@ workflows: - unit - integration - build + filters: + branches: + ignore: + - beta + - /^dependabot/.*/ + - /^renovate/.*/ + - /^pull/.*/ # don't deploy to gh pages on PRs. + build-deploy-beta: + jobs: + - setup: + context: + - dockerhub-credentials + filters: + branches: + only: + - beta + - /^v[0-9]+\.[0-9]+\.[0-9]+$/ + - build: + context: + - dockerhub-credentials + requires: + - setup + - store_build: + context: + - dockerhub-credentials + requires: + - build + filters: + branches: + only: + - beta + - /^v[0-9]+\.[0-9]+\.[0-9]+$/ + - store_dist: + context: + - dockerhub-credentials + requires: + - build + filters: + branches: + only: + - beta + - /^v[0-9]+\.[0-9]+\.[0-9]+$/ + - deploy-gh-pages-branch: + context: + - dockerhub-credentials + requires: + - build filters: branches: ignore: diff --git a/LEGAL b/LEGAL index d4a6bb66460..8cd288fd0c6 100644 --- a/LEGAL +++ b/LEGAL @@ -54,10 +54,14 @@ opal/opal-parser.min.js These files are licensed under the MIT License (see https://github.com/opal/opal/blob/master/LICENSE ). -src/lib/libraries/extensions/microbit_more/microbitMore.png -src/lib/libraries/extensions/microbit_more/microbitMore-illustration.svg -src/lib/libraries/extensions/microbit_more/microbitMore-small.svg +src/lib/libraries/extensions/microbitMore/connection-icon.svg +src/lib/libraries/extensions/microbitMore/connection-small-icon.svg +src/lib/libraries/extensions/microbitMore/entry-icon.png +src/lib/libraries/extensions/microbitMore/index.jsx +src/lib/libraries/extensions/microbitMore/inset-icon.svg +src/lib/libraries/extensions/microbitMore/mbit-more-v2-board.afdesign +src/lib/libraries/extensions/microbitMore/mbit-more-v2-entry-icon.afdesign +src/lib/libraries/extensions/microbitMore/translations.json These files are licensed under the MIT License - (see https://github.com/yokobond/scratch-microbit-more/blob/master/LICENSE ). - + (see https://github.com/microbit-more/mbit-more-v2/blob/master/LICENSE ). diff --git a/package-lock.json b/package-lock.json index 5b441523ea0..a0b785b4ec7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "smalruby3-gui", - "version": "1.0.2", + "version": "2.0.0", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -19532,7 +19532,7 @@ "integrity": "sha512-r0lvpgQjPMjbhI2wROrgoXzBhCvWJdkbAqJMfl2CdNqrwBpUXqLvNNtI3VtNLPJAcp9VfxEylkU9lVZ0gvU46Q==" }, "scratch-vm": { - "version": "github:smalruby/scratch-vm#4972aa73f139b7e1ab157be591ac05a60a9c91ac", + "version": "github:smalruby/scratch-vm#72fa95c5d1f77259ed3494379535bbbf98adb5ec", "from": "github:smalruby/scratch-vm#develop", "requires": { "@vernier/godirect": "1.5.0", diff --git a/package.json b/package.json index 977be632288..51d7eed97df 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "smalruby3-gui", - "version": "1.0.2", + "version": "2.0.0", "description": "GraphicaL User Interface for creating and running Smalruby 3.0 projects", "author": "Ruby Programming Shounendan", "license": "BSD-3-Clause", diff --git a/src/containers/extension-library.jsx b/src/containers/extension-library.jsx index b46d992c0ab..aaa70789d6e 100644 --- a/src/containers/extension-library.jsx +++ b/src/containers/extension-library.jsx @@ -25,6 +25,17 @@ const messages = defineMessages({ class ExtensionLibrary extends React.PureComponent { constructor (props) { super(props); + extensionLibraryContent.forEach(extension => { + if (extension.setFormatMessage) { + extension.setFormatMessage(this.props.intl.formatMessage); + } + if (extension.translationMap) { + Object.assign( + this.props.intl.messages, + extension.translationMap[this.props.intl.locale] + ); + } + }); bindAll(this, [ 'handleItemSelect' ]); diff --git a/src/lib/generator.js b/src/lib/generator.js index 58d8f66c04c..082cf27723d 100644 --- a/src/lib/generator.js +++ b/src/lib/generator.js @@ -582,8 +582,9 @@ class Generator { return this.getField(block, name).id; } - getFieldValue (block, name) { - return this.getField(block, name).value; + getFieldValue (block, name, defaultValue = null) { + const field = this.getField(block, name); + return field ? field.value : defaultValue; } isConnectedValue (block) { diff --git a/src/lib/libraries/extensions/index.jsx b/src/lib/libraries/extensions/index.jsx index 963a95b3db2..8b05eb7672a 100644 --- a/src/lib/libraries/extensions/index.jsx +++ b/src/lib/libraries/extensions/index.jsx @@ -400,7 +400,7 @@ const extensions = [ ]; // Injected for extra extensions -import microbitMore from './microbitMore/entry.jsx'; +import microbitMore from './microbitMore/index.jsx'; extensions.push(microbitMore); export default extensions; diff --git a/src/lib/libraries/extensions/microbitMore/connection-icon.svg b/src/lib/libraries/extensions/microbitMore/connection-icon.svg new file mode 100644 index 00000000000..860ad01d88c --- /dev/null +++ b/src/lib/libraries/extensions/microbitMore/connection-icon.svg @@ -0,0 +1,7276 @@ + +image/svg+xml diff --git a/src/lib/libraries/extensions/microbitMore/connection-small-icon.svg b/src/lib/libraries/extensions/microbitMore/connection-small-icon.svg new file mode 100644 index 00000000000..db550968de3 --- /dev/null +++ b/src/lib/libraries/extensions/microbitMore/connection-small-icon.svg @@ -0,0 +1,6947 @@ + +image/svg+xml diff --git a/src/lib/libraries/extensions/microbitMore/entry-icon.png b/src/lib/libraries/extensions/microbitMore/entry-icon.png new file mode 100644 index 00000000000..83c7ef92d01 Binary files /dev/null and b/src/lib/libraries/extensions/microbitMore/entry-icon.png differ diff --git a/src/lib/libraries/extensions/microbitMore/entry.jsx b/src/lib/libraries/extensions/microbitMore/entry.jsx deleted file mode 100644 index d0ee6bea647..00000000000 --- a/src/lib/libraries/extensions/microbitMore/entry.jsx +++ /dev/null @@ -1,38 +0,0 @@ -import React from 'react'; -import {FormattedMessage} from 'react-intl'; - -import microbitMoreIconURL from './microbitMore.png'; -import microbitMoreInsetIconURL from './microbitMore-small.svg'; -import microbitMoreConnectionIconURL from './microbitMore-illustration.svg'; -import microbitMoreConnectionSmallIconURL from './microbitMore-small.svg'; - -export default { - name: 'micro:bit MORE v0.4.3', - extensionId: 'microbitMore', - collaborator: 'Yengawa Lab', - iconURL: microbitMoreIconURL, - insetIconURL: microbitMoreInsetIconURL, - description: ( - - ), - featured: true, - disabled: false, - bluetoothRequired: true, - internetConnectionRequired: false, - launchPeripheralConnectionFlow: true, - useAutoScan: false, - connectionIconURL: microbitMoreConnectionIconURL, - connectionSmallIconURL: microbitMoreConnectionSmallIconURL, - connectingMessage: ( - - ), - helpLink: 'https://lab.yengawa.com/project/scratch-microbit-more/' -}; diff --git a/src/lib/libraries/extensions/microbitMore/index.jsx b/src/lib/libraries/extensions/microbitMore/index.jsx new file mode 100644 index 00000000000..850667d955a --- /dev/null +++ b/src/lib/libraries/extensions/microbitMore/index.jsx @@ -0,0 +1,57 @@ +let formatMessage = messageData => messageData.defaultMessage; + +/** + * MicroBit More extension + */ + +import microbitMoreIconURL from './entry-icon.png'; +import microbitMoreInsetIconURL from './inset-icon.svg'; +import microbitMoreConnectionIconURL from './connection-icon.svg'; +import microbitMoreConnectionSmallIconURL from './connection-small-icon.svg'; +import translations from './translations.json'; + +const version = 'v2-0.2.5'; + +const entry = { + get name () { + return `${formatMessage({ + defaultMessage: 'MicroBit More', + description: 'Name of this extension', + id: 'mbitMore.entry.name' + })} (${version})`; + }, + extensionId: 'microbitMore', + collaborator: 'Yengawa Lab', + iconURL: microbitMoreIconURL, + insetIconURL: microbitMoreInsetIconURL, + get description () { + return formatMessage({ + defaultMessage: 'Play with all functions of micro:bit.', + description: "Description for the 'Microbit More' extension", + id: 'mbitMore.entry.description' + }); + }, + featured: true, + disabled: false, + bluetoothRequired: true, + internetConnectionRequired: false, + launchPeripheralConnectionFlow: true, + useAutoScan: false, + connectionIconURL: microbitMoreConnectionIconURL, + connectionSmallIconURL: microbitMoreConnectionSmallIconURL, + get connectingMessage () { + return formatMessage({ + defaultMessage: 'Connecting', + description: 'Message to help people connect to their micro:bit.', + id: 'gui.extension.microbit.connectingMessage' + }); + }, + helpLink: 'https://microbit-more.github.io/', + setFormatMessage: formatter => { + formatMessage = formatter; + }, + translationMap: translations +}; + +export {entry}; // loadable-extension needs this line. +export default entry; diff --git a/src/lib/libraries/extensions/microbitMore/inset-icon.svg b/src/lib/libraries/extensions/microbitMore/inset-icon.svg new file mode 100644 index 00000000000..2372fcac6ef --- /dev/null +++ b/src/lib/libraries/extensions/microbitMore/inset-icon.svg @@ -0,0 +1,1802 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/lib/libraries/extensions/microbitMore/mbit-more-v2-board.afdesign b/src/lib/libraries/extensions/microbitMore/mbit-more-v2-board.afdesign new file mode 100644 index 00000000000..721aee8e01e Binary files /dev/null and b/src/lib/libraries/extensions/microbitMore/mbit-more-v2-board.afdesign differ diff --git a/src/lib/libraries/extensions/microbitMore/mbit-more-v2-entry-icon.afdesign b/src/lib/libraries/extensions/microbitMore/mbit-more-v2-entry-icon.afdesign new file mode 100644 index 00000000000..30b5eedd5b6 Binary files /dev/null and b/src/lib/libraries/extensions/microbitMore/mbit-more-v2-entry-icon.afdesign differ diff --git a/src/lib/libraries/extensions/microbitMore/microbitMore-block.png b/src/lib/libraries/extensions/microbitMore/microbitMore-block.png deleted file mode 100644 index b4c3421f55b..00000000000 Binary files a/src/lib/libraries/extensions/microbitMore/microbitMore-block.png and /dev/null differ diff --git a/src/lib/libraries/extensions/microbitMore/microbitMore-illustration.svg b/src/lib/libraries/extensions/microbitMore/microbitMore-illustration.svg deleted file mode 100644 index 3b984106c13..00000000000 --- a/src/lib/libraries/extensions/microbitMore/microbitMore-illustration.svg +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/lib/libraries/extensions/microbitMore/microbitMore-small.svg b/src/lib/libraries/extensions/microbitMore/microbitMore-small.svg deleted file mode 100644 index f675c8fd9ad..00000000000 --- a/src/lib/libraries/extensions/microbitMore/microbitMore-small.svg +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/lib/libraries/extensions/microbitMore/microbitMore.png b/src/lib/libraries/extensions/microbitMore/microbitMore.png deleted file mode 100644 index 6d5cf028b4e..00000000000 Binary files a/src/lib/libraries/extensions/microbitMore/microbitMore.png and /dev/null differ diff --git a/src/lib/libraries/extensions/microbitMore/translations.json b/src/lib/libraries/extensions/microbitMore/translations.json new file mode 100644 index 00000000000..41ede5088f9 --- /dev/null +++ b/src/lib/libraries/extensions/microbitMore/translations.json @@ -0,0 +1,18 @@ +{ + "de": { + "mbitMore.entry.name": "MicroBit More", + "mbitMore.entry.description": "Nutze alle Funktionen des micro:bit." + }, + "en": { + "mbitMore.entry.name": "MicroBit More", + "mbitMore.entry.description": "Play with all functions of micro:bit." + }, + "ja": { + "mbitMore.entry.name": "MicroBit More", + "mbitMore.entry.description": "micro:bitのすべての機能で遊ぶ。" + }, + "ja-Hira": { + "mbitMore.entry.name": "マイクロビット モア", + "mbitMore.entry.description": "マイクロビットのすべてのきのうであそぶ。" + } +} diff --git a/src/lib/project-fetcher-hoc.jsx b/src/lib/project-fetcher-hoc.jsx index 0a205ed691a..c2d7d8c3605 100644 --- a/src/lib/project-fetcher-hoc.jsx +++ b/src/lib/project-fetcher-hoc.jsx @@ -73,7 +73,7 @@ const ProjectFetcherHOC = function (WrappedComponent) { } } fetchProject (projectId, loadingState) { - if (!this.props.projectToken) { + if (projectId !== '0' && !this.props.projectToken) { const errorHandler = err => { this.props.onError(err); log.error(err); diff --git a/src/lib/ruby-generator/microbit_more.js b/src/lib/ruby-generator/microbit_more.js index 069cd92fb15..767275e8579 100644 --- a/src/lib/ruby-generator/microbit_more.js +++ b/src/lib/ruby-generator/microbit_more.js @@ -1,24 +1,63 @@ /** - * Define Ruby code generator for micro:bit MORE Blocks + * Define Ruby code generator for Microbit More Blocks * @param {RubyGenerator} Generator The RubyGenerator * @return {RubyGenerator} same as param. */ export default function (Generator) { - Generator.microbitMore_whenButtonPressed = function (block) { + Generator.microbitMore_whenConnectionChanged = function (block) { + block.isStatement = true; + const state = Generator.quote_(Generator.getFieldValue(block, 'STATE', 'connected')); + return `microbit_more.when_microbit(${state}) do\n`; + }; + + Generator.microbitMore_whenButtonEvent = function (block) { block.isStatement = true; - const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || Generator.quote_('A'); - return `microbit_more.when_button_pressed(${btn}) do\n`; + const name = Generator.quote_(Generator.getFieldValue(block, 'NAME', 'A')); + const event = Generator.quote_(Generator.getFieldValue(block, 'EVENT', 'down').toLowerCase()); + return `microbit_more.when_button_is(${name}, ${event}) do\n`; }; Generator.microbitMore_isButtonPressed = function (block) { - const btn = Generator.valueToCode(block, 'BTN', Generator.ORDER_NONE) || Generator.quote_('A'); - return [`microbit_more.button_pressed?(${btn})`, Generator.ORDER_FUNCTION_CALL]; + const name = Generator.quote_(Generator.getFieldValue(block, 'NAME', 'A')); + return [`microbit_more.button_pressed?(${name})`, Generator.ORDER_FUNCTION_CALL]; }; + const TouchEventLabel = { + DOWN: 'touched', + UP: 'released', + CLICK: 'tapped' + }; + Generator.microbitMore_whenTouchEvent = function (block) { + block.isStatement = true; + const name = Generator.quote_(Generator.getFieldValue(block, 'NAME', 'LOGO')); + const event = Generator.getFieldValue(block, 'EVENT', 'DOWN'); + const eventLabel = Generator.quote_(TouchEventLabel[event]); + return `microbit_more.when_pin_is(${name}, ${eventLabel}) do\n`; + }; + + Generator.microbitMore_isPinTouched = function (block) { + const name = Generator.quote_(Generator.getFieldValue(block, 'NAME', 'LOGO')); + return [`microbit_more.pin_is_touched?(${name})`, Generator.ORDER_FUNCTION_CALL]; + }; + + const GestureLabel = { + TILT_UP: 'tilt up', + TILT_DOWN: 'tilt down', + TILT_LEFT: 'tilt left', + TILT_RIGHT: 'tilt right', + FACE_UP: 'face up', + FACE_DOWN: 'face down', + FREEFALL: 'freefall', + G3: '3G', + G6: '6G', + G8: '8G', + SHAKE: 'shake' + }; Generator.microbitMore_whenGesture = function (block) { block.isStatement = true; - const gesture = Generator.valueToCode(block, 'GESTURE', Generator.ORDER_NONE) || Generator.quote_('moved'); - return `microbit_more.when(${gesture}) do\n`; + const gesture = Generator.getFieldValue(block, 'GESTURE', 'SHAKE'); + const gestureLabel = Generator.quote_(GestureLabel[gesture]); + return `microbit_more.when(${gestureLabel}) do\n`; }; const makeMatrixArgs = function (matrix) { @@ -26,7 +65,7 @@ export default function (Generator) { matrix = matrix.match(/.{5}/g).map(s => Generator.quote_(s)); return matrix.join(',\n'); }; - Generator.microbitMore_displaySymbol = function (block) { + Generator.microbitMore_displayMatrix = function (block) { let matrix = Generator.valueToCode(block, 'MATRIX', Generator.ORDER_NONE); if (!matrix) { matrix = makeMatrixArgs('0101010101100010101000100'); @@ -34,45 +73,19 @@ export default function (Generator) { if (matrix.indexOf('\n') >= 0) { matrix = `\n${Generator.prefixLines(matrix, Generator.INDENT)}\n`; } - return `microbit_more.display(${matrix})\n`; + return `microbit_more.display_pattern(${matrix})\n`; }; Generator.microbitMore_displayText = function (block) { const text = Generator.valueToCode(block, 'TEXT', Generator.ORDER_NONE) || Generator.quote_('Hello!'); - return `microbit_more.display_text(${text})\n`; + const delay = Generator.valueToCode(block, 'DELAY', Generator.ORDER_NONE) || 120; + return `microbit_more.display_text_delay(${text}, ${delay})\n`; }; Generator.microbitMore_displayClear = function () { return `microbit_more.clear_display\n`; }; - Generator.microbitMore_whenTilted = function (block) { - block.isStatement = true; - const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null; - return `microbit_more.when_tilted(${direction}) do\n`; - }; - - Generator.microbitMore_isTilted = function (block) { - const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null; - return [`microbit_more.tilted?(${direction})`, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_getTiltAngle = function (block) { - const direction = Generator.valueToCode(block, 'DIRECTION', Generator.ORDER_NONE) || null; - return [`microbit_more.tilt_angle(${direction})`, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_whenPinConnected = function (block) { - block.isStatement = true; - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null; - return `microbit_more.when_pin_connected(${pin}) do\n`; - }; - - Generator.microbitMore_isPinConnected = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null; - return [`microbit_more.pin_connected?(${pin})`, Generator.ORDER_FUNCTION_CALL]; - }; - Generator.microbitMore_getLightLevel = function () { return ['microbit_more.light_intensity', Generator.ORDER_FUNCTION_CALL]; }; @@ -82,7 +95,7 @@ export default function (Generator) { }; Generator.microbitMore_getCompassHeading = function () { - return ['microbit_more.angle_with_the_north', Generator.ORDER_FUNCTION_CALL]; + return ['microbit_more.angle_with_north', Generator.ORDER_FUNCTION_CALL]; }; Generator.microbitMore_getPitch = function () { @@ -93,153 +106,117 @@ export default function (Generator) { return ['microbit_more.roll', Generator.ORDER_FUNCTION_CALL]; }; + Generator.microbitMore_getSoundLevel = function () { + return ['microbit_more.sound_level', Generator.ORDER_FUNCTION_CALL]; + }; + Generator.microbitMore_getMagneticForce = function () { return ['microbit_more.magnetic_force', Generator.ORDER_FUNCTION_CALL]; }; Generator.microbitMore_getAcceleration = function (block) { - const axis = Generator.valueToCode(block, 'AXIS', Generator.ORDER_NONE) || null; + const axis = Generator.quote_(Generator.getFieldValue(block, 'AXIS', 'x')); return [`microbit_more.acceleration(${axis})`, Generator.ORDER_FUNCTION_CALL]; }; Generator.microbitMore_getAnalogValue = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null; - return [`microbit_more.analog_value_of_pin(${pin})`, Generator.ORDER_FUNCTION_CALL]; + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + return [`microbit_more.analog_value(${pin})`, Generator.ORDER_FUNCTION_CALL]; }; - Generator.microbitMore_getDigitalValue = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || null; - return [`microbit_more.digital_value_of_pin(${pin})`, Generator.ORDER_FUNCTION_CALL]; + Generator.microbitMore_setPullMode = function (block) { + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + const mode = Generator.quote_(Generator.getFieldValue(block, 'MODE', 'up').toLowerCase()); + return `microbit_more.set_pin_to_input_pull(${pin}, ${mode})\n`; }; - const PinModeLabel = { - pullNone: 'none', - pullUp: 'up', - pullDown: 'down' - }; - Generator.microbitMore_setPinMode = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; - const mode = Generator.getFieldValue(block, 'MODE') || 'pullUp'; - const modeLabel = Generator.quote_(PinModeLabel[mode]); - return `microbit_more.set_pin_to_input_pull(${pin}, ${modeLabel})\n`; + Generator.microbitMore_isPinHigh = function (block) { + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + return [`microbit_more.is_pin_high?(${pin})`, Generator.ORDER_FUNCTION_CALL]; }; - Generator.microbitMore_setOutput = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; - const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || 0; + Generator.microbitMore_setDigitalOut = function (block) { + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || Generator.quote_('Low'); return `microbit_more.set_digital(${pin}, ${level})\n`; }; - Generator.microbitMore_setPWM = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; + Generator.microbitMore_setAnalogOut = function (block) { + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); const level = Generator.valueToCode(block, 'LEVEL', Generator.ORDER_NONE) || 0; - return `microbit_more.set_pwm(${pin}, ${level})\n`; + return `microbit_more.set_analog(${pin}, ${level})\n`; }; Generator.microbitMore_setServo = function (block) { - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); const angle = Generator.valueToCode(block, 'ANGLE', Generator.ORDER_NONE) || 0; return `microbit_more.set_servo(${pin}, ${angle})\n`; }; + Generator.microbitMore_playTone = function (block) { + const freq = Generator.valueToCode(block, 'FREQ', Generator.ORDER_NONE) || 440; + const vol = Generator.valueToCode(block, 'VOL', Generator.ORDER_NONE) || 100; + return `microbit_more.play_tone(${freq}, ${vol})\n`; + }; + + Generator.microbitMore_stopTone = function () { + return `microbit_more.stop_tone\n`; + }; + const EventTypeLabel = { - 0: 'none', - 1: 'edge', - 2: 'pulse' + NONE: 'none', + ON_PULSE: 'pulse', + ON_EDGE: 'edge' }; - Generator.microbitMore_setPinEventType = function (block) { - const eventType = Generator.getFieldValue(block, 'EVENT_TYPE') || 0; + Generator.microbitMore_listenPinEventType = function (block) { + const eventType = Generator.getFieldValue(block, 'EVENT_TYPE', 'NONE'); const eventTypeLabel = Generator.quote_(EventTypeLabel[eventType]); - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; - return `microbit_more.catch_event_on(${eventTypeLabel}, ${pin})\n`; + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + return `microbit_more.listen_event_on(${eventTypeLabel}, ${pin})\n`; }; const EventLabel = { - 5: 'low pulse', - 4: 'high pulse', - 3: 'fall', - 2: 'rise' + PULSE_LOW: 'low pulse', + PULSE_HIGH: 'high pulse', + FALL: 'fall', + RISE: 'rise' }; Generator.microbitMore_whenPinEvent = function (block) { block.isStatement = true; - const event = Generator.getFieldValue(block, 'EVENT') || 5; + const event = Generator.getFieldValue(block, 'EVENT', 'PULSE_LOW'); const eventLabel = Generator.quote_(EventLabel[event]); - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); return `microbit_more.when_catch_at_pin(${eventLabel}, ${pin}) do\n`; }; - Generator.microbitMore_getPinEventTimestamp = function (block) { - const event = Generator.getFieldValue(block, 'EVENT') || 5; + Generator.microbitMore_getPinEventValue = function (block) { + const event = Generator.getFieldValue(block, 'EVENT', 'PULSE_LOW'); const eventLabel = Generator.quote_(EventLabel[event]); - const pin = Generator.valueToCode(block, 'PIN', Generator.ORDER_NONE) || 0; - return `microbit_more.timestamp_of(${eventLabel}, ${pin})\n`; - }; - - Generator.microbitMore_getSharedData = function (block) { - const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || 0; - return [`microbit_more.shared_data[${index}]`, Generator.ORDER_FUNCTION_CALL]; + const pin = Generator.quote_(`P${Generator.getFieldValue(block, 'PIN', '0')}`); + return `microbit_more.value_of(${eventLabel}, ${pin})\n`; }; - Generator.microbitMore_setSharedData = function (block) { - const index = Generator.valueToCode(block, 'INDEX', Generator.ORDER_NONE) || 0; - const value = Generator.valueToCode(block, 'VALUE', Generator.ORDER_NONE) || 0; - return `microbit_more.shared_data[${index}] = ${value}\n`; - }; - - Generator.microbitMore_whenConnectionChanged = function (block) { + Generator.microbitMore_whenDataReceived = function (block) { block.isStatement = true; - const state = Generator.quote_(Generator.getFieldValue(block, 'STATE') || 'connected'); - return `microbit_more.when_microbit(${state}) do\n`; - }; - - Generator.microbitMore_menu_buttons = function (block) { - const buttons = Generator.quote_(Generator.getFieldValue(block, 'buttons') || 'A'); - return [buttons, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_gestures = function (block) { - const gestures = Generator.quote_(Generator.getFieldValue(block, 'gestures') || 'moved'); - return [gestures, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_tiltDirectionAny = function (block) { - const tiltDirectionAny = Generator.quote_(Generator.getFieldValue(block, 'tiltDirectionAny') || 'any'); - return [tiltDirectionAny, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_tiltDirection = function (block) { - const tiltDirection = Generator.quote_(Generator.getFieldValue(block, 'tiltDirection') || 'front'); - return [tiltDirection, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_touchPins = function (block) { - const touchPins = Generator.getFieldValue(block, 'touchPins') || 0; - return [touchPins, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_gpio = function (block) { - const gpio = Generator.getFieldValue(block, 'gpio') || 0; - return [gpio, Generator.ORDER_ATOMIC]; - }; - - Generator.microbitMore_menu_axis = function (block) { - const axis = Generator.quote_(Generator.getFieldValue(block, 'axis') || 'x'); - return [axis, Generator.ORDER_ATOMIC]; + const label = Generator.valueToCode(block, 'LABEL', Generator.ORDER_NONE) || Generator.quote_('label-01'); + return `microbit_more.when_data_received_from_microbit(${label}) do\n`; }; - Generator.microbitMore_menu_analogIn = function (block) { - const analogIn = Generator.getFieldValue(block, 'analogIn') || 0; - return [analogIn, Generator.ORDER_ATOMIC]; + Generator.microbitMore_getDataLabeled = function (block) { + const label = Generator.valueToCode(block, 'LABEL', Generator.ORDER_NONE) || Generator.quote_('label-01'); + return [`microbit_more.data[${label}]`, Generator.ORDER_FUNCTION_CALL]; }; - Generator.microbitMore_menu_digitalValue = function (block) { - const digitalValue = Generator.getFieldValue(block, 'digitalValue') || 0; - return [digitalValue, Generator.ORDER_ATOMIC]; + Generator.microbitMore_sendData = function (block) { + const label = Generator.valueToCode(block, 'LABEL', Generator.ORDER_NONE) || Generator.quote_('label-01'); + const data = Generator.valueToCode(block, 'DATA', Generator.ORDER_NONE) || Generator.quote_('data'); + return `microbit_more.send_data_to_microbit(${data}, ${label})\n`; }; - Generator.microbitMore_menu_sharedDataIndex = function (block) { - const index = Generator.getFieldValue(block, 'sharedDataIndex') || 0; - return [index, Generator.ORDER_ATOMIC]; + Generator.microbitMore_menu_digitalValueMenu = function (block) { + const value = Generator.getFieldValue(block, 'digitalValueMenu') || 'false'; + const code = Generator.quote_(value === 'true' ? 'High' : 'Low'); + return [code, Generator.ORDER_ATOMIC]; }; Generator.matrix = function (block) { diff --git a/src/lib/ruby-to-blocks-converter/index.js b/src/lib/ruby-to-blocks-converter/index.js index 2c21a296e47..6a647860747 100644 --- a/src/lib/ruby-to-blocks-converter/index.js +++ b/src/lib/ruby-to-blocks-converter/index.js @@ -21,7 +21,7 @@ import MyBlocksConverter from './my-blocks'; import MusicConverter from './music'; import PenConverter from './pen'; import MicroBitConverter from './microbit'; -import MicroBitMoreConverter from './microbit_more'; +import MicrobitMoreConverter from './microbit_more'; import EV3Converter from './ev3'; import Wedo2Converter from './wedo2'; import GdxForConverter from './gdx_for'; @@ -112,7 +112,7 @@ class RubyToBlocksConverter { VideoConverter, Text2SpeechConverter, Wedo2Converter, - MicroBitMoreConverter + MicrobitMoreConverter ].forEach(x => x.register(this)); } diff --git a/src/lib/ruby-to-blocks-converter/microbit_more.js b/src/lib/ruby-to-blocks-converter/microbit_more.js index 2b75c247e16..9e0980f5fee 100644 --- a/src/lib/ruby-to-blocks-converter/microbit_more.js +++ b/src/lib/ruby-to-blocks-converter/microbit_more.js @@ -1,37 +1,58 @@ import Primitive from './primitive'; -const MicroBitMore = 'microbit_more'; -const SharedData = 'microbit_more.shared_data'; +const MicrobitMore = 'microbit_more'; +const MicrobitMoreData = 'microbit_more.data'; -const ButtonsMenu = [ +const ButtonIDMenu = [ 'A', - 'B', - 'any' + 'B' ]; -const ButtonsMenuLower = ButtonsMenu.map(x => x.toLowerCase()); +const ButtonIDMenuLower = ButtonIDMenu.map(x => x.toLowerCase()); -const GesturesMenu = [ - 'moved', - 'shaken', - 'jumped' +const ButtonEventMenu = [ + 'down', + 'up', + 'click' ]; -const TiltDirectionAnyMenu = [ - 'front', - 'back', - 'left', - 'right', - 'any' +const TouchIDMenu = [ + 'LOGO', + 'P0', + 'P1', + 'P2' ]; +const TouchIDMenuLower = TouchIDMenu.map(x => x.toLowerCase()); -const TiltDirectionMenu = TiltDirectionAnyMenu.slice(0, 4); +const TouchEventMenu = { + touched: 'DOWN', + released: 'UP', + tapped: 'CLICK' +}; + +const GestureMenu = { + TILT_UP: 'tilt up', + TILT_DOWN: 'tilt down', + TILT_LEFT: 'tilt left', + TILT_RIGHT: 'tilt right', + FACE_UP: 'face up', + FACE_DOWN: 'face down', + FREEFALL: 'freefall', + G3: '3G', + G6: '6G', + G8: '8G', + SHAKE: 'shake' +}; +const GestureMenuLower = Object.entries(GestureMenu).map(x => x[1].toLowerCase()); +const GestureMenuValue = Object.entries(GestureMenu).map(x => x[0]); const AnalogIn = [0, 1, 2]; +const AnalogInPin = AnalogIn.map(x => `p${x}`); const Gpio = [ 0, 1, 2, 8, 13, 14, 15, 16 ]; +const GpioPin = Gpio.map(x => `p${x}`); const AccelerationMenu = [ 'x', @@ -40,32 +61,36 @@ const AccelerationMenu = [ 'absolute' ]; -const PinMode = { - none: 'pullNone', - up: 'pullUp', - down: 'pullDown' -}; -const PinModeMenu = Object.keys(PinMode); +const PinModeMenu = [ + 'NONE', + 'UP', + 'DOWN' +]; +const PinModeMenuLower = PinModeMenu.map(x => x.toLowerCase()); -const EventType = { - none: 0, - pulse: 2, - edge: 1 +const DigitalValueMenu = { + high: 'true', + low: 'false' }; -const EventTypeMenu = Object.keys(EventType); +const DigitalValueMenuLower = Object.keys(DigitalValueMenu); +const DigitalValueMenuValue = Object.entries(DigitalValueMenu).map(x => x[1]); -const EventMenu = [ - 'rise', - 'fall', - 'high pulse', - 'low pulse' -]; -const Event = [ - 2, - 3, - 4, - 5 -]; +const PinEventTypeMenu = { + none: 'NONE', + pulse: 'ON_PULSE', + edge: 'ON_EDGE' +}; +const PinEventTypeMenuLower = Object.keys(PinEventTypeMenu); +const PinEventTypeMenuValue = Object.entries(PinEventTypeMenu).map(x => x[1]); + +const PinEventMenu = { + PULSE_LOW: 'low pulse', + PULSE_HIGH: 'high pulse', + FALL: 'fall', + RISE: 'rise' +}; +const PinEventMenuLower = Object.entries(PinEventMenu).map(x => x[1]); +const PinEventMenuValue = Object.keys(PinEventMenu); const ConnectionStateMenu = [ 'connected', @@ -73,416 +98,510 @@ const ConnectionStateMenu = [ ]; /** - * MicroBitMore converter + * MicrobitMore converter */ -const MicroBitMoreConverter = { +const MicrobitMoreConverter = { register: function (converter) { - converter.registerCallMethod('self', MicroBitMore, 0, params => { + converter.registerCallMethod('self', MicrobitMore, 0, params => { const {node} = params; - return converter.createRubyExpressionBlock(MicroBitMore, node); + return converter.createRubyExpressionBlock(MicrobitMore, node); }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when_button_pressed', 1, 0, params => { + converter.registerCallMethodWithBlock(MicrobitMore, 'when_microbit', 1, 0, params => { + const {receiver, args, rubyBlock} = params; + + if (!converter.isString(args[0])) return null; + const index = ConnectionStateMenu.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + args[0] = new Primitive('str', ConnectionStateMenu[index], args[0].node); + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenConnectionChanged', 'hat'); + converter.addField(block, 'STATE', args[0]); + converter.setParent(rubyBlock, block); + return block; + }); + + converter.registerCallMethodWithBlock(MicrobitMore, 'when_button_is', 2, 0, params => { const {receiver, args, rubyBlock} = params; - if (!converter.isStringOrBlock(args[0])) return null; if (converter.isString(args[0])) { - const index = ButtonsMenuLower.indexOf(args[0].toString().toLowerCase()); + const index = ButtonIDMenuLower.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('str', ButtonIDMenu[index], args[0].node); + } else { + return null; + } + if (converter.isString(args[1])) { + const index = ButtonEventMenu.indexOf(args[1].toString().toLowerCase()); if (index < 0) return null; - args[0] = new Primitive('str', ButtonsMenu[index], args[0].node); + args[1] = new Primitive('str', ButtonEventMenu[index], args[1].node); + } else { + return null; } - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenButtonPressed', 'hat'); - converter.addFieldInput(block, 'BTN', 'microbitMore_menu_buttons', 'buttons', args[0], 'A'); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenButtonEvent', 'hat'); + converter.addField(block, 'NAME', args[0]); + converter.addField(block, 'EVENT', args[1]); converter.setParent(rubyBlock, block); return block; }); - converter.registerCallMethod(MicroBitMore, 'button_pressed?', 1, params => { + converter.registerCallMethod(MicrobitMore, 'button_pressed?', 1, params => { const {receiver, args} = params; - if (!converter.isStringOrBlock(args[0])) return null; if (converter.isString(args[0])) { - const index = ButtonsMenuLower.indexOf(args[0].toString().toLowerCase()); + const index = ButtonIDMenuLower.indexOf(args[0].toString().toLowerCase()); if (index < 0) return null; - args[0] = new Primitive('str', ButtonsMenu[index], args[0].node); + args[0] = new Primitive('str', ButtonIDMenu[index], args[0].node); + } else { + return null; } const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_isButtonPressed', 'value_boolean'); - converter.addFieldInput(block, 'BTN', 'microbitMore_menu_buttons', 'buttons', args[0], 'A'); + converter.addField(block, 'NAME', args[0]); return block; }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when', 1, 0, params => { + converter.registerCallMethodWithBlock(MicrobitMore, 'when_pin_is', 2, 0, params => { const {receiver, args, rubyBlock} = params; - if (!converter.isStringOrBlock(args[0])) return null; if (converter.isString(args[0])) { - const index = GesturesMenu.indexOf(args[0].toString().toLowerCase()); + const index = TouchIDMenuLower.indexOf(args[0].toString().toLowerCase()); if (index < 0) return null; - args[0] = new Primitive('str', GesturesMenu[index], args[0].node); + args[0] = new Primitive('str', TouchIDMenu[index], args[0].node); + } else { + return null; } - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenGesture', 'hat'); - converter.addFieldInput(block, 'GESTURE', 'microbitMore_menu_gestures', 'gestures', args[0], 'moved'); - converter.setParent(rubyBlock, block); - return block; - }); - - converter.registerCallMethod(MicroBitMore, 'display', 5, params => { - const {receiver, args} = params; - - if (!args.every(x => converter.isString(x))) return null; - - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displaySymbol', 'statement'); + if (converter.isString(args[1])) { + const event = TouchEventMenu[args[1].toString().toLowerCase()]; + if (!event) return null; - let matrix = ''; - for (const arg of args) { - matrix += arg; + args[1] = new Primitive('str', event, args[1].node); + } else { + return null; } - matrix = matrix.replace(/[1-9]/g, '1').replace(/[^1-9]/g, '0'); - converter.addFieldInput(block, 'MATRIX', 'matrix', 'MATRIX', matrix, null); - return block; - }); - - converter.registerCallMethod(MicroBitMore, 'display', 1, params => { - const {receiver, args} = params; - - if (!converter.isBlock(args[0])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displaySymbol', 'statement'); - converter.addFieldInput(block, 'MATRIX', 'matrix', 'MATRIX', args[0], '0101010101100010101000100'); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenTouchEvent', 'hat'); + converter.addField(block, 'NAME', args[0]); + converter.addField(block, 'EVENT', args[1]); + converter.setParent(rubyBlock, block); return block; }); - converter.registerCallMethod(MicroBitMore, 'display_text', 1, params => { + converter.registerCallMethod(MicrobitMore, 'pin_is_touched?', 1, params => { const {receiver, args} = params; - if (!converter.isStringOrBlock(args[0])) return null; - - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayText', 'statement'); - converter.addTextInput(block, 'TEXT', args[0], 'Hello!'); - return block; - }); + if (converter.isString(args[0])) { + const index = TouchIDMenuLower.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; - converter.registerCallMethod(MicroBitMore, 'clear_display', 0, params => { - const {receiver} = params; + args[0] = new Primitive('str', TouchIDMenu[index], args[0].node); + } else { + return null; + } - return converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayClear', 'statement'); + const block = + converter.changeRubyExpressionBlock(receiver, 'microbitMore_isPinTouched', 'value_boolean'); + converter.addField(block, 'NAME', args[0]); + return block; }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when_tilted', 1, 0, params => { + converter.registerCallMethodWithBlock(MicrobitMore, 'when', 1, 0, params => { const {receiver, args, rubyBlock} = params; - if (!converter.isStringOrBlock(args[0])) return null; if (converter.isString(args[0])) { - const index = TiltDirectionAnyMenu.indexOf(args[0].toString().toLowerCase()); + const index = GestureMenuLower.indexOf(args[0].toString().toLowerCase()); if (index < 0) return null; - args[0] = new Primitive('str', TiltDirectionAnyMenu[index], args[0].node); + args[0] = new Primitive('str', GestureMenuValue[index], args[0].node); + } else { + return null; } - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenTilted', 'hat'); - converter.addFieldInput( - block, 'DIRECTION', 'microbitMore_menu_tiltDirectionAny', 'tiltDirectionAny', args[0], 'any' - ); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenGesture', 'hat'); + converter.addField(block, 'GESTURE', args[0]); converter.setParent(rubyBlock, block); return block; }); - converter.registerCallMethod(MicroBitMore, 'tilted?', 1, params => { + converter.registerCallMethod(MicrobitMore, 'display_pattern', 5, params => { const {receiver, args} = params; - if (!converter.isStringOrBlock(args[0])) return null; - if (converter.isString(args[0])) { - const index = TiltDirectionAnyMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; + if (!args.every(x => converter.isString(x))) return null; - args[0] = new Primitive('str', TiltDirectionAnyMenu[index], args[0].node); - } + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayMatrix', 'statement'); - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_isTilted', 'value_boolean'); - converter.addFieldInput( - block, 'DIRECTION', 'microbitMore_menu_tiltDirectionAny', 'tiltDirectionAny', args[0], 'any' - ); + let matrix = ''; + for (const arg of args) { + matrix += arg; + } + matrix = matrix.replace(/[1-9]/g, '1').replace(/[^1-9]/g, '0'); + converter.addFieldInput(block, 'MATRIX', 'matrix', 'MATRIX', matrix, null); return block; }); - converter.registerCallMethod(MicroBitMore, 'tilt_angle', 1, params => { + converter.registerCallMethod(MicrobitMore, 'display_pattern', 1, params => { const {receiver, args} = params; - if (!converter.isStringOrBlock(args[0])) return null; - if (converter.isString(args[0])) { - const index = TiltDirectionMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; - - args[0] = new Primitive('str', TiltDirectionMenu[index], args[0].node); - } + if (!converter.isBlock(args[0])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getTiltAngle', 'value'); - converter.addFieldInput( - block, 'DIRECTION', 'microbitMore_menu_tiltDirection', 'tiltDirection', args[0], 'front' - ); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayMatrix', 'statement'); + converter.addFieldInput(block, 'MATRIX', 'matrix', 'MATRIX', args[0], '0101010101100010101000100'); return block; }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when_pin_connected', 1, 0, params => { - const {receiver, args, rubyBlock} = params; + converter.registerCallMethod(MicrobitMore, 'display_text_delay', 2, params => { + const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; + if (!converter.isStringOrBlock(args[0])) return null; + if (!converter.isNumberOrBlock(args[1])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenPinConnected', 'hat'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); - converter.setParent(rubyBlock, block); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayText', 'statement'); + converter.addTextInput(block, 'TEXT', args[0], 'Hello!'); + converter.addNumberInput(block, 'DELAY', 'math_number', args[1], 120); return block; }); - converter.registerCallMethod(MicroBitMore, 'pin_connected?', 1, params => { - const {receiver, args} = params; - - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; + converter.registerCallMethod(MicrobitMore, 'clear_display', 0, params => { + const {receiver} = params; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_isPinConnected', 'value_boolean'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); - return block; + return converter.changeRubyExpressionBlock(receiver, 'microbitMore_displayClear', 'statement'); }); - converter.registerCallMethod(MicroBitMore, 'light_intensity', 0, params => { + converter.registerCallMethod(MicrobitMore, 'light_intensity', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getLightLevel', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'temperature', 0, params => { + converter.registerCallMethod(MicrobitMore, 'temperature', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getTemperature', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'angle_with_the_north', 0, params => { + converter.registerCallMethod(MicrobitMore, 'angle_with_north', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getCompassHeading', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'pitch', 0, params => { + converter.registerCallMethod(MicrobitMore, 'pitch', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getPitch', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'roll', 0, params => { + converter.registerCallMethod(MicrobitMore, 'roll', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getRoll', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'magnetic_force', 0, params => { + converter.registerCallMethod(MicrobitMore, 'sound_level', 0, params => { + const {receiver} = params; + + return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getSoundLevel', 'value'); + }); + + converter.registerCallMethod(MicrobitMore, 'magnetic_force', 0, params => { const {receiver} = params; return converter.changeRubyExpressionBlock(receiver, 'microbitMore_getMagneticForce', 'value'); }); - converter.registerCallMethod(MicroBitMore, 'acceleration', 1, params => { + converter.registerCallMethod(MicrobitMore, 'acceleration', 1, params => { const {receiver, args} = params; - if (!converter.isStringOrBlock(args[0])) return null; if (converter.isString(args[0])) { const index = AccelerationMenu.indexOf(args[0].toString().toLowerCase()); if (index < 0) return null; args[0] = new Primitive('str', AccelerationMenu[index], args[0].node); + } else { + return null; } + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getAcceleration', 'value'); - converter.addFieldInput(block, 'AXIS', 'microbitMore_menu_axis', 'axis', args[0], 'x'); + converter.addField(block, 'AXIS', args[0]); return block; }); - converter.registerCallMethod(MicroBitMore, 'analog_value_of_pin', 1, params => { + converter.registerCallMethod(MicrobitMore, 'analog_value', 1, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && AnalogIn.indexOf(args[0].value) < 0) return null; + if (converter.isString(args[0])) { + const index = AnalogInPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('int', AnalogIn[index], args[0].node); + } else { + return null; + } const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getAnalogValue', 'value'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_analogIn', 'analogIn', args[0], '0'); + converter.addField(block, 'PIN', args[0]); return block; }); - converter.registerCallMethod(MicroBitMore, 'digital_value_of_pin', 1, params => { + converter.registerCallMethod(MicrobitMore, 'set_pin_to_input_pull', 2, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; + if (converter.isString(args[0])) { + const index = GpioPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('int', Gpio[index], args[0].node); + } else { + return null; + } + if (converter.isString(args[1])) { + const index = PinModeMenuLower.indexOf(args[1].toString().toLowerCase()); + if (index < 0) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getDigitalValue', 'value'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); + args[1] = new Primitive('str', PinModeMenu[index], args[1].node); + } else { + return null; + } + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setPullMode', 'statement'); + converter.addField(block, 'PIN', args[0]); + converter.addField(block, 'MODE', args[1]); return block; }); - converter.registerCallMethod(MicroBitMore, 'set_pin_to_input_pull', 2, params => { + converter.registerCallMethod(MicrobitMore, 'is_pin_high?', 1, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && AnalogIn.indexOf(args[0].value) < 0) return null; - if (!converter.isString(args[1])) return null; - const index = PinModeMenu.indexOf(args[1].toString().toLowerCase()); - if (index < 0) return null; - args[1] = new Primitive('str', PinMode[PinModeMenu[index]], args[1].node); + if (converter.isString(args[0])) { + const index = GpioPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setPinMode', 'statement'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_analogIn', 'analogIn', args[0], '0'); - converter.addField(block, 'MODE', args[1]); + args[0] = new Primitive('int', Gpio[index], args[0].node); + } else { + return null; + } + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_isPinHigh', 'value_boolean'); + converter.addField(block, 'PIN', args[0]); return block; }); - converter.registerCallMethod(MicroBitMore, 'set_digital', 2, params => { + converter.registerCallMethod(MicrobitMore, 'set_digital', 2, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; - if (!converter.isNumberOrBlock(args[1])) return null; - if (converter.isNumber(args[1]) && args[1].value !== 0 && args[1].value !== 1) return null; + if (converter.isString(args[0])) { + const index = GpioPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setOutput', 'statement'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); - converter.addFieldInput(block, 'LEVEL', 'microbitMore_menu_digitalValue', 'digitalValue', args[1], '0'); + args[0] = new Primitive('int', Gpio[index], args[0].node); + } else { + return null; + } + if (converter.isString(args[1])) { + const index = DigitalValueMenuLower.indexOf(args[1].toString().toLowerCase()); + if (index < 0) return null; + + args[1] = new Primitive('str', DigitalValueMenuValue[index], args[0].node); + } else { + return null; + } + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setDigitalOut', 'statement'); + converter.addField(block, 'PIN', args[0]); + converter.addFieldInput(block, 'LEVEL', 'microbitMore_menu_digitalValueMenu', 'digitalValueMenu', + args[1], 'false'); return block; }); - converter.registerCallMethod(MicroBitMore, 'set_pwm', 2, params => { + converter.registerCallMethod(MicrobitMore, 'set_analog', 2, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; + if (converter.isString(args[0])) { + const index = GpioPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('int', Gpio[index], args[0].node); + } else { + return null; + } if (!converter.isNumberOrBlock(args[1])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setPWM', 'statement'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setAnalogOut', 'statement'); + converter.addField(block, 'PIN', args[0]); converter.addNumberInput(block, 'LEVEL', 'math_number', args[1], 0); return block; }); - converter.registerCallMethod(MicroBitMore, 'set_servo', 2, params => { + converter.registerCallMethod(MicrobitMore, 'set_servo', 2, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && Gpio.indexOf(args[0].value) < 0) return null; + if (converter.isString(args[0])) { + const index = GpioPin.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('int', Gpio[index], args[0].node); + } else { + return null; + } + if (!converter.isNumberOrBlock(args[1])) return null; const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setServo', 'statement'); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[0], '0'); + converter.addField(block, 'PIN', args[0]); converter.addNumberInput(block, 'ANGLE', 'math_number', args[1], 0); return block; }); - converter.registerCallMethod(MicroBitMore, 'catch_event_on', 2, params => { + converter.registerCallMethod(MicrobitMore, 'play_tone', 2, params => { const {receiver, args} = params; - if (!converter.isString(args[0])) return null; - const index = EventTypeMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; - args[0] = new Primitive('int', EventType[EventTypeMenu[index]], args[0].node); + if (!converter.isNumberOrBlock(args[0])) return null; if (!converter.isNumberOrBlock(args[1])) return null; - if (converter.isNumber(args[1]) && Gpio.indexOf(args[1].value) < 0) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setPinEventType', 'statement'); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_playTone', 'statement'); + converter.addNumberInput(block, 'FREQ', 'math_number', args[0], 440); + converter.addNumberInput(block, 'VOL', 'math_number', args[1], 100); + return block; + }); + + converter.registerCallMethod(MicrobitMore, 'stop_tone', 0, params => { + const {receiver} = params; + + return converter.changeRubyExpressionBlock(receiver, 'microbitMore_stopTone', 'statement'); + }); + + converter.registerCallMethod(MicrobitMore, 'listen_event_on', 2, params => { + const {receiver, args} = params; + + if (converter.isString(args[0])) { + const index = PinEventTypeMenuLower.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('str', PinEventTypeMenuValue[index], args[0].node); + } else { + return null; + } + + if (converter.isString(args[1])) { + const index = GpioPin.indexOf(args[1].toString().toLowerCase()); + if (index < 0) return null; + + args[1] = new Primitive('int', Gpio[index], args[1].node); + } else { + return null; + } + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_listenPinEventType', 'statement'); converter.addField(block, 'EVENT_TYPE', args[0]); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[1], '0'); + converter.addField(block, 'PIN', args[1]); return block; }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when_catch_at_pin', 2, 0, params => { + converter.registerCallMethodWithBlock(MicrobitMore, 'when_catch_at_pin', 2, 0, params => { const {receiver, args, rubyBlock} = params; - if (!converter.isString(args[0])) return null; - const index = EventMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; - args[0] = new Primitive('int', Event[index], args[0].node); - if (!converter.isNumberOrBlock(args[1])) return null; - if (converter.isNumber(args[1]) && Gpio.indexOf(args[1].value) < 0) return null; + if (converter.isString(args[0])) { + const index = PinEventMenuLower.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('str', PinEventMenuValue[index], args[0].node); + } else { + return null; + } + + if (converter.isString(args[1])) { + const index = GpioPin.indexOf(args[1].toString().toLowerCase()); + if (index < 0) return null; + + args[1] = new Primitive('int', Gpio[index], args[1].node); + } else { + return null; + } const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenPinEvent', 'hat'); converter.addField(block, 'EVENT', args[0]); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[1], '0'); + converter.addField(block, 'PIN', args[1], '0'); converter.setParent(rubyBlock, block); return block; }); - converter.registerCallMethod(MicroBitMore, 'timestamp_of', 2, params => { + converter.registerCallMethod(MicrobitMore, 'value_of', 2, params => { const {receiver, args} = params; - if (!converter.isString(args[0])) return null; - const index = EventMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; - args[0] = new Primitive('int', Event[index], args[0].node); - if (!converter.isNumberOrBlock(args[1])) return null; - if (converter.isNumber(args[1]) && Gpio.indexOf(args[1].value) < 0) return null; + if (converter.isString(args[0])) { + const index = PinEventMenuLower.indexOf(args[0].toString().toLowerCase()); + if (index < 0) return null; + + args[0] = new Primitive('str', PinEventMenuValue[index], args[0].node); + } else { + return null; + } + + if (converter.isString(args[1])) { + const index = GpioPin.indexOf(args[1].toString().toLowerCase()); + if (index < 0) return null; + + args[1] = new Primitive('int', Gpio[index], args[1].node); + } else { + return null; + } - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getPinEventTimestamp', 'value'); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getPinEventValue', 'value'); converter.addField(block, 'EVENT', args[0]); - converter.addFieldInput(block, 'PIN', 'microbitMore_menu_gpio', 'gpio', args[1], '0'); + converter.addField(block, 'PIN', args[1], '0'); return block; }); - converter.registerCallMethod(MicroBitMore, 'shared_data', 0, params => { - const {receiver, node} = params; + converter.registerCallMethodWithBlock(MicrobitMore, 'when_data_received_from_microbit', 1, 0, params => { + const {receiver, args, rubyBlock} = params; - const block = converter.changeRubyExpressionBlock(receiver, 'ruby_expression', 'value_boolean'); - block.node = node; - converter.addInput(block, 'EXPRESSION', converter.createTextBlock(SharedData)); + if (!converter.isStringOrBlock(args[0])) return null; + + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenDataReceived', 'hat'); + converter.addTextInput(block, 'LABEL', args[0], 'label-01'); + converter.setParent(rubyBlock, block); return block; }); - converter.registerCallMethod(SharedData, '[]', 1, params => { - const {receiver, args} = params; - - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && (args[0].value < 0 || args[0].value > 3)) return null; + converter.registerCallMethod(MicrobitMore, 'data', 0, params => { + const {receiver, node} = params; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getSharedData', 'value'); - converter.addFieldInput( - block, 'INDEX', 'microbitMore_menu_sharedDataIndex', 'sharedDataIndex', args[0], '0' - ); + const block = converter.changeRubyExpressionBlock(receiver, 'ruby_expression', 'value_boolean'); + block.node = node; + converter.addInput(block, 'EXPRESSION', converter.createTextBlock(MicrobitMoreData)); return block; }); - converter.registerCallMethod(SharedData, '[]=', 2, params => { + converter.registerCallMethod(MicrobitMoreData, '[]', 1, params => { const {receiver, args} = params; - if (!converter.isNumberOrBlock(args[0])) return null; - if (converter.isNumber(args[0]) && (args[0].value < 0 || args[0].value > 3)) return null; - if (!converter.isNumberOrBlock(args[1])) return null; + if (!converter.isStringOrBlock(args[0])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_setSharedData', 'statement'); - converter.addFieldInput( - block, 'INDEX', 'microbitMore_menu_sharedDataIndex', 'sharedDataIndex', args[0], '0' - ); - converter.addNumberInput(block, 'VALUE', 'math_number', args[1], 0); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_getDataLabeled', 'value'); + converter.addTextInput(block, 'LABEL', args[0], 'label-01'); return block; }); - converter.registerCallMethodWithBlock(MicroBitMore, 'when_microbit', 1, 0, params => { - const {receiver, args, rubyBlock} = params; + converter.registerCallMethod(MicrobitMore, 'send_data_to_microbit', 2, params => { + const {receiver, args} = params; - if (!converter.isString(args[0])) return null; - const index = ConnectionStateMenu.indexOf(args[0].toString().toLowerCase()); - if (index < 0) return null; - args[0] = new Primitive('str', ConnectionStateMenu[index], args[0].node); + if (!converter.isStringOrBlock(args[0])) return null; + if (!converter.isStringOrBlock(args[1])) return null; - const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_whenConnectionChanged', 'hat'); - converter.addField(block, 'STATE', args[0]); - converter.setParent(rubyBlock, block); + const block = converter.changeRubyExpressionBlock(receiver, 'microbitMore_sendData', 'statement'); + converter.addTextInput(block, 'LABEL', args[1], 'label-01'); + converter.addTextInput(block, 'DATA', args[0], 'data'); return block; }); } }; -export default MicroBitMoreConverter; +export default MicrobitMoreConverter; diff --git a/test/.eslintrc.js b/test/.eslintrc.js index c4463f885db..1680f66180c 100644 --- a/test/.eslintrc.js +++ b/test/.eslintrc.js @@ -11,6 +11,7 @@ module.exports = { terms: ['todo'], location: 'start' }], + 'jest/no-disabled-tests': 0, 'jest/valid-describe': 0 } }; diff --git a/test/integration/ruby-tab/extension_microbit_more.test.js b/test/integration/ruby-tab/extension_microbit_more.test.js index 2a5b66ab7da..060b4cd0176 100644 --- a/test/integration/ruby-tab/extension_microbit_more.test.js +++ b/test/integration/ruby-tab/extension_microbit_more.test.js @@ -16,7 +16,7 @@ const { let driver; -describe('Ruby Tab: micro:bit MORE v0.4.3 extension blocks', () => { +describe('Ruby Tab: Microbit More v2 extension blocks', () => { beforeAll(() => { driver = getDriver(); }); @@ -29,200 +29,121 @@ describe('Ruby Tab: micro:bit MORE v0.4.3 extension blocks', () => { await loadUri(urlFor('/')); const code = dedent` - microbit_more.when_button_pressed("A") do + microbit_more.when_microbit("connected") do end - microbit_more.when_button_pressed("B") do + microbit_more.when_microbit("disconnected") do end - microbit_more.when_button_pressed("any") do + microbit_more.when_button_is("A", "down") do end - microbit_more.when_button_pressed(x) do + microbit_more.when_button_is("B", "click") do end microbit_more.button_pressed?("A") - microbit_more.button_pressed?(x) - - microbit_more.when("moved") do - end - - microbit_more.when("shaken") do - end - - microbit_more.when("jumped") do - microbit_more.display( - ".1.1.", - "1.1.1", - "1...1", - ".1.1.", - "..1.." - ) - microbit_more.display(x) - microbit_more.display_text("Hello!") - microbit_more.display_text(x) - microbit_more.clear_display - end - - microbit_more.when(x) do - end - - microbit_more.when_tilted("any") do - end - - microbit_more.when_tilted("front") do - end - - microbit_more.when_tilted("back") do - end - - microbit_more.when_tilted("left") do - end - - microbit_more.when_tilted("right") do - end - - microbit_more.when_tilted(x) do - end - - microbit_more.tilted?("any") - - microbit_more.tilted?(x) - - microbit_more.tilt_angle("front") - - microbit_more.tilt_angle(x) - - microbit_more.when_pin_connected(0) do - end - - microbit_more.when_pin_connected(1) do - end - - microbit_more.when_pin_connected(2) do - end + microbit_more.button_pressed?("B") - microbit_more.when_pin_connected(8) do + microbit_more.when_pin_is("LOGO", "touched") do end - microbit_more.when_pin_connected(13) do + microbit_more.when_pin_is("P2", "tapped") do end - microbit_more.when_pin_connected(14) do - end + microbit_more.pin_is_touched?("LOGO") - microbit_more.when_pin_connected(15) do - end + microbit_more.pin_is_touched?("P2") - microbit_more.when_pin_connected(16) do + microbit_more.when("shake") do end - microbit_more.when_pin_connected(x) do + microbit_more.when("6G") do end - microbit_more.pin_connected?(0) - - microbit_more.pin_connected?(x) + microbit_more.display_pattern( + ".1.1.", + "1.1.1", + "1...1", + ".1.1.", + "..1.." + ) + microbit_more.display_pattern( + "1...1", + ".1.1.", + "..1..", + ".1.1.", + "1...1" + ) + microbit_more.display_text_delay("Hello!", 120) + microbit_more.display_text_delay("Test", 60) + microbit_more.clear_display microbit_more.light_intensity microbit_more.temperature - microbit_more.angle_with_the_north + microbit_more.angle_with_north microbit_more.pitch microbit_more.roll + microbit_more.sound_level + microbit_more.magnetic_force microbit_more.acceleration("x") - microbit_more.acceleration("y") - - microbit_more.acceleration("z") - microbit_more.acceleration("absolute") - microbit_more.acceleration(x) - - microbit_more.analog_value_of_pin(0) - - microbit_more.analog_value_of_pin(1) - - microbit_more.analog_value_of_pin(2) - - microbit_more.analog_value_of_pin(x) - - microbit_more.digital_value_of_pin(0) - - microbit_more.digital_value_of_pin(8) - - microbit_more.digital_value_of_pin(13) + microbit_more.analog_value("P0") - microbit_more.digital_value_of_pin(14) + microbit_more.analog_value("P2") - microbit_more.digital_value_of_pin(15) + microbit_more.set_pin_to_input_pull("P0", "up") + microbit_more.set_pin_to_input_pull("P16", "down") - microbit_more.digital_value_of_pin(16) + microbit_more.is_pin_high?("P0") - microbit_more.digital_value_of_pin(x) + microbit_more.is_pin_high?("P16") - microbit_more.set_pin_to_input_pull(0, "up") - microbit_more.set_pin_to_input_pull(1, "none") - microbit_more.set_pin_to_input_pull(2, "down") - microbit_more.set_pin_to_input_pull(x, "down") - microbit_more.set_digital(0, 0) - microbit_more.set_digital(16, 1) - microbit_more.set_digital(x, 1) - microbit_more.set_pwm(0, 0) - microbit_more.set_pwm(16, x) - microbit_more.set_pwm(x, y) - microbit_more.set_servo(0, 0) - microbit_more.set_servo(16, x) - microbit_more.set_servo(x, y) - microbit_more.catch_event_on("none", 0) - microbit_more.catch_event_on("pulse", 16) - microbit_more.catch_event_on("edge", x) + microbit_more.set_digital("P0", "Low") + microbit_more.set_digital("P16", "High") + microbit_more.set_analog("P0", 0) + microbit_more.set_analog("P16", 100) + microbit_more.set_servo("P0", 0) + microbit_more.set_servo("P16", 100) + microbit_more.play_tone(440, 100) + microbit_more.play_tone(220, 50) + microbit_more.stop_tone + microbit_more.listen_event_on("none", "P0") + microbit_more.listen_event_on("edge", "P16") - microbit_more.when_catch_at_pin("low pulse", 0) do + microbit_more.when_catch_at_pin("low pulse", "P0") do end - microbit_more.when_catch_at_pin("high pulse", 16) do + microbit_more.when_catch_at_pin("rise", "P16") do end - microbit_more.when_catch_at_pin("fall", x) do - end - - microbit_more.when_catch_at_pin("rise", y) do - end - - microbit_more.timestamp_of("low pulse", 0) - - microbit_more.timestamp_of("rise", 16) - - microbit_more.timestamp_of("rise", x) - - microbit_more.shared_data[0] - - microbit_more.shared_data[1] + microbit_more.value_of("low pulse", "P0") - microbit_more.shared_data[2] + microbit_more.value_of("rise", "P16") - microbit_more.shared_data[3] + microbit_more.when_data_received_from_microbit("label-01") do + end - microbit_more.shared_data[x] + microbit_more.when_data_received_from_microbit("label-02") do + end - microbit_more.shared_data[0] = 0 - microbit_more.shared_data[3] = x + microbit_more.data["label-01"] - microbit_more.when_microbit("connected") do - end + microbit_more.data["label-02"] - microbit_more.when_microbit("disconnected") do - end + microbit_more.send_data_to_microbit("data", "label-01") + microbit_more.send_data_to_microbit("123456", "label-02") `; + await expectInterconvertBetweenCodeAndRuby(code); }); });