From c86c8f8e926c6a8a8651ae215b04da8f4e87222a Mon Sep 17 00:00:00 2001 From: Aaron Dodson Date: Thu, 12 Aug 2021 09:55:38 -0700 Subject: [PATCH] Migrate core/variables.js to goog.module syntax (#5321) * Migrate core/variables.js to ES6 const/let * Migrate core/variables.js to goog.module * Migrate core/variables.js to named requires * clang-format core/variables.js * Add JSDoc and make testdeps function test-only * Fix return type for getTestDeps * Migrate to new style of exposing methods for mocking in core/variables.js --- core/variables.js | 402 +++++++++++++---------------- tests/deps.js | 2 +- tests/mocha/field_variable_test.js | 4 +- 3 files changed, 189 insertions(+), 219 deletions(-) diff --git a/core/variables.js b/core/variables.js index 223838a2b..f468163c4 100644 --- a/core/variables.js +++ b/core/variables.js @@ -14,44 +14,36 @@ * @name Blockly.Variables * @namespace */ -goog.provide('Blockly.Variables'); +goog.module('Blockly.Variables'); +goog.module.declareLegacyNamespace(); -goog.require('Blockly.Blocks'); -goog.require('Blockly.internalConstants'); -goog.require('Blockly.Msg'); -goog.require('Blockly.utils'); -goog.require('Blockly.utils.xml'); -goog.require('Blockly.VariableModel'); -goog.require('Blockly.Xml'); +const Blocks = goog.require('Blockly.Blocks'); +const Msg = goog.require('Blockly.Msg'); +const VariableModel = goog.require('Blockly.VariableModel'); +/* eslint-disable-next-line no-unused-vars */ +const Workspace = goog.requireType('Blockly.Workspace'); +const Xml = goog.require('Blockly.Xml'); +const utilsXml = goog.require('Blockly.utils.xml'); -goog.requireType('Blockly.Workspace'); - - -/** - * Constant to separate variable names from procedures and generated functions - * when running generators. - * @deprecated Use Blockly.internalConstants.VARIABLE_CATEGORY_NAME - */ -Blockly.Variables.NAME_TYPE = Blockly.internalConstants.VARIABLE_CATEGORY_NAME; /** * Find all user-created variables that are in use in the workspace. * For use by generators. * To get a list of all variables on a workspace, including unused variables, * call Workspace.getAllVariables. - * @param {!Blockly.Workspace} ws The workspace to search for variables. - * @return {!Array} Array of variable models. + * @param {!Workspace} ws The workspace to search for variables. + * @return {!Array} Array of variable models. */ -Blockly.Variables.allUsedVarModels = function(ws) { - var blocks = ws.getAllBlocks(false); - var variableHash = Object.create(null); +const allUsedVarModels = function(ws) { + const blocks = ws.getAllBlocks(false); + const variableHash = Object.create(null); // Iterate through every block and add each variable to the hash. - for (var i = 0; i < blocks.length; i++) { - var blockVariables = blocks[i].getVarModels(); + for (let i = 0; i < blocks.length; i++) { + const blockVariables = blocks[i].getVarModels(); if (blockVariables) { - for (var j = 0; j < blockVariables.length; j++) { - var variable = blockVariables[j]; - var id = variable.getId(); + for (let j = 0; j < blockVariables.length; j++) { + const variable = blockVariables[j]; + const id = variable.getId(); if (id) { variableHash[id] = variable; } @@ -59,18 +51,18 @@ Blockly.Variables.allUsedVarModels = function(ws) { } } // Flatten the hash into a list. - var variableList = []; - for (var id in variableHash) { + const variableList = []; + for (const id in variableHash) { variableList.push(variableHash[id]); } return variableList; }; +exports.allUsedVarModels = allUsedVarModels; /** - * @private * @type {Object} */ -Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_ = {}; +const ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE = {}; /** * Find all developer variables used by blocks in the workspace. @@ -79,29 +71,28 @@ Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_ = {}; * To declare developer variables, define the getDeveloperVariables function on * your block and return a list of variable names. * For use by generators. - * @param {!Blockly.Workspace} workspace The workspace to search. + * @param {!Workspace} workspace The workspace to search. * @return {!Array} A list of non-duplicated variable names. */ -Blockly.Variables.allDeveloperVariables = function(workspace) { - var blocks = workspace.getAllBlocks(false); - var variableHash = Object.create(null); - for (var i = 0, block; (block = blocks[i]); i++) { - var getDeveloperVariables = block.getDeveloperVariables; +const allDeveloperVariables = function(workspace) { + const blocks = workspace.getAllBlocks(false); + const variableHash = Object.create(null); + for (let i = 0, block; (block = blocks[i]); i++) { + let getDeveloperVariables = block.getDeveloperVariables; if (!getDeveloperVariables && block.getDeveloperVars) { // August 2018: getDeveloperVars() was deprecated and renamed // getDeveloperVariables(). getDeveloperVariables = block.getDeveloperVars; - if (!Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[ - block.type]) { - console.warn('Function getDeveloperVars() deprecated. Use ' + + if (!ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE[block.type]) { + console.warn( + 'Function getDeveloperVars() deprecated. Use ' + 'getDeveloperVariables() (block type \'' + block.type + '\')'); - Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[ - block.type] = true; + ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE[block.type] = true; } } if (getDeveloperVariables) { - var devVars = getDeveloperVariables(); - for (var j = 0; j < devVars.length; j++) { + const devVars = getDeveloperVariables(); + for (let j = 0; j < devVars.length; j++) { variableHash[devVars[j]] = true; } } @@ -110,57 +101,57 @@ Blockly.Variables.allDeveloperVariables = function(workspace) { // Flatten the hash into a list. return Object.keys(variableHash); }; +exports.allDeveloperVariables = allDeveloperVariables; /** * Construct the elements (blocks and button) required by the flyout for the * variable category. - * @param {!Blockly.Workspace} workspace The workspace containing variables. + * @param {!Workspace} workspace The workspace containing variables. * @return {!Array} Array of XML elements. */ -Blockly.Variables.flyoutCategory = function(workspace) { - var xmlList = []; - var button = document.createElement('button'); +const flyoutCategory = function(workspace) { + let xmlList = []; + const button = document.createElement('button'); button.setAttribute('text', '%{BKY_NEW_VARIABLE}'); button.setAttribute('callbackKey', 'CREATE_VARIABLE'); workspace.registerButtonCallback('CREATE_VARIABLE', function(button) { - Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace()); + createVariableButtonHandler(button.getTargetWorkspace()); }); xmlList.push(button); - var blockList = Blockly.Variables.flyoutCategoryBlocks(workspace); + const blockList = flyoutCategoryBlocks(workspace); xmlList = xmlList.concat(blockList); return xmlList; }; +exports.flyoutCategory = flyoutCategory; /** * Construct the blocks required by the flyout for the variable category. - * @param {!Blockly.Workspace} workspace The workspace containing variables. + * @param {!Workspace} workspace The workspace containing variables. * @return {!Array} Array of XML block elements. */ -Blockly.Variables.flyoutCategoryBlocks = function(workspace) { - var variableModelList = workspace.getVariablesOfType(''); +const flyoutCategoryBlocks = function(workspace) { + const variableModelList = workspace.getVariablesOfType(''); - var xmlList = []; + const xmlList = []; if (variableModelList.length > 0) { // New variables are added to the end of the variableModelList. - var mostRecentVariable = variableModelList[variableModelList.length - 1]; - if (Blockly.Blocks['variables_set']) { - var block = Blockly.utils.xml.createElement('block'); + const mostRecentVariable = variableModelList[variableModelList.length - 1]; + if (Blocks['variables_set']) { + const block = utilsXml.createElement('block'); block.setAttribute('type', 'variables_set'); - block.setAttribute('gap', Blockly.Blocks['math_change'] ? 8 : 24); - block.appendChild( - Blockly.Variables.generateVariableFieldDom(mostRecentVariable)); + block.setAttribute('gap', Blocks['math_change'] ? 8 : 24); + block.appendChild(generateVariableFieldDom(mostRecentVariable)); xmlList.push(block); } - if (Blockly.Blocks['math_change']) { - var block = Blockly.utils.xml.createElement('block'); + if (Blocks['math_change']) { + const block = utilsXml.createElement('block'); block.setAttribute('type', 'math_change'); - block.setAttribute('gap', Blockly.Blocks['variables_get'] ? 20 : 8); - block.appendChild( - Blockly.Variables.generateVariableFieldDom(mostRecentVariable)); - var value = Blockly.Xml.textToDom( + block.setAttribute('gap', Blocks['variables_get'] ? 20 : 8); + block.appendChild(generateVariableFieldDom(mostRecentVariable)); + const value = Xml.textToDom( '' + '' + '1' + @@ -170,35 +161,35 @@ Blockly.Variables.flyoutCategoryBlocks = function(workspace) { xmlList.push(block); } - if (Blockly.Blocks['variables_get']) { - variableModelList.sort(Blockly.VariableModel.compareByName); - for (var i = 0, variable; (variable = variableModelList[i]); i++) { - var block = Blockly.utils.xml.createElement('block'); + if (Blocks['variables_get']) { + variableModelList.sort(VariableModel.compareByName); + for (let i = 0, variable; (variable = variableModelList[i]); i++) { + const block = utilsXml.createElement('block'); block.setAttribute('type', 'variables_get'); block.setAttribute('gap', 8); - block.appendChild(Blockly.Variables.generateVariableFieldDom(variable)); + block.appendChild(generateVariableFieldDom(variable)); xmlList.push(block); } } } return xmlList; }; +exports.flyoutCategoryBlocks = flyoutCategoryBlocks; -Blockly.Variables.VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh'; // No 'l'. +const VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh'; // No 'l'. +exports.VAR_LETTER_OPTIONS = VAR_LETTER_OPTIONS; /** * Return a new variable name that is not yet being used. This will try to * generate single letter variable names in the range 'i' to 'z' to start with. * If no unique name is located it will try 'i' to 'z', 'a' to 'h', * then 'i2' to 'z2' etc. Skip 'l'. - * @param {!Blockly.Workspace} workspace The workspace to be unique in. + * @param {!Workspace} workspace The workspace to be unique in. * @return {string} New variable name. */ -Blockly.Variables.generateUniqueName = function(workspace) { - return Blockly.Variables.generateUniqueNameFromOptions( - Blockly.Variables.VAR_LETTER_OPTIONS.charAt(0), - workspace.getAllVariableNames() - ); +exports.generateUniqueName = function(workspace) { + return generateUniqueNameFromOptions( + VAR_LETTER_OPTIONS.charAt(0), workspace.getAllVariableNames()); }; /** @@ -209,20 +200,20 @@ Blockly.Variables.generateUniqueName = function(workspace) { * @param {!Array} usedNames A list of all of the used names. * @return {string} A unique name that is not present in the usedNames array. */ -Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames) { +const generateUniqueNameFromOptions = function(startChar, usedNames) { if (!usedNames.length) { return startChar; } - var letters = Blockly.Variables.VAR_LETTER_OPTIONS; - var suffix = ''; - var letterIndex = letters.indexOf(startChar); - var potName = startChar; + const letters = VAR_LETTER_OPTIONS; + let suffix = ''; + let letterIndex = letters.indexOf(startChar); + let potName = startChar; // eslint-disable-next-line no-constant-condition while (true) { - var inUse = false; - for (var i = 0; i < usedNames.length; i++) { + let inUse = false; + for (let i = 0; i < usedNames.length; i++) { if (usedNames[i].toLowerCase() == potName) { inUse = true; break; @@ -241,6 +232,7 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames) potName = letters.charAt(letterIndex) + suffix; } }; +exports.generateUniqueNameFromOptions = generateUniqueNameFromOptions; /** * Handles "Create Variable" button in the default variables toolbox category. @@ -251,7 +243,7 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames) * types and after-creation processing. More complex customization (e.g., * prompting for variable type) is beyond the scope of this function. * - * @param {!Blockly.Workspace} workspace The workspace on which to create the + * @param {!Workspace} workspace The workspace on which to create the * variable. * @param {function(?string=)=} opt_callback A callback. It will be passed an * acceptable new variable name, or null if change is to be aborted (cancel @@ -259,107 +251,88 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames) * @param {string=} opt_type The type of the variable like 'int', 'string', or * ''. This will default to '', which is a specific type. */ -Blockly.Variables.createVariableButtonHandler = function( +const createVariableButtonHandler = function( workspace, opt_callback, opt_type) { - var type = opt_type || ''; + const type = opt_type || ''; // This function needs to be named so it can be called recursively. - var promptAndCheckWithAlert = function(defaultName) { - Blockly.Variables.promptName(Blockly.Msg['NEW_VARIABLE_TITLE'], defaultName, - function(text) { - if (text) { - var existing = - Blockly.Variables.nameUsedWithAnyType(text, workspace); - if (existing) { - if (existing.type == type) { - var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS'].replace( - '%1', existing.name); - } else { - var msg = - Blockly.Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE']; - msg = msg.replace('%1', existing.name).replace('%2', existing.type); - } - Blockly.alert(msg, - function() { - promptAndCheckWithAlert(text); // Recurse - }); - } else { - // No conflict - workspace.createVariable(text, type); - if (opt_callback) { - opt_callback(text); - } - } + const promptAndCheckWithAlert = function(defaultName) { + promptName(Msg['NEW_VARIABLE_TITLE'], defaultName, function(text) { + if (text) { + const existing = nameUsedWithAnyType(text, workspace); + if (existing) { + let msg; + if (existing.type == type) { + msg = Msg['VARIABLE_ALREADY_EXISTS'].replace('%1', existing.name); } else { - // User canceled prompt. - if (opt_callback) { - opt_callback(null); - } + msg = Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE']; + msg = msg.replace('%1', existing.name).replace('%2', existing.type); } - }); + Blockly.alert(msg, function() { + promptAndCheckWithAlert(text); // Recurse + }); + } else { + // No conflict + workspace.createVariable(text, type); + if (opt_callback) { + opt_callback(text); + } + } + } else { + // User canceled prompt. + if (opt_callback) { + opt_callback(null); + } + } + }); }; promptAndCheckWithAlert(''); }; - -/** - * Original name of Blockly.Variables.createVariableButtonHandler(..). - * @deprecated Use Blockly.Variables.createVariableButtonHandler(..). - * - * @param {!Blockly.Workspace} workspace The workspace on which to create the - * variable. - * @param {function(?string=)=} opt_callback A callback. It will be passed an - * acceptable new variable name, or null if change is to be aborted (cancel - * button), or undefined if an existing variable was chosen. - * @param {string=} opt_type The type of the variable like 'int', 'string', or - * ''. This will default to '', which is a specific type. - */ -Blockly.Variables.createVariable = - Blockly.Variables.createVariableButtonHandler; +exports.createVariableButtonHandler = createVariableButtonHandler; /** * Opens a prompt that allows the user to enter a new name for a variable. * Triggers a rename if the new name is valid. Or re-prompts if there is a * collision. - * @param {!Blockly.Workspace} workspace The workspace on which to rename the + * @param {!Workspace} workspace The workspace on which to rename the * variable. - * @param {!Blockly.VariableModel} variable Variable to rename. + * @param {!VariableModel} variable Variable to rename. * @param {function(?string=)=} opt_callback A callback. It will * be passed an acceptable new variable name, or null if change is to be * aborted (cancel button), or undefined if an existing variable was chosen. */ -Blockly.Variables.renameVariable = function(workspace, variable, opt_callback) { +const renameVariable = function(workspace, variable, opt_callback) { // This function needs to be named so it can be called recursively. - var promptAndCheckWithAlert = function(defaultName) { - var promptText = - Blockly.Msg['RENAME_VARIABLE_TITLE'].replace('%1', variable.name); - Blockly.Variables.promptName(promptText, defaultName, - function(newName) { - if (newName) { - var existing = Blockly.Variables.nameUsedWithOtherType_(newName, - variable.type, workspace); - if (existing) { - var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE'] - .replace('%1', existing.name) - .replace('%2', existing.type); - Blockly.alert(msg, - function() { - promptAndCheckWithAlert(newName); // Recurse - }); - } else { - workspace.renameVariableById(variable.getId(), newName); - if (opt_callback) { - opt_callback(newName); - } - } - } else { - // User canceled prompt. - if (opt_callback) { - opt_callback(null); - } + const promptAndCheckWithAlert = function(defaultName) { + const promptText = + Msg['RENAME_VARIABLE_TITLE'].replace('%1', variable.name); + promptName(promptText, defaultName, function(newName) { + if (newName) { + const existing = + nameUsedWithOtherType(newName, variable.type, workspace); + if (existing) { + const msg = Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE'] + .replace('%1', existing.name) + .replace('%2', existing.type); + Blockly.alert(msg, function() { + promptAndCheckWithAlert(newName); // Recurse + }); + } else { + workspace.renameVariableById(variable.getId(), newName); + if (opt_callback) { + opt_callback(newName); } - }); + } + } else { + // User canceled prompt. + if (opt_callback) { + opt_callback(null); + } + } + }); }; promptAndCheckWithAlert(''); }; +exports.renameVariable = renameVariable; /** * Prompt the user for a new variable name. @@ -368,14 +341,13 @@ Blockly.Variables.renameVariable = function(workspace, variable, opt_callback) { * @param {function(?string)} callback A callback. It will return the new * variable name, or null if the user picked something illegal. */ -Blockly.Variables.promptName = function(promptText, defaultText, callback) { +const promptName = function(promptText, defaultText, callback) { Blockly.prompt(promptText, defaultText, function(newVar) { // Merge runs of whitespace. Strip leading and trailing whitespace. // Beyond this, all names are legal. if (newVar) { newVar = newVar.replace(/[\s\xa0]+/g, ' ').trim(); - if (newVar == Blockly.Msg['RENAME_VARIABLE'] || - newVar == Blockly.Msg['NEW_VARIABLE']) { + if (newVar == Msg['RENAME_VARIABLE'] || newVar == Msg['NEW_VARIABLE']) { // Ok, not ALL names are legal... newVar = null; } @@ -383,23 +355,23 @@ Blockly.Variables.promptName = function(promptText, defaultText, callback) { callback(newVar); }); }; +exports.promptName = promptName; /** * Check whether there exists a variable with the given name but a different * type. * @param {string} name The name to search for. * @param {string} type The type to exclude from the search. - * @param {!Blockly.Workspace} workspace The workspace to search for the + * @param {!Workspace} workspace The workspace to search for the * variable. - * @return {?Blockly.VariableModel} The variable with the given name and a + * @return {?VariableModel} The variable with the given name and a * different type, or null if none was found. - * @private */ -Blockly.Variables.nameUsedWithOtherType_ = function(name, type, workspace) { - var allVariables = workspace.getVariableMap().getAllVariables(); +const nameUsedWithOtherType = function(name, type, workspace) { + const allVariables = workspace.getVariableMap().getAllVariables(); name = name.toLowerCase(); - for (var i = 0, variable; (variable = allVariables[i]); i++) { + for (let i = 0, variable; (variable = allVariables[i]); i++) { if (variable.name.toLowerCase() == name && variable.type != type) { return variable; } @@ -410,84 +382,82 @@ Blockly.Variables.nameUsedWithOtherType_ = function(name, type, workspace) { /** * Check whether there exists a variable with the given name of any type. * @param {string} name The name to search for. - * @param {!Blockly.Workspace} workspace The workspace to search for the + * @param {!Workspace} workspace The workspace to search for the * variable. - * @return {?Blockly.VariableModel} The variable with the given name, + * @return {?VariableModel} The variable with the given name, * or null if none was found. */ -Blockly.Variables.nameUsedWithAnyType = function(name, workspace) { - var allVariables = workspace.getVariableMap().getAllVariables(); +const nameUsedWithAnyType = function(name, workspace) { + const allVariables = workspace.getVariableMap().getAllVariables(); name = name.toLowerCase(); - for (var i = 0, variable; (variable = allVariables[i]); i++) { + for (let i = 0, variable; (variable = allVariables[i]); i++) { if (variable.name.toLowerCase() == name) { return variable; } } return null; }; +exports.nameUsedWithAnyType = nameUsedWithAnyType; /** * Generate DOM objects representing a variable field. - * @param {!Blockly.VariableModel} variableModel The variable model to + * @param {!VariableModel} variableModel The variable model to * represent. * @return {?Element} The generated DOM. - * @public */ -Blockly.Variables.generateVariableFieldDom = function(variableModel) { +const generateVariableFieldDom = function(variableModel) { /* Generates the following XML: * foo */ - var field = Blockly.utils.xml.createElement('field'); + const field = utilsXml.createElement('field'); field.setAttribute('name', 'VAR'); field.setAttribute('id', variableModel.getId()); field.setAttribute('variabletype', variableModel.type); - var name = Blockly.utils.xml.createTextNode(variableModel.name); + const name = utilsXml.createTextNode(variableModel.name); field.appendChild(name); return field; }; +exports.generateVariableFieldDom = generateVariableFieldDom; /** * Helper function to look up or create a variable on the given workspace. * If no variable exists, creates and returns it. - * @param {!Blockly.Workspace} workspace The workspace to search for the + * @param {!Workspace} workspace The workspace to search for the * variable. It may be a flyout workspace or main workspace. * @param {?string} id The ID to use to look up or create the variable, or null. * @param {string=} opt_name The string to use to look up or create the * variable. * @param {string=} opt_type The type to use to look up or create the variable. - * @return {!Blockly.VariableModel} The variable corresponding to the given ID + * @return {!VariableModel} The variable corresponding to the given ID * or name + type combination. */ -Blockly.Variables.getOrCreateVariablePackage = function(workspace, id, opt_name, - opt_type) { - var variable = Blockly.Variables.getVariable(workspace, id, opt_name, - opt_type); +const getOrCreateVariablePackage = function(workspace, id, opt_name, opt_type) { + let variable = getVariable(workspace, id, opt_name, opt_type); if (!variable) { - variable = Blockly.Variables.createVariable_(workspace, id, opt_name, - opt_type); + variable = createVariable(workspace, id, opt_name, opt_type); } return variable; }; +exports.getOrCreateVariablePackage = getOrCreateVariablePackage; /** * Look up a variable on the given workspace. * Always looks in the main workspace before looking in the flyout workspace. * Always prefers lookup by ID to lookup by name + type. - * @param {!Blockly.Workspace} workspace The workspace to search for the + * @param {!Workspace} workspace The workspace to search for the * variable. It may be a flyout workspace or main workspace. * @param {?string} id The ID to use to look up the variable, or null. * @param {string=} opt_name The string to use to look up the variable. * Only used if lookup by ID fails. * @param {string=} opt_type The type to use to look up the variable. * Only used if lookup by ID fails. - * @return {?Blockly.VariableModel} The variable corresponding to the given ID + * @return {?VariableModel} The variable corresponding to the given ID * or name + type combination, or null if not found. - * @public */ -Blockly.Variables.getVariable = function(workspace, id, opt_name, opt_type) { - var potentialVariableMap = workspace.getPotentialVariableMap(); - var variable = null; +const getVariable = function(workspace, id, opt_name, opt_type) { + const potentialVariableMap = workspace.getPotentialVariableMap(); + let variable = null; // Try to just get the variable, by ID if possible. if (id) { // Look in the real variable map before checking the potential variable map. @@ -513,29 +483,28 @@ Blockly.Variables.getVariable = function(workspace, id, opt_name, opt_type) { } return variable; }; +exports.getVariable = getVariable; /** * Helper function to create a variable on the given workspace. - * @param {!Blockly.Workspace} workspace The workspace in which to create the + * @param {!Workspace} workspace The workspace in which to create the * variable. It may be a flyout workspace or main workspace. * @param {?string} id The ID to use to create the variable, or null. * @param {string=} opt_name The string to use to create the variable. * @param {string=} opt_type The type to use to create the variable. - * @return {!Blockly.VariableModel} The variable corresponding to the given ID + * @return {!VariableModel} The variable corresponding to the given ID * or name + type combination. - * @private */ -Blockly.Variables.createVariable_ = function(workspace, id, opt_name, - opt_type) { - var potentialVariableMap = workspace.getPotentialVariableMap(); +const createVariable = function(workspace, id, opt_name, opt_type) { + const potentialVariableMap = workspace.getPotentialVariableMap(); // Variables without names get uniquely named for this workspace. if (!opt_name) { - var ws = workspace.isFlyout ? workspace.targetWorkspace : workspace; - opt_name = Blockly.Variables.generateUniqueName(ws); + const ws = workspace.isFlyout ? workspace.targetWorkspace : workspace; + opt_name = exports.generateUniqueName(ws); } // Create a potential variable if in the flyout. - var variable = null; + let variable = null; if (potentialVariableMap) { variable = potentialVariableMap.createVariable(opt_name, opt_type, id); } else { // In the main workspace, create a real variable. @@ -548,20 +517,19 @@ Blockly.Variables.createVariable_ = function(workspace, id, opt_name, * Helper function to get the list of variables that have been added to the * workspace after adding a new block, using the given list of variables that * were in the workspace before the new block was added. - * @param {!Blockly.Workspace} workspace The workspace to inspect. - * @param {!Array} originalVariables The array of + * @param {!Workspace} workspace The workspace to inspect. + * @param {!Array} originalVariables The array of * variables that existed in the workspace before adding the new block. - * @return {!Array} The new array of variables that + * @return {!Array} The new array of variables that * were freshly added to the workspace after creating the new block, * or [] if no new variables were added to the workspace. - * @package */ -Blockly.Variables.getAddedVariables = function(workspace, originalVariables) { - var allCurrentVariables = workspace.getAllVariables(); - var addedVariables = []; +const getAddedVariables = function(workspace, originalVariables) { + const allCurrentVariables = workspace.getAllVariables(); + const addedVariables = []; if (originalVariables.length != allCurrentVariables.length) { - for (var i = 0; i < allCurrentVariables.length; i++) { - var variable = allCurrentVariables[i]; + for (let i = 0; i < allCurrentVariables.length; i++) { + const variable = allCurrentVariables[i]; // For any variable that is present in allCurrentVariables but not // present in originalVariables, add the variable to addedVariables. if (originalVariables.indexOf(variable) == -1) { @@ -571,3 +539,5 @@ Blockly.Variables.getAddedVariables = function(workspace, originalVariables) { } return addedVariables; }; +/** @package */ +exports.getAddedVariables = getAddedVariables; diff --git a/tests/deps.js b/tests/deps.js index 8e73990eb..f6348dbeb 100644 --- a/tests/deps.js +++ b/tests/deps.js @@ -213,7 +213,7 @@ goog.addDependency('../../core/utils/useragent.js', ['Blockly.utils.userAgent'], goog.addDependency('../../core/utils/xml.js', ['Blockly.utils.xml'], []); goog.addDependency('../../core/variable_map.js', ['Blockly.VariableMap'], ['Blockly.Events', 'Blockly.Events.VarDelete', 'Blockly.Events.VarRename', 'Blockly.Msg', 'Blockly.Names', 'Blockly.VariableModel', 'Blockly.utils', 'Blockly.utils.object'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('../../core/variable_model.js', ['Blockly.VariableModel'], ['Blockly.Events', 'Blockly.Events.VarCreate', 'Blockly.utils'], {'lang': 'es6', 'module': 'goog'}); -goog.addDependency('../../core/variables.js', ['Blockly.Variables'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Xml', 'Blockly.internalConstants', 'Blockly.utils', 'Blockly.utils.xml']); +goog.addDependency('../../core/variables.js', ['Blockly.Variables'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Xml', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('../../core/variables_dynamic.js', ['Blockly.VariablesDynamic'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Variables', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('../../core/warning.js', ['Blockly.Warning'], ['Blockly.Bubble', 'Blockly.Events', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('../../core/widgetdiv.js', ['Blockly.WidgetDiv'], ['Blockly.common', 'Blockly.utils.dom']); diff --git a/tests/mocha/field_variable_test.js b/tests/mocha/field_variable_test.js index 0048b8e09..eab65a16e 100644 --- a/tests/mocha/field_variable_test.js +++ b/tests/mocha/field_variable_test.js @@ -11,8 +11,8 @@ suite('Variable Fields', function() { sharedTestSetup.call(this); this.workspace = new Blockly.Workspace(); // Stub for default variable name. - sinon.stub(Blockly.Variables, 'generateUniqueName') - .returns(FAKE_VARIABLE_NAME); + sinon.stub(Blockly.Variables, 'generateUniqueName').returns( + FAKE_VARIABLE_NAME); }); teardown(function() { sharedTestTeardown.call(this);