nodeskini 1.0.0 → 1.0.2

package/blocklySkini/blockly/generators/lua/text.js

@@ -0,0 +1,353 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Lua for text blocks.
+ * @author rodrigoq@google.com (Rodrigo Queiro)
+ */
+'use strict';
+
+goog.provide('Blockly.Lua.texts');
+
+goog.require('Blockly.Lua');
+
+
+Blockly.Lua['text'] = function(block) {
+  // Text value.
+  var code = Blockly.Lua.quote_(block.getFieldValue('TEXT'));
+  return [code, Blockly.Lua.ORDER_ATOMIC];
+};
+
+Blockly.Lua['text_multiline'] = function(block) {
+  // Text value.
+  var code = Blockly.Lua.multiline_quote_(block.getFieldValue('TEXT'));
+  return [code, Blockly.Lua.ORDER_ATOMIC];
+};
+
+Blockly.Lua['text_join'] = function(block) {
+  // Create a string made up of any number of elements of any type.
+  if (block.itemCount_ == 0) {
+    return ['\'\'', Blockly.Lua.ORDER_ATOMIC];
+  } else if (block.itemCount_ == 1) {
+    var element = Blockly.Lua.valueToCode(block, 'ADD0',
+        Blockly.Lua.ORDER_NONE) || '\'\'';
+    var code = 'tostring(' + element + ')';
+    return [code, Blockly.Lua.ORDER_HIGH];
+  } else if (block.itemCount_ == 2) {
+    var element0 = Blockly.Lua.valueToCode(block, 'ADD0',
+        Blockly.Lua.ORDER_CONCATENATION) || '\'\'';
+    var element1 = Blockly.Lua.valueToCode(block, 'ADD1',
+        Blockly.Lua.ORDER_CONCATENATION) || '\'\'';
+    var code = element0 + ' .. ' + element1;
+    return [code, Blockly.Lua.ORDER_CONCATENATION];
+  } else {
+    var elements = [];
+    for (var i = 0; i < block.itemCount_; i++) {
+      elements[i] = Blockly.Lua.valueToCode(block, 'ADD' + i,
+          Blockly.Lua.ORDER_NONE) || '\'\'';
+    }
+    var code = 'table.concat({' + elements.join(', ') + '})';
+    return [code, Blockly.Lua.ORDER_HIGH];
+  }
+};
+
+Blockly.Lua['text_append'] = function(block) {
+  // Append to a variable in place.
+  var varName = Blockly.Lua.variableDB_.getName(
+      block.getFieldValue('VAR'), Blockly.VARIABLE_CATEGORY_NAME);
+  var value = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_CONCATENATION) || '\'\'';
+  return varName + ' = ' + varName + ' .. ' + value + '\n';
+};
+
+Blockly.Lua['text_length'] = function(block) {
+  // String or array length.
+  var text = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_UNARY) || '\'\'';
+  return ['#' + text, Blockly.Lua.ORDER_UNARY];
+};
+
+Blockly.Lua['text_isEmpty'] = function(block) {
+  // Is the string null or array empty?
+  var text = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_UNARY) || '\'\'';
+  return ['#' + text + ' == 0', Blockly.Lua.ORDER_RELATIONAL];
+};
+
+Blockly.Lua['text_indexOf'] = function(block) {
+  // Search the text for a substring.
+  var substring = Blockly.Lua.valueToCode(block, 'FIND',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var text = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  if (block.getFieldValue('END') == 'FIRST') {
+    var functionName = Blockly.Lua.provideFunction_(
+        'firstIndexOf',
+        ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ +
+             '(str, substr) ',
+         '  local i = string.find(str, substr, 1, true)',
+         '  if i == nil then',
+         '    return 0',
+         '  else',
+         '    return i',
+         '  end',
+         'end']);
+  } else {
+    var functionName = Blockly.Lua.provideFunction_(
+        'lastIndexOf',
+        ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ +
+             '(str, substr)',
+         '  local i = string.find(string.reverse(str), ' +
+             'string.reverse(substr), 1, true)',
+         '  if i then',
+         '    return #str + 2 - i - #substr',
+         '  end',
+         '  return 0',
+         'end']);
+  }
+  var code = functionName + '(' + text + ', ' + substring + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_charAt'] = function(block) {
+  // Get letter at index.
+  // Note: Until January 2013 this block did not have the WHERE input.
+  var where = block.getFieldValue('WHERE') || 'FROM_START';
+  var atOrder = (where == 'FROM_END') ? Blockly.Lua.ORDER_UNARY :
+      Blockly.Lua.ORDER_NONE;
+  var at = Blockly.Lua.valueToCode(block, 'AT', atOrder) || '1';
+  var text = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var code;
+  if (where == 'RANDOM') {
+    var functionName = Blockly.Lua.provideFunction_(
+        'text_random_letter',
+        ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(str)',
+         '  local index = math.random(string.len(str))',
+         '  return string.sub(str, index, index)',
+         'end']);
+    code = functionName + '(' + text + ')';
+  } else {
+    if (where == 'FIRST') {
+      var start = '1';
+    } else if (where == 'LAST') {
+      var start = '-1';
+    } else {
+      if (where == 'FROM_START') {
+        var start = at;
+      } else if (where == 'FROM_END') {
+        var start = '-' + at;
+      } else {
+        throw Error('Unhandled option (text_charAt).');
+      }
+    }
+    if (start.match(/^-?\w*$/)) {
+      code = 'string.sub(' + text + ', ' + start + ', ' + start + ')';
+    } else {
+      // use function to avoid reevaluation
+      var functionName = Blockly.Lua.provideFunction_(
+          'text_char_at',
+          ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ +
+               '(str, index)',
+           '  return string.sub(str, index, index)',
+           'end']);
+      code = functionName + '(' + text + ', ' + start + ')';
+    }
+  }
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_getSubstring'] = function(block) {
+  // Get substring.
+  var text = Blockly.Lua.valueToCode(block, 'STRING',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+
+  // Get start index.
+  var where1 = block.getFieldValue('WHERE1');
+  var at1Order = (where1 == 'FROM_END') ? Blockly.Lua.ORDER_UNARY :
+      Blockly.Lua.ORDER_NONE;
+  var at1 = Blockly.Lua.valueToCode(block, 'AT1', at1Order) || '1';
+  if (where1 == 'FIRST') {
+    var start = 1;
+  } else if (where1 == 'FROM_START') {
+    var start = at1;
+  } else if (where1 == 'FROM_END') {
+    var start = '-' + at1;
+  } else {
+    throw Error('Unhandled option (text_getSubstring)');
+  }
+
+  // Get end index.
+  var where2 = block.getFieldValue('WHERE2');
+  var at2Order = (where2 == 'FROM_END') ? Blockly.Lua.ORDER_UNARY :
+      Blockly.Lua.ORDER_NONE;
+  var at2 = Blockly.Lua.valueToCode(block, 'AT2', at2Order) || '1';
+  if (where2 == 'LAST') {
+    var end = -1;
+  } else if (where2 == 'FROM_START') {
+    var end = at2;
+  } else if (where2 == 'FROM_END') {
+    var end = '-' + at2;
+  } else {
+    throw Error('Unhandled option (text_getSubstring)');
+  }
+  var code = 'string.sub(' + text + ', ' + start + ', ' + end + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_changeCase'] = function(block) {
+  // Change capitalization.
+  var operator = block.getFieldValue('CASE');
+  var text = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  if (operator == 'UPPERCASE') {
+    var functionName = 'string.upper';
+  } else if (operator == 'LOWERCASE') {
+    var functionName = 'string.lower';
+  } else if (operator == 'TITLECASE') {
+    var functionName = Blockly.Lua.provideFunction_(
+        'text_titlecase',
+        // There are shorter versions at
+        // http://lua-users.org/wiki/SciteTitleCase
+        // that do not preserve whitespace.
+        ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(str)',
+         '  local buf = {}',
+         '  local inWord = false',
+         '  for i = 1, #str do',
+         '    local c = string.sub(str, i, i)',
+         '    if inWord then',
+         '      table.insert(buf, string.lower(c))',
+         '      if string.find(c, "%s") then',
+         '        inWord = false',
+         '      end',
+         '    else',
+         '      table.insert(buf, string.upper(c))',
+         '      inWord = true',
+         '    end',
+         '  end',
+         '  return table.concat(buf)',
+         'end']);
+  }
+  var code = functionName + '(' + text + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_trim'] = function(block) {
+  // Trim spaces.
+  var OPERATORS = {
+    LEFT: '^%s*(,-)',
+    RIGHT: '(.-)%s*$',
+    BOTH: '^%s*(.-)%s*$'
+  };
+  var operator = OPERATORS[block.getFieldValue('MODE')];
+  var text = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var code = 'string.gsub(' + text + ', "' + operator + '", "%1")';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_print'] = function(block) {
+  // Print statement.
+  var msg = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  return 'print(' + msg + ')\n';
+};
+
+Blockly.Lua['text_prompt_ext'] = function(block) {
+  // Prompt function.
+  if (block.getField('TEXT')) {
+    // Internal message.
+    var msg = Blockly.Lua.quote_(block.getFieldValue('TEXT'));
+  } else {
+    // External message.
+    var msg = Blockly.Lua.valueToCode(block, 'TEXT',
+        Blockly.Lua.ORDER_NONE) || '\'\'';
+  }
+
+  var functionName = Blockly.Lua.provideFunction_(
+      'text_prompt',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(msg)',
+       '  io.write(msg)',
+       '  io.flush()',
+       '  return io.read()',
+       'end']);
+  var code = functionName + '(' + msg + ')';
+
+  var toNumber = block.getFieldValue('TYPE') == 'NUMBER';
+  if (toNumber) {
+    code = 'tonumber(' + code + ', 10)';
+  }
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_prompt'] = Blockly.Lua['text_prompt_ext'];
+
+Blockly.Lua['text_count'] = function(block) {
+  var text = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var sub = Blockly.Lua.valueToCode(block, 'SUB',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var functionName = Blockly.Lua.provideFunction_(
+      'text_count',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_
+        + '(haystack, needle)',
+        '  if #needle == 0 then',
+        '    return #haystack + 1',
+        '  end',
+        '  local i = 1',
+        '  local count = 0',
+        '  while true do',
+        '    i = string.find(haystack, needle, i, true)',
+        '    if i == nil then',
+        '      break',
+        '    end',
+        '    count = count + 1',
+        '    i = i + #needle',
+        '  end',
+        '  return count',
+        'end',
+      ]);
+  var code = functionName + '(' + text + ', ' + sub + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_replace'] = function(block) {
+  var text = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var from = Blockly.Lua.valueToCode(block, 'FROM',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var to = Blockly.Lua.valueToCode(block, 'TO',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var functionName = Blockly.Lua.provideFunction_(
+      'text_replace',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_
+        + '(haystack, needle, replacement)',
+        '  local buf = {}',
+        '  local i = 1',
+        '  while i <= #haystack do',
+        '    if string.sub(haystack, i, i + #needle - 1) == needle then',
+        '      for j = 1, #replacement do',
+        '        table.insert(buf, string.sub(replacement, j, j))',
+        '      end',
+        '      i = i + #needle',
+        '    else',
+        '      table.insert(buf, string.sub(haystack, i, i))',
+        '      i = i + 1',
+        '    end',
+        '  end',
+        '  return table.concat(buf)',
+        'end',
+      ]);
+  var code = functionName + '(' + text + ', ' + from + ', ' + to + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['text_reverse'] = function(block) {
+  var text = Blockly.Lua.valueToCode(block, 'TEXT',
+      Blockly.Lua.ORDER_HIGH) || '\'\'';
+  var code = 'string.reverse(' + text + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};

package/blocklySkini/blockly/generators/lua/variables.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Lua for variable blocks.
+ * @author rodrigoq@google.com (Rodrigo Queiro)
+ */
+'use strict';
+
+goog.provide('Blockly.Lua.variables');
+
+goog.require('Blockly.Lua');
+
+
+Blockly.Lua['variables_get'] = function(block) {
+  // Variable getter.
+  var code = Blockly.Lua.variableDB_.getName(block.getFieldValue('VAR'),
+      Blockly.VARIABLE_CATEGORY_NAME);
+  return [code, Blockly.Lua.ORDER_ATOMIC];
+};
+
+Blockly.Lua['variables_set'] = function(block) {
+  // Variable setter.
+  var argument0 = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_NONE) || '0';
+  var varName = Blockly.Lua.variableDB_.getName(
+      block.getFieldValue('VAR'), Blockly.VARIABLE_CATEGORY_NAME);
+  return varName + ' = ' + argument0 + '\n';
+};

package/blocklySkini/blockly/generators/lua/variables_dynamic.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Lua for dynamic variable blocks.
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Lua.variablesDynamic');
+
+goog.require('Blockly.Lua');
+goog.require('Blockly.Lua.variables');
+
+
+// Lua is dynamically typed.
+Blockly.Lua['variables_get_dynamic'] = Blockly.Lua['variables_get'];
+Blockly.Lua['variables_set_dynamic'] = Blockly.Lua['variables_set'];

package/blocklySkini/blockly/generators/lua.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Helper functions for generating Lua for blocks.
+ * @author rodrigoq@google.com (Rodrigo Queiro)
+ * Based on Ellen Spertus's blocky-lua project.
+ */
+'use strict';
+
+goog.provide('Blockly.Lua');
+
+goog.require('Blockly.Generator');
+goog.require('Blockly.utils.string');
+
+
+/**
+ * Lua code generator.
+ * @type {!Blockly.Generator}
+ */
+Blockly.Lua = new Blockly.Generator('Lua');
+
+/**
+ * List of illegal variable names.
+ * This is not intended to be a security feature.  Blockly is 100% client-side,
+ * so bypassing this list is trivial.  This is intended to prevent users from
+ * accidentally clobbering a built-in object or function.
+ * @private
+ */
+Blockly.Lua.addReservedWords(
+    // Special character
+    '_,' +
+    // From theoriginalbit's script:
+    // https://github.com/espertus/blockly-lua/issues/6
+    '__inext,assert,bit,colors,colours,coroutine,disk,dofile,error,fs,' +
+    'fetfenv,getmetatable,gps,help,io,ipairs,keys,loadfile,loadstring,math,' +
+    'native,next,os,paintutils,pairs,parallel,pcall,peripheral,print,' +
+    'printError,rawequal,rawget,rawset,read,rednet,redstone,rs,select,' +
+    'setfenv,setmetatable,sleep,string,table,term,textutils,tonumber,' +
+    'tostring,turtle,type,unpack,vector,write,xpcall,_VERSION,__indext,' +
+    // Not included in the script, probably because it wasn't enabled:
+    'HTTP,' +
+    // Keywords (http://www.lua.org/pil/1.3.html).
+    'and,break,do,else,elseif,end,false,for,function,if,in,local,nil,not,or,' +
+    'repeat,return,then,true,until,while,' +
+    // Metamethods (http://www.lua.org/manual/5.2/manual.html).
+    'add,sub,mul,div,mod,pow,unm,concat,len,eq,lt,le,index,newindex,call,' +
+    // Basic functions (http://www.lua.org/manual/5.2/manual.html, section 6.1).
+    'assert,collectgarbage,dofile,error,_G,getmetatable,inpairs,load,' +
+    'loadfile,next,pairs,pcall,print,rawequal,rawget,rawlen,rawset,select,' +
+    'setmetatable,tonumber,tostring,type,_VERSION,xpcall,' +
+    // Modules (http://www.lua.org/manual/5.2/manual.html, section 6.3).
+    'require,package,string,table,math,bit32,io,file,os,debug'
+);
+
+/**
+ * Order of operation ENUMs.
+ * http://www.lua.org/manual/5.3/manual.html#3.4.8
+ */
+Blockly.Lua.ORDER_ATOMIC = 0;          // literals
+// The next level was not explicit in documentation and inferred by Ellen.
+Blockly.Lua.ORDER_HIGH = 1;            // Function calls, tables[]
+Blockly.Lua.ORDER_EXPONENTIATION = 2;  // ^
+Blockly.Lua.ORDER_UNARY = 3;           // not # - ~
+Blockly.Lua.ORDER_MULTIPLICATIVE = 4;  // * / %
+Blockly.Lua.ORDER_ADDITIVE = 5;        // + -
+Blockly.Lua.ORDER_CONCATENATION = 6;   // ..
+Blockly.Lua.ORDER_RELATIONAL = 7;      // < > <=  >= ~= ==
+Blockly.Lua.ORDER_AND = 8;             // and
+Blockly.Lua.ORDER_OR = 9;              // or
+Blockly.Lua.ORDER_NONE = 99;
+
+/**
+ * Note: Lua is not supporting zero-indexing since the language itself is
+ * one-indexed, so the generator does not repoct the oneBasedIndex configuration
+ * option used for lists and text.
+ */
+
+/**
+ * Initialise the database of variable names.
+ * @param {!Blockly.Workspace} workspace Workspace to generate code from.
+ */
+Blockly.Lua.init = function(workspace) {
+  // Create a dictionary of definitions to be printed before the code.
+  Blockly.Lua.definitions_ = Object.create(null);
+  // Create a dictionary mapping desired function names in definitions_
+  // to actual function names (to avoid collisions with user functions).
+  Blockly.Lua.functionNames_ = Object.create(null);
+
+  if (!Blockly.Lua.variableDB_) {
+    Blockly.Lua.variableDB_ =
+        new Blockly.Names(Blockly.Lua.RESERVED_WORDS_);
+  } else {
+    Blockly.Lua.variableDB_.reset();
+  }
+  Blockly.Lua.variableDB_.setVariableMap(workspace.getVariableMap());
+};
+
+/**
+ * Prepend the generated code with the variable definitions.
+ * @param {string} code Generated code.
+ * @return {string} Completed code.
+ */
+Blockly.Lua.finish = function(code) {
+  // Convert the definitions dictionary into a list.
+  var definitions = [];
+  for (var name in Blockly.Lua.definitions_) {
+    definitions.push(Blockly.Lua.definitions_[name]);
+  }
+  // Clean up temporary data.
+  delete Blockly.Lua.definitions_;
+  delete Blockly.Lua.functionNames_;
+  Blockly.Lua.variableDB_.reset();
+  return definitions.join('\n\n') + '\n\n\n' + code;
+};
+
+/**
+ * Naked values are top-level blocks with outputs that aren't plugged into
+ * anything. In Lua, an expression is not a legal statement, so we must assign
+ * the value to the (conventionally ignored) _.
+ * http://lua-users.org/wiki/ExpressionsAsStatements
+ * @param {string} line Line of generated code.
+ * @return {string} Legal line of code.
+ */
+Blockly.Lua.scrubNakedValue = function(line) {
+  return 'local _ = ' + line + '\n';
+};
+
+/**
+ * Encode a string as a properly escaped Lua string, complete with
+ * quotes.
+ * @param {string} string Text to encode.
+ * @return {string} Lua string.
+ * @private
+ */
+Blockly.Lua.quote_ = function(string) {
+  string = string.replace(/\\/g, '\\\\')
+                 .replace(/\n/g, '\\\n')
+                 .replace(/'/g, '\\\'');
+  return '\'' + string + '\'';
+};
+
+/**
+ * Encode a string as a properly escaped multiline Lua string, complete with
+ * quotes.
+ * @param {string} string Text to encode.
+ * @return {string} Lua string.
+ * @private
+ */
+Blockly.Lua.multiline_quote_ = function(string) {
+  var lines = string.split(/\n/g).map(Blockly.Lua.quote_);
+  // Join with the following, plus a newline:
+  // .. '\n' ..
+  return lines.join(' .. \'\\n\' ..\n');
+};
+
+/**
+ * Common tasks for generating Lua from blocks.
+ * Handles comments for the specified block and any connected value blocks.
+ * Calls any statements following this block.
+ * @param {!Blockly.Block} block The current block.
+ * @param {string} code The Lua code created for this block.
+ * @param {boolean=} opt_thisOnly True to generate code for only this statement.
+ * @return {string} Lua code with comments and subsequent blocks added.
+ * @private
+ */
+Blockly.Lua.scrub_ = function(block, code, opt_thisOnly) {
+  var commentCode = '';
+  // Only collect comments for blocks that aren't inline.
+  if (!block.outputConnection || !block.outputConnection.targetConnection) {
+    // Collect comment for this block.
+    var comment = block.getCommentText();
+    if (comment) {
+      comment = Blockly.utils.string.wrap(comment,
+          Blockly.Lua.COMMENT_WRAP - 3);
+      commentCode += Blockly.Lua.prefixLines(comment, '-- ') + '\n';
+    }
+    // Collect comments for all value arguments.
+    // Don't collect comments for nested statements.
+    for (var i = 0; i < block.inputList.length; i++) {
+      if (block.inputList[i].type == Blockly.INPUT_VALUE) {
+        var childBlock = block.inputList[i].connection.targetBlock();
+        if (childBlock) {
+          comment = Blockly.Lua.allNestedComments(childBlock);
+          if (comment) {
+            commentCode += Blockly.Lua.prefixLines(comment, '-- ');
+          }
+        }
+      }
+    }
+  }
+  var nextBlock = block.nextConnection && block.nextConnection.targetBlock();
+  var nextCode = opt_thisOnly ? '' : Blockly.Lua.blockToCode(nextBlock);
+  return commentCode + code + nextCode;
+};

package/blocklySkini/blockly/generators/php/colour.js

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2015 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating PHP for colour blocks.
+ * @author daarond@gmail.com (Daaron Dwyer)
+ */
+'use strict';
+
+goog.provide('Blockly.PHP.colour');
+
+goog.require('Blockly.PHP');
+
+
+Blockly.PHP['colour_picker'] = function(block) {
+  // Colour picker.
+  var code = Blockly.PHP.quote_(block.getFieldValue('COLOUR'));
+  return [code, Blockly.PHP.ORDER_ATOMIC];
+};
+
+Blockly.PHP['colour_random'] = function(block) {
+  // Generate a random colour.
+  var functionName = Blockly.PHP.provideFunction_(
+      'colour_random',
+      ['function ' + Blockly.PHP.FUNCTION_NAME_PLACEHOLDER_ + '() {',
+       '  return \'#\' . str_pad(dechex(mt_rand(0, 0xFFFFFF)), ' +
+          '6, \'0\', STR_PAD_LEFT);',
+       '}']);
+  var code = functionName + '()';
+  return [code, Blockly.PHP.ORDER_FUNCTION_CALL];
+};
+
+Blockly.PHP['colour_rgb'] = function(block) {
+  // Compose a colour from RGB components expressed as percentages.
+  var red = Blockly.PHP.valueToCode(block, 'RED',
+      Blockly.PHP.ORDER_COMMA) || 0;
+  var green = Blockly.PHP.valueToCode(block, 'GREEN',
+      Blockly.PHP.ORDER_COMMA) || 0;
+  var blue = Blockly.PHP.valueToCode(block, 'BLUE',
+      Blockly.PHP.ORDER_COMMA) || 0;
+  var functionName = Blockly.PHP.provideFunction_(
+      'colour_rgb',
+      ['function ' + Blockly.PHP.FUNCTION_NAME_PLACEHOLDER_ +
+          '($r, $g, $b) {',
+       '  $r = round(max(min($r, 100), 0) * 2.55);',
+       '  $g = round(max(min($g, 100), 0) * 2.55);',
+       '  $b = round(max(min($b, 100), 0) * 2.55);',
+       '  $hex = \'#\';',
+       '  $hex .= str_pad(dechex($r), 2, \'0\', STR_PAD_LEFT);',
+       '  $hex .= str_pad(dechex($g), 2, \'0\', STR_PAD_LEFT);',
+       '  $hex .= str_pad(dechex($b), 2, \'0\', STR_PAD_LEFT);',
+       '  return $hex;',
+       '}']);
+  var code = functionName + '(' + red + ', ' + green + ', ' + blue + ')';
+  return [code, Blockly.PHP.ORDER_FUNCTION_CALL];
+};
+
+Blockly.PHP['colour_blend'] = function(block) {
+  // Blend two colours together.
+  var c1 = Blockly.PHP.valueToCode(block, 'COLOUR1',
+      Blockly.PHP.ORDER_COMMA) || '\'#000000\'';
+  var c2 = Blockly.PHP.valueToCode(block, 'COLOUR2',
+      Blockly.PHP.ORDER_COMMA) || '\'#000000\'';
+  var ratio = Blockly.PHP.valueToCode(block, 'RATIO',
+      Blockly.PHP.ORDER_COMMA) || 0.5;
+  var functionName = Blockly.PHP.provideFunction_(
+      'colour_blend',
+      ['function ' + Blockly.PHP.FUNCTION_NAME_PLACEHOLDER_ +
+          '($c1, $c2, $ratio) {',
+       '  $ratio = max(min($ratio, 1), 0);',
+       '  $r1 = hexdec(substr($c1, 1, 2));',
+       '  $g1 = hexdec(substr($c1, 3, 2));',
+       '  $b1 = hexdec(substr($c1, 5, 2));',
+       '  $r2 = hexdec(substr($c2, 1, 2));',
+       '  $g2 = hexdec(substr($c2, 3, 2));',
+       '  $b2 = hexdec(substr($c2, 5, 2));',
+       '  $r = round($r1 * (1 - $ratio) + $r2 * $ratio);',
+       '  $g = round($g1 * (1 - $ratio) + $g2 * $ratio);',
+       '  $b = round($b1 * (1 - $ratio) + $b2 * $ratio);',
+       '  $hex = \'#\';',
+       '  $hex .= str_pad(dechex($r), 2, \'0\', STR_PAD_LEFT);',
+       '  $hex .= str_pad(dechex($g), 2, \'0\', STR_PAD_LEFT);',
+       '  $hex .= str_pad(dechex($b), 2, \'0\', STR_PAD_LEFT);',
+       '  return $hex;',
+       '}']);
+  var code = functionName + '(' + c1 + ', ' + c2 + ', ' + ratio + ')';
+  return [code, Blockly.PHP.ORDER_FUNCTION_CALL];
+};