CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-10 18:37:09 +01:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove deprecateLegacyNamespace from keyboard nav files

Browse Source 
* chore: Remove deprecateLegacyNamespace & fix tests

* chore: export from the blockly file
This commit is contained in:
alschmiedt
2021-09-21 17:18:34 -07:00
committed by GitHub
parent 556a2422e2
commit cf091351d8
9 changed files with 139 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
core/blockly.js
View File

@@ -17,14 +17,19 @@
goog.module('Blockly');
goog.module.declareLegacyNamespace();
const ASTNode = goog.require('Blockly.ASTNode');
const BasicCursor = goog.require('Blockly.BasicCursor');
const Block = goog.require('Blockly.Block');
const Blocks = goog.require('Blockly.Blocks');
const BlockDragger = goog.require('Blockly.BlockDragger');
const BlockDragSurfaceSvg = goog.require('Blockly.BlockDragSurfaceSvg');
const BlockSvg = goog.require('Blockly.BlockSvg');
const Cursor = goog.require('Blockly.Cursor');
/* eslint-disable-next-line no-unused-vars */
const ICopyable = goog.requireType('Blockly.ICopyable');
const Marker = goog.require('Blockly.Marker');
const Size = goog.require('Blockly.utils.Size');
const TabNavigateCursor = goog.require('Blockly.TabNavigateCursor');
/* eslint-disable-next-line no-unused-vars */
const Workspace = goog.requireType('Blockly.Workspace');
/* eslint-disable-next-line no-unused-vars */
@@ -402,7 +407,12 @@ exports.DELETE_VARIABLE_ID = internalConstants.DELETE_VARIABLE_ID;
exports.COLLAPSED_INPUT_NAME = constants.COLLAPSED_INPUT_NAME;
exports.COLLAPSED_FIELD_NAME = constants.COLLAPSED_FIELD_NAME;
exports.ASTNode = ASTNode;
exports.BasicCursor = BasicCursor;
exports.Block = Block;
exports.BlockDragger = BlockDragger;
exports.BlockDragSurfaceSvg = BlockDragSurfaceSvg;
exports.BlockSvg = BlockSvg;
exports.Cursor = Cursor;
exports.Marker = Marker;
exports.TabNavigateCursor = TabNavigateCursor;

1
core/keyboard_nav/ast_node.js
View File

@@ -11,7 +11,6 @@
'use strict';
goog.module('Blockly.ASTNode');
goog.module.declareLegacyNamespace();
/* eslint-disable-next-line no-unused-vars */
const Block = goog.requireType('Blockly.Block');

1
core/keyboard_nav/basic_cursor.js
View File

@@ -12,7 +12,6 @@
'use strict';
goog.module('Blockly.BasicCursor');
goog.module.declareLegacyNamespace();
const ASTNode = goog.require('Blockly.ASTNode');
const Cursor = goog.require('Blockly.Cursor');

1
core/keyboard_nav/cursor.js
View File

@@ -12,7 +12,6 @@
'use strict';
goog.module('Blockly.Cursor');
goog.module.declareLegacyNamespace();
const ASTNode = goog.require('Blockly.ASTNode');
const Marker = goog.require('Blockly.Marker');

1
core/keyboard_nav/marker.js
View File

@@ -12,7 +12,6 @@
'use strict';
goog.module('Blockly.Marker');
goog.module.declareLegacyNamespace();
/* eslint-disable-next-line no-unused-vars */
const ASTNode = goog.requireType('Blockly.ASTNode');

1
core/keyboard_nav/tab_navigate_cursor.js
View File

@@ -12,7 +12,6 @@
'use strict';
goog.module('Blockly.TabNavigateCursor');
goog.module.declareLegacyNamespace();
const ASTNode = goog.require('Blockly.ASTNode');
const BasicCursor = goog.require('Blockly.BasicCursor');

223
tests/mocha/astnode_test.js
View File

@@ -6,6 +6,7 @@
goog.module('Blockly.test.astNode');
const ASTNode = goog.require('Blockly.ASTNode');
const {sharedTestSetup, sharedTestTeardown, workspaceTeardown} = goog.require('Blockly.test.helpers');
@@ -103,7 +104,7 @@ suite('ASTNode', function() {
var input = this.blocks.statementInput1.inputList[0];
var input2 = this.blocks.statementInput1.inputList[1];
var connection = input.connection;
var node = Blockly.ASTNode.createConnectionNode(connection);
var node = ASTNode.createConnectionNode(connection);
var newASTNode = node.findNextForInput_(input);
chai.assert.equal(newASTNode.getLocation(), input2.connection);
});
@@ -112,7 +113,7 @@ suite('ASTNode', function() {
var input = this.blocks.statementInput1.inputList[0];
var input2 = this.blocks.statementInput1.inputList[1];
var connection = input2.connection;
var node = Blockly.ASTNode.createConnectionNode(connection);
var node = ASTNode.createConnectionNode(connection);
var newASTNode = node.findPrevForInput_(input2);
chai.assert.equal(newASTNode.getLocation(), input.connection);
});
@@ -120,7 +121,7 @@ suite('ASTNode', function() {
test('findNextForField_', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var newASTNode = node.findNextForField_(field);
chai.assert.equal(newASTNode.getLocation(), field2);
});
@@ -128,39 +129,39 @@ suite('ASTNode', function() {
test('findPrevForField_', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
var node = Blockly.ASTNode.createFieldNode(field2);
var node = ASTNode.createFieldNode(field2);
var newASTNode = node.findPrevForField_(field2);
chai.assert.equal(newASTNode.getLocation(), field);
});
test('navigateBetweenStacks_Forward', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.NEXT, this.blocks.statementInput1.nextConnection);
var node = new ASTNode(
ASTNode.types.NEXT, this.blocks.statementInput1.nextConnection);
var newASTNode = node.navigateBetweenStacks_(true);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
});
test('navigateBetweenStacks_Backward', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var node = new ASTNode(
ASTNode.types.BLOCK, this.blocks.statementInput4);
var newASTNode = node.navigateBetweenStacks_(false);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
});
test('getOutAstNodeForBlock_', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput2);
var node = new ASTNode(
ASTNode.types.BLOCK, this.blocks.statementInput2);
var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput2);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
});
test('getOutAstNodeForBlock_OneBlock', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var node = new ASTNode(
ASTNode.types.BLOCK, this.blocks.statementInput4);
var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput4);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
});
test('findFirstFieldOrInput_', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var node = new ASTNode(
ASTNode.types.BLOCK, this.blocks.statementInput4);
var field = this.blocks.statementInput4.inputList[0].fieldRow[0];
var newASTNode = node.findFirstFieldOrInput_(this.blocks.statementInput4);
chai.assert.equal(newASTNode.getLocation(), field);
@@ -321,95 +322,95 @@ suite('ASTNode', function() {
test('fromPreviousToBlock', function() {
var prevConnection = this.blocks.statementInput1.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var node = ASTNode.createConnectionNode(prevConnection);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput1);
});
test('fromBlockToNext', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var node = ASTNode.createBlockNode(this.blocks.statementInput1);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), nextConnection);
});
test('fromBlockToNull', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.noNextConnection);
var node = ASTNode.createBlockNode(this.blocks.noNextConnection);
var nextNode = node.next();
chai.assert.isNull(nextNode);
});
test('fromNextToPrevious', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var prevConnection = this.blocks.statementInput2.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var node = ASTNode.createConnectionNode(nextConnection);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), prevConnection);
});
test('fromNextToNull', function() {
var nextConnection = this.blocks.statementInput2.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var node = ASTNode.createConnectionNode(nextConnection);
var nextNode = node.next();
chai.assert.isNull(nextNode);
});
test('fromInputToInput', function() {
var input = this.blocks.statementInput1.inputList[0];
var inputConnection = this.blocks.statementInput1.inputList[1].connection;
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromInputToStatementInput', function() {
var input = this.blocks.fieldAndInputs2.inputList[1];
var inputConnection = this.blocks.fieldAndInputs2.inputList[2].connection;
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromInputToField', function() {
var input = this.blocks.fieldAndInputs2.inputList[0];
var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), field);
});
test('fromInputToNull', function() {
var input = this.blocks.fieldAndInputs2.inputList[2];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var nextNode = node.next();
chai.assert.isNull(nextNode);
});
test('fromOutputToBlock', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var node = ASTNode.createConnectionNode(output);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), this.blocks.fieldWithOutput);
});
test('fromFieldToInput', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[1];
var inputConnection = this.blocks.statementInput1.inputList[0].connection;
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromFieldToField', function() {
var field = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var field2 = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), field2);
});
test('fromFieldToNull', function() {
var field = this.blocks.twoFields.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var nextNode = node.next();
chai.assert.isNull(nextNode);
});
test('fromStackToStack', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
var node = ASTNode.createStackNode(this.blocks.statementInput1);
var nextNode = node.next();
chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput4);
chai.assert.equal(nextNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(nextNode.getType(), ASTNode.types.STACK);
});
test('fromStackToNull', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.singleBlock);
var node = ASTNode.createStackNode(this.blocks.singleBlock);
var nextNode = node.next();
chai.assert.isNull(nextNode);
});
@@ -418,96 +419,96 @@ suite('ASTNode', function() {
suite('Previous', function() {
test('fromPreviousToNull', function() {
var prevConnection = this.blocks.statementInput1.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var node = ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromPreviousToNext', function() {
var prevConnection = this.blocks.statementInput2.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var node = ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
var nextConnection = this.blocks.statementInput1.nextConnection;
chai.assert.equal(prevNode.getLocation(), nextConnection);
});
test('fromPreviousToInput', function() {
var prevConnection = this.blocks.statementInput3.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var node = ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromBlockToPrevious', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var node = ASTNode.createBlockNode(this.blocks.statementInput1);
var prevNode = node.prev();
var prevConnection = this.blocks.statementInput1.previousConnection;
chai.assert.equal(prevNode.getLocation(), prevConnection);
});
test('fromBlockToNull', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.noPrevConnection);
var node = ASTNode.createBlockNode(this.blocks.noPrevConnection);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromBlockToOutput', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.fieldWithOutput);
var node = ASTNode.createBlockNode(this.blocks.fieldWithOutput);
var prevNode = node.prev();
var outputConnection = this.blocks.fieldWithOutput.outputConnection;
chai.assert.equal(prevNode.getLocation(), outputConnection);
});
test('fromNextToBlock', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var node = ASTNode.createConnectionNode(nextConnection);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
});
test('fromInputToField', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), input.fieldRow[1]);
});
test('fromInputToNull', function() {
var input = this.blocks.fieldAndInputs2.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromInputToInput', function() {
var input = this.blocks.fieldAndInputs2.inputList[2];
var inputConnection = this.blocks.fieldAndInputs2.inputList[1].connection;
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), inputConnection);
});
test('fromOutputToNull', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var node = ASTNode.createConnectionNode(output);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromFieldToNull', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var prevNode = node.prev();
chai.assert.isNull(prevNode);
});
test('fromFieldToInput', function() {
var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
var inputConnection = this.blocks.fieldAndInputs2.inputList[0].connection;
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), inputConnection);
});
test('fromFieldToField', function() {
var field = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
var field2 = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), field2);
});
test('fromStackToStack', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
var node = ASTNode.createStackNode(this.blocks.statementInput4);
var prevNode = node.prev();
chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(prevNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(prevNode.getType(), ASTNode.types.STACK);
});
});
@@ -521,99 +522,99 @@ suite('ASTNode', function() {
test('fromInputToOutput', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var inNode = node.in();
var outputConnection = this.blocks.fieldWithOutput.outputConnection;
chai.assert.equal(inNode.getLocation(), outputConnection);
});
test('fromInputToNull', function() {
var input = this.blocks.statementInput2.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var inNode = node.in();
chai.assert.isNull(inNode);
});
test('fromInputToPrevious', function() {
var input = this.blocks.statementInput2.inputList[1];
var previousConnection = this.blocks.statementInput3.previousConnection;
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), previousConnection);
});
test('fromBlockToInput', function() {
var input = this.blocks.valueInput.inputList[0];
var node = Blockly.ASTNode.createBlockNode(this.blocks.valueInput);
var node = ASTNode.createBlockNode(this.blocks.valueInput);
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), input.connection);
});
test('fromBlockToField', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var node = ASTNode.createBlockNode(this.blocks.statementInput1);
var inNode = node.in();
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
chai.assert.equal(inNode.getLocation(), field);
});
test('fromBlockToPrevious', function() {
var prevConnection = this.blocks.statementInput4.previousConnection;
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
var node = ASTNode.createStackNode(this.blocks.statementInput4);
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), prevConnection);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.equal(inNode.getType(), ASTNode.types.PREVIOUS);
});
test('fromBlockToNull_DummyInput', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInput);
var node = ASTNode.createBlockNode(this.blocks.dummyInput);
var inNode = node.in();
chai.assert.isNull(inNode);
});
test('fromBlockToInput_DummyInputValue', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInputValue);
var node = ASTNode.createBlockNode(this.blocks.dummyInputValue);
var inputConnection = this.blocks.dummyInputValue.inputList[1].connection;
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), inputConnection);
});
test('fromOuputToNull', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var node = ASTNode.createConnectionNode(output);
var inNode = node.in();
chai.assert.isNull(inNode);
});
test('fromFieldToNull', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var inNode = node.in();
chai.assert.isNull(inNode);
});
test('fromWorkspaceToStack', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode.createWorkspaceNode(this.workspace, coordinate);
var node = ASTNode.createWorkspaceNode(this.workspace, coordinate);
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(inNode.getType(), ASTNode.types.STACK);
});
test('fromWorkspaceToNull', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode.createWorkspaceNode(
var node = ASTNode.createWorkspaceNode(
this.emptyWorkspace, coordinate);
var inNode = node.in();
chai.assert.isNull(inNode);
});
test('fromStackToPrevious', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
var node = ASTNode.createStackNode(this.blocks.statementInput1);
var previous = this.blocks.statementInput1.previousConnection;
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), previous);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.equal(inNode.getType(), ASTNode.types.PREVIOUS);
});
test('fromStackToOutput', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.fieldWithOutput2);
var node = ASTNode.createStackNode(this.blocks.fieldWithOutput2);
var output = this.blocks.fieldWithOutput2.outputConnection;
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), output);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.OUTPUT);
chai.assert.equal(inNode.getType(), ASTNode.types.OUTPUT);
});
test('fromStackToBlock', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.dummyInput);
var node = ASTNode.createStackNode(this.blocks.dummyInput);
var inNode = node.in();
chai.assert.equal(inNode.getLocation(), this.blocks.dummyInput);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.BLOCK);
chai.assert.equal(inNode.getType(), ASTNode.types.BLOCK);
});
});
@@ -628,39 +629,39 @@ suite('ASTNode', function() {
test('fromInputToBlock', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.BLOCK);
chai.assert.equal(outNode.getType(), ASTNode.types.BLOCK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromOutputToInput', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var node = ASTNode.createConnectionNode(output);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(),
this.blocks.statementInput1.inputList[0].connection);
});
test('fromOutputToStack', function() {
var output = this.blocks.fieldWithOutput2.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var node = ASTNode.createConnectionNode(output);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.fieldWithOutput2);
});
test('fromFieldToBlock', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.BLOCK);
chai.assert.equal(outNode.getType(), ASTNode.types.BLOCK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromStackToWorkspace', function() {
var stub = sinon.stub(this.blocks.statementInput4,
"getRelativeToSurfaceXY").returns({x: 10, y:10});
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
var node = ASTNode.createStackNode(this.blocks.statementInput4);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.WORKSPACE);
chai.assert.equal(outNode.getType(), ASTNode.types.WORKSPACE);
chai.assert.equal(outNode.wsCoordinate_.x, 10);
chai.assert.equal(outNode.wsCoordinate_.y, -10);
stub.restore();
@@ -668,38 +669,38 @@ suite('ASTNode', function() {
test('fromPreviousToInput', function() {
var previous = this.blocks.statementInput3.previousConnection;
var inputConnection = this.blocks.statementInput2.inputList[1].connection;
var node = Blockly.ASTNode.createConnectionNode(previous);
var node = ASTNode.createConnectionNode(previous);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(), inputConnection);
});
test('fromPreviousToStack', function() {
var previous = this.blocks.statementInput2.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(previous);
var node = ASTNode.createConnectionNode(previous);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromNextToInput', function() {
var next = this.blocks.statementInput3.nextConnection;
var inputConnection = this.blocks.statementInput2.inputList[1].connection;
var node = Blockly.ASTNode.createConnectionNode(next);
var node = ASTNode.createConnectionNode(next);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(), inputConnection);
});
test('fromNextToStack', function() {
var next = this.blocks.statementInput2.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(next);
var node = ASTNode.createConnectionNode(next);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromNextToStack_NoPreviousConnection', function() {
var next = this.blocks.secondBlock.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(next);
var node = ASTNode.createConnectionNode(next);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.noPrevConnection);
});
/**
@@ -708,42 +709,42 @@ suite('ASTNode', function() {
*/
test('fromNextToInput_OutputAndPreviousConnection', function() {
var next = this.blocks.outputNextBlock.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(next);
var node = ASTNode.createConnectionNode(next);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(),
this.blocks.secondBlock.inputList[0].connection);
});
test('fromBlockToStack', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput2);
var node = ASTNode.createBlockNode(this.blocks.statementInput2);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromBlockToInput', function() {
var input = this.blocks.statementInput2.inputList[1].connection;
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput3);
var node = ASTNode.createBlockNode(this.blocks.statementInput3);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(), input);
});
test('fromTopBlockToStack', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var node = ASTNode.createBlockNode(this.blocks.statementInput1);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.statementInput1);
});
test('fromBlockToStack_OutputConnection', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.fieldWithOutput2);
var node = ASTNode.createBlockNode(this.blocks.fieldWithOutput2);
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(outNode.getType(), ASTNode.types.STACK);
chai.assert.equal(outNode.getLocation(), this.blocks.fieldWithOutput2);
});
test('fromBlockToInput_OutputConnection', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.outputNextBlock);
var node = ASTNode.createBlockNode(this.blocks.outputNextBlock);
var inputConnection = this.blocks.secondBlock.inputList[0].connection;
var outNode = node.out();
chai.assert.equal(outNode.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(outNode.getType(), ASTNode.types.INPUT);
chai.assert.equal(outNode.getLocation(), inputConnection);
});
});
@@ -751,55 +752,55 @@ suite('ASTNode', function() {
suite('createFunctions', function() {
test('createFieldNode', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var node = ASTNode.createFieldNode(field);
chai.assert.equal(node.getLocation(), field);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.FIELD);
chai.assert.equal(node.getType(), ASTNode.types.FIELD);
chai.assert.isFalse(node.isConnection());
});
test('createConnectionNode', function() {
var prevConnection = this.blocks.statementInput4.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var node = ASTNode.createConnectionNode(prevConnection);
chai.assert.equal(node.getLocation(), prevConnection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.equal(node.getType(), ASTNode.types.PREVIOUS);
chai.assert.isTrue(node.isConnection());
});
test('createInputNode', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var node = ASTNode.createInputNode(input);
chai.assert.equal(node.getLocation(), input.connection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(node.getType(), ASTNode.types.INPUT);
chai.assert.isTrue(node.isConnection());
});
test('createWorkspaceNode', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode
var node = ASTNode
.createWorkspaceNode(this.workspace, coordinate);
chai.assert.equal(node.getLocation(), this.workspace);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.WORKSPACE);
chai.assert.equal(node.getType(), ASTNode.types.WORKSPACE);
chai.assert.equal(node.getWsCoordinate(), coordinate);
chai.assert.isFalse(node.isConnection());
});
test('createStatementConnectionNode', function() {
var nextConnection = this.blocks.statementInput1.inputList[1].connection;
var inputConnection = this.blocks.statementInput1.inputList[1].connection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var node = ASTNode.createConnectionNode(nextConnection);
chai.assert.equal(node.getLocation(), inputConnection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.equal(node.getType(), ASTNode.types.INPUT);
chai.assert.isTrue(node.isConnection());
});
test('createTopNode-previous', function() {
var block = this.blocks.statementInput1;
var topNode = Blockly.ASTNode.createTopNode(block);
var topNode = ASTNode.createTopNode(block);
chai.assert.equal(topNode.getLocation(), block.previousConnection);
});
test('createTopNode-block', function() {
var block = this.blocks.noPrevConnection;
var topNode = Blockly.ASTNode.createTopNode(block);
var topNode = ASTNode.createTopNode(block);
chai.assert.equal(topNode.getLocation(), block);
});
test('createTopNode-output', function() {
var block = this.blocks.outputNextBlock;
var topNode = Blockly.ASTNode.createTopNode(block);
var topNode = ASTNode.createTopNode(block);
chai.assert.equal(topNode.getLocation(), block.outputConnection);
});
});

11
tests/mocha/cursor_test.js
View File

@@ -7,6 +7,7 @@
goog.module('Blockly.test.cursor');
const {sharedTestSetup, sharedTestTeardown} = goog.require('Blockly.test.helpers');
const ASTNode = goog.require('Blockly.ASTNode');
suite('Cursor', function() {
@@ -82,14 +83,14 @@ suite('Cursor', function() {
});
test('Next - From a Previous skip over next connection and block', function() {
var prevNode = Blockly.ASTNode.createConnectionNode(this.blocks.A.previousConnection);
var prevNode = ASTNode.createConnectionNode(this.blocks.A.previousConnection);
this.cursor.setCurNode(prevNode);
this.cursor.next();
var curNode = this.cursor.getCurNode();
chai.assert.equal(curNode.getLocation(), this.blocks.B.previousConnection);
});
test('Next - From last block in a stack go to next connection', function() {
var prevNode = Blockly.ASTNode.createConnectionNode(this.blocks.B.previousConnection);
var prevNode = ASTNode.createConnectionNode(this.blocks.B.previousConnection);
this.cursor.setCurNode(prevNode);
this.cursor.next();
var curNode = this.cursor.getCurNode();
@@ -98,7 +99,7 @@ suite('Cursor', function() {
test('In - From output connection', function() {
var fieldBlock = this.blocks.E;
var outputNode = Blockly.ASTNode.createConnectionNode(fieldBlock.outputConnection);
var outputNode = ASTNode.createConnectionNode(fieldBlock.outputConnection);
this.cursor.setCurNode(outputNode);
this.cursor.in();
var curNode = this.cursor.getCurNode();
@@ -107,7 +108,7 @@ suite('Cursor', function() {
test('Prev - From previous connection skip over next connection', function() {
var prevConnection = this.blocks.B.previousConnection;
var prevConnectionNode = Blockly.ASTNode.createConnectionNode(prevConnection);
var prevConnectionNode = ASTNode.createConnectionNode(prevConnection);
this.cursor.setCurNode(prevConnectionNode);
this.cursor.prev();
var curNode = this.cursor.getCurNode();
@@ -116,7 +117,7 @@ suite('Cursor', function() {
test('Out - From field skip over block node', function() {
var field = this.blocks.E.inputList[0].fieldRow[0];
var fieldNode = Blockly.ASTNode.createFieldNode(field);
var fieldNode = ASTNode.createFieldNode(field);
this.cursor.setCurNode(fieldNode);
this.cursor.out();
var curNode = this.cursor.getCurNode();

21
tests/mocha/event_test.js
View File

@@ -7,6 +7,7 @@
goog.module('Blockly.test.event');
const {assertEventEquals, assertNthCallEventArgEquals, assertVariableValues, createFireChangeListenerSpy, createGenUidStubWithReturns, sharedTestSetup, sharedTestTeardown, workspaceTeardown} = goog.require('Blockly.test.helpers');
const ASTNode = goog.require('Blockly.ASTNode');
goog.require('Blockly.WorkspaceComment');
@@ -367,36 +368,36 @@ suite('Events', function() {
isStart: false, blockId: thisObj.block.id, blocks: [thisObj.block]})},
{title: 'null to Block Marker move', class: Blockly.Events.MarkerMove,
getArgs: (thisObj) => [thisObj.block, true, null,
new Blockly.ASTNode(Blockly.ASTNode.types.BLOCK, thisObj.block)],
new ASTNode(ASTNode.types.BLOCK, thisObj.block)],
getExpectedJson: (thisObj) => ({type: 'marker_move',
isCursor: true, blockId: thisObj.block.id, oldNode: null,
newNode: new Blockly.ASTNode(Blockly.ASTNode.types.BLOCK,
newNode: new ASTNode(ASTNode.types.BLOCK,
thisObj.block)})},
{title: 'null to Workspace Marker move', class: Blockly.Events.MarkerMove,
getArgs: (thisObj) => [null, true, null,
Blockly.ASTNode.createWorkspaceNode(thisObj.workspace,
ASTNode.createWorkspaceNode(thisObj.workspace,
new Blockly.utils.Coordinate(0, 0))],
getExpectedJson: (thisObj) => ({type: 'marker_move',
isCursor: true, blockId: null, oldNode: null,
newNode: Blockly.ASTNode.createWorkspaceNode(thisObj.workspace,
newNode: ASTNode.createWorkspaceNode(thisObj.workspace,
new Blockly.utils.Coordinate(0, 0))})},
{title: 'Workspace to Block Marker move',
class: Blockly.Events.MarkerMove,
getArgs: (thisObj) => [thisObj.block, true,
Blockly.ASTNode.createWorkspaceNode(thisObj.workspace,
ASTNode.createWorkspaceNode(thisObj.workspace,
new Blockly.utils.Coordinate(0, 0)),
new Blockly.ASTNode(Blockly.ASTNode.types.BLOCK, thisObj.block)],
new ASTNode(ASTNode.types.BLOCK, thisObj.block)],
getExpectedJson: (thisObj) => ({type: 'marker_move',
isCursor: true, blockId: thisObj.block.id,
oldNode: Blockly.ASTNode.createWorkspaceNode(thisObj.workspace,
oldNode: ASTNode.createWorkspaceNode(thisObj.workspace,
new Blockly.utils.Coordinate(0, 0)),
newNode: new Blockly.ASTNode(Blockly.ASTNode.types.BLOCK,
newNode: new ASTNode(ASTNode.types.BLOCK,
thisObj.block)})},
{title: 'Block to Workspace Marker move',
class: Blockly.Events.MarkerMove,
getArgs: (thisObj) => [null, true,
new Blockly.ASTNode(Blockly.ASTNode.types.BLOCK, thisObj.block),
Blockly.ASTNode.createWorkspaceNode(thisObj.workspace,
new ASTNode(ASTNode.types.BLOCK, thisObj.block),
ASTNode.createWorkspaceNode(thisObj.workspace,
new Blockly.utils.Coordinate(0, 0))]},
{title: 'Selected', class: Blockly.Events.Selected,
getArgs: (thisObj) => [null, thisObj.block.id, thisObj.workspace.id],