blockly 7.20211209.4 → 8.0.1

package/generators/python/math.js

@@ -41,7 +41,7 @@ Python['math_arithmetic'] = function(block) {
     'MINUS': [' - ', Python.ORDER_ADDITIVE],
     'MULTIPLY': [' * ', Python.ORDER_MULTIPLICATIVE],
     'DIVIDE': [' / ', Python.ORDER_MULTIPLICATIVE],
-    'POWER': [' ** ', Python.ORDER_EXPONENTIATION]
+    'POWER': [' ** ', Python.ORDER_EXPONENTIATION],
   };
   const tuple = OPERATORS[block.getFieldValue('OP')];
   const operator = tuple[0];
@@ -142,7 +142,7 @@ Python['math_constant'] = function(block) {
     'GOLDEN_RATIO': ['(1 + math.sqrt(5)) / 2', Python.ORDER_MULTIPLICATIVE],
     'SQRT2': ['math.sqrt(2)', Python.ORDER_MEMBER],
     'SQRT1_2': ['math.sqrt(1.0 / 2)', Python.ORDER_MEMBER],
-    'INFINITY': ['float(\'inf\')', Python.ORDER_ATOMIC]
+    'INFINITY': ['float(\'inf\')', Python.ORDER_ATOMIC],
   };
   const constant = block.getFieldValue('CONSTANT');
   if (constant !== 'INFINITY') {
@@ -152,65 +152,62 @@ Python['math_constant'] = function(block) {
 };
 
 Python['math_number_property'] = function(block) {
-  // Check if a number is even, odd, prime, whole, positive, or negative
-  // or if it is divisible by certain number. Returns true or false.
-  const number_to_check =
-      Python.valueToCode(
-          block, 'NUMBER_TO_CHECK', Python.ORDER_MULTIPLICATIVE) ||
-      '0';
-  const dropdown_property = block.getFieldValue('PROPERTY');
+   // Check if a number is even, odd, prime, whole, positive, or negative
+   // or if it is divisible by certain number. Returns true or false.
+  const PROPERTIES = {
+    'EVEN': [' % 2 == 0', Python.ORDER_MULTIPLICATIVE, Python.ORDER_RELATIONAL],
+    'ODD': [' % 2 == 1', Python.ORDER_MULTIPLICATIVE, Python.ORDER_RELATIONAL],
+    'WHOLE': [' % 1 == 0', Python.ORDER_MULTIPLICATIVE,
+        Python.ORDER_RELATIONAL],
+    'POSITIVE': [' > 0', Python.ORDER_RELATIONAL, Python.ORDER_RELATIONAL],
+    'NEGATIVE': [' < 0', Python.ORDER_RELATIONAL, Python.ORDER_RELATIONAL],
+    'DIVISIBLE_BY': [null, Python.ORDER_MULTIPLICATIVE,
+        Python.ORDER_RELATIONAL],
+    'PRIME': [null, Python.ORDER_NONE, Python.ORDER_FUNCTION_CALL],
+  }
+  const dropdownProperty = block.getFieldValue('PROPERTY');
+  const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
+  const numberToCheck = Python.valueToCode(block, 'NUMBER_TO_CHECK',
+      inputOrder) || '0';
   let code;
-  if (dropdown_property === 'PRIME') {
+  if (dropdownProperty === 'PRIME') {
+    // Prime is a special case as it is not a one-liner test.
     Python.definitions_['import_math'] = 'import math';
     Python.definitions_['from_numbers_import_Number'] =
         'from numbers import Number';
-    const functionName = Python.provideFunction_('math_isPrime', [
-      'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(n):',
-      '  # https://en.wikipedia.org/wiki/Primality_test#Naive_methods',
-      '  # If n is not a number but a string, try parsing it.',
-      '  if not isinstance(n, Number):', '    try:', '      n = float(n)',
-      '    except:', '      return False',
-      '  if n == 2 or n == 3:', '    return True',
-      '  # False if n is negative, is 1, or not whole,' +
-          ' or if n is divisible by 2 or 3.',
-      '  if n <= 1 or n % 1 != 0 or n % 2 == 0 or n % 3 == 0:',
-      '    return False',
-      '  # Check all the numbers of form 6k +/- 1, up to sqrt(n).',
-      '  for x in range(6, int(math.sqrt(n)) + 2, 6):',
-      '    if n % (x - 1) == 0 or n % (x + 1) == 0:', '      return False',
-      '  return True'
-    ]);
-    code = functionName + '(' + number_to_check + ')';
-    return [code, Python.ORDER_FUNCTION_CALL];
-  }
-  switch (dropdown_property) {
-    case 'EVEN':
-      code = number_to_check + ' % 2 == 0';
-      break;
-    case 'ODD':
-      code = number_to_check + ' % 2 == 1';
-      break;
-    case 'WHOLE':
-      code = number_to_check + ' % 1 == 0';
-      break;
-    case 'POSITIVE':
-      code = number_to_check + ' > 0';
-      break;
-    case 'NEGATIVE':
-      code = number_to_check + ' < 0';
-      break;
-    case 'DIVISIBLE_BY': {
-      const divisor =
-          Python.valueToCode(block, 'DIVISOR', Python.ORDER_MULTIPLICATIVE);
-      // If 'divisor' is some code that evals to 0, Python will raise an error.
-      if (!divisor || divisor === '0') {
-        return ['False', Python.ORDER_ATOMIC];
-      }
-      code = number_to_check + ' % ' + divisor + ' == 0';
-      break;
+    const functionName = Python.provideFunction_('math_isPrime', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(n):
+  # https://en.wikipedia.org/wiki/Primality_test#Naive_methods
+  # If n is not a number but a string, try parsing it.
+  if not isinstance(n, Number):
+    try:
+      n = float(n)
+    except:
+      return False
+  if n == 2 or n == 3:
+    return True
+  # False if n is negative, is 1, or not whole, or if n is divisible by 2 or 3.
+  if n <= 1 or n % 1 != 0 or n % 2 == 0 or n % 3 == 0:
+    return False
+  # Check all the numbers of form 6k +/- 1, up to sqrt(n).
+  for x in range(6, int(math.sqrt(n)) + 2, 6):
+    if n % (x - 1) == 0 or n % (x + 1) == 0:
+      return False
+  return True
+`);
+       code = functionName + '(' + numberToCheck + ')';
+  } else if (dropdownProperty === 'DIVISIBLE_BY') {
+    const divisor = Python.valueToCode(block, 'DIVISOR',
+        Python.ORDER_MULTIPLICATIVE) || '0';
+    // If 'divisor' is some code that evals to 0, Python will raise an error.
+    if (divisor === '0') {
+      return ['False', Python.ORDER_ATOMIC];
     }
-  }
-  return [code, Python.ORDER_RELATIONAL];
+    code = numberToCheck + ' % ' + divisor + ' == 0';
+  } else {
+    code = numberToCheck + suffix;
+  };
+  return [code, outputOrder];
 };
 
 Python['math_change'] = function(block) {
@@ -248,71 +245,72 @@ Python['math_on_list'] = function(block) {
     case 'AVERAGE': {
       Python.definitions_['from_numbers_import_Number'] =
           'from numbers import Number';
-      const functionName = Python.provideFunction_(
-          'math_mean',
-          // This operation excludes null and values that aren't int or float:
-          // math_mean([null, null, "aString", 1, 9]) -> 5.0
-          [
-            'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
-            '  localList = [e for e in myList if isinstance(e, Number)]',
-            '  if not localList: return',
-            '  return float(sum(localList)) / len(localList)'
-          ]);
+      // This operation excludes null and values that aren't int or float:
+      // math_mean([null, null, "aString", 1, 9]) -> 5.0
+      const functionName = Python.provideFunction_('math_mean', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(myList):
+  localList = [e for e in myList if isinstance(e, Number)]
+  if not localList: return
+  return float(sum(localList)) / len(localList)
+`);
       code = functionName + '(' + list + ')';
       break;
     }
     case 'MEDIAN': {
       Python.definitions_['from_numbers_import_Number'] =
           'from numbers import Number';
-      const functionName = Python.provideFunction_(
-          'math_median',
-          // This operation excludes null values:
-          // math_median([null, null, 1, 3]) -> 2.0
-          [
-            'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
-            '  localList = sorted([e for e in myList if isinstance(e, Number)])',
-            '  if not localList: return', '  if len(localList) % 2 == 0:',
-            '    return (localList[len(localList) // 2 - 1] + ' +
-                'localList[len(localList) // 2]) / 2.0',
-            '  else:', '    return localList[(len(localList) - 1) // 2]'
-          ]);
+      // This operation excludes null values:
+      // math_median([null, null, 1, 3]) -> 2.0
+      const functionName = Python.provideFunction_( 'math_median', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(myList):
+  localList = sorted([e for e in myList if isinstance(e, Number)])
+  if not localList: return
+  if len(localList) % 2 == 0:
+    return (localList[len(localList) // 2 - 1] + localList[len(localList) // 2]) / 2.0
+  else:
+    return localList[(len(localList) - 1) // 2]
+`);
       code = functionName + '(' + list + ')';
       break;
     }
     case 'MODE': {
-      const functionName = Python.provideFunction_(
-          'math_modes',
-          // As a list of numbers can contain more than one mode,
-          // the returned result is provided as an array.
-          // Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1]
-          [
-            'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(some_list):',
-            '  modes = []',
-            '  # Using a lists of [item, count] to keep count rather than dict',
-            '  # to avoid "unhashable" errors when the counted item is ' +
-                'itself a list or dict.',
-            '  counts = []', '  maxCount = 1', '  for item in some_list:',
-            '    found = False', '    for count in counts:',
-            '      if count[0] == item:', '        count[1] += 1',
-            '        maxCount = max(maxCount, count[1])',
-            '        found = True',
-            '    if not found:', '      counts.append([item, 1])',
-            '  for counted_item, item_count in counts:',
-            '    if item_count == maxCount:',
-            '      modes.append(counted_item)', '  return modes'
-          ]);
+      // As a list of numbers can contain more than one mode,
+      // the returned result is provided as an array.
+      // Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1]
+      const functionName = Python.provideFunction_('math_modes', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(some_list):
+  modes = []
+  # Using a lists of [item, count] to keep count rather than dict
+  # to avoid "unhashable" errors when the counted item is itself a list or dict.
+  counts = []
+  maxCount = 1
+  for item in some_list:
+    found = False
+    for count in counts:
+      if count[0] == item:
+        count[1] += 1
+        maxCount = max(maxCount, count[1])
+        found = True
+    if not found:
+      counts.append([item, 1])
+  for counted_item, item_count in counts:
+    if item_count == maxCount:
+      modes.append(counted_item)
+  return modes
+`);
       code = functionName + '(' + list + ')';
       break;
     }
     case 'STD_DEV': {
       Python.definitions_['import_math'] = 'import math';
-      const functionName = Python.provideFunction_('math_standard_deviation', [
-        'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(numbers):',
-        '  n = len(numbers)', '  if n == 0: return',
-        '  mean = float(sum(numbers)) / n',
-        '  variance = sum((x - mean) ** 2 for x in numbers) / n',
-        '  return math.sqrt(variance)'
-      ]);
+      const functionName = Python.provideFunction_('math_standard_deviation', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(numbers):
+  n = len(numbers)
+  if n == 0: return
+  mean = float(sum(numbers)) / n
+  variance = sum((x - mean) ** 2 for x in numbers) / n
+  return math.sqrt(variance)
+`);
       code = functionName + '(' + list + ')';
       break;
     }

package/generators/python/text.js

@@ -55,18 +55,18 @@ Python['text_join'] = function(block) {
   // Should we allow joining by '-' or ',' or any other characters?
   switch (block.itemCount_) {
     case 0:
-      return ['\'\'', Python.ORDER_ATOMIC];
+      return ["''", Python.ORDER_ATOMIC];
     case 1: {
       const element =
-          Python.valueToCode(block, 'ADD0', Python.ORDER_NONE) || '\'\'';
+          Python.valueToCode(block, 'ADD0', Python.ORDER_NONE) || "''";
       const codeAndOrder = forceString(element);
       return codeAndOrder;
     }
     case 2: {
       const element0 =
-          Python.valueToCode(block, 'ADD0', Python.ORDER_NONE) || '\'\'';
+          Python.valueToCode(block, 'ADD0', Python.ORDER_NONE) || "''";
       const element1 =
-          Python.valueToCode(block, 'ADD1', Python.ORDER_NONE) || '\'\'';
+          Python.valueToCode(block, 'ADD1', Python.ORDER_NONE) || "''";
       const code = forceString(element0)[0] + ' + ' + forceString(element1)[0];
       return [code, Python.ORDER_ADDITIVE];
     }
@@ -74,7 +74,7 @@ Python['text_join'] = function(block) {
       const elements = [];
       for (let i = 0; i < block.itemCount_; i++) {
         elements[i] =
-            Python.valueToCode(block, 'ADD' + i, Python.ORDER_NONE) || '\'\'';
+            Python.valueToCode(block, 'ADD' + i, Python.ORDER_NONE) || "''";
       }
       const tempVar = Python.nameDB_.getDistinctName('x', NameType.VARIABLE);
       const code = '\'\'.join([str(' + tempVar + ') for ' + tempVar + ' in [' +
@@ -88,19 +88,19 @@ Python['text_append'] = function(block) {
   // Append to a variable in place.
   const varName =
       Python.nameDB_.getName(block.getFieldValue('VAR'), NameType.VARIABLE);
-  const value = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || '\'\'';
+  const value = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || "''";
   return varName + ' = str(' + varName + ') + ' + forceString(value)[0] + '\n';
 };
 
 Python['text_length'] = function(block) {
   // Is the string null or array empty?
-  const text = Python.valueToCode(block, 'VALUE', Python.ORDER_NONE) || '\'\'';
+  const text = Python.valueToCode(block, 'VALUE', Python.ORDER_NONE) || "''";
   return ['len(' + text + ')', Python.ORDER_FUNCTION_CALL];
 };
 
 Python['text_isEmpty'] = function(block) {
   // Is the string null or array empty?
-  const text = Python.valueToCode(block, 'VALUE', Python.ORDER_NONE) || '\'\'';
+  const text = Python.valueToCode(block, 'VALUE', Python.ORDER_NONE) || "''";
   const code = 'not len(' + text + ')';
   return [code, Python.ORDER_LOGICAL_NOT];
 };
@@ -110,9 +110,9 @@ Python['text_indexOf'] = function(block) {
   // Should we allow for non-case sensitive???
   const operator = block.getFieldValue('END') === 'FIRST' ? 'find' : 'rfind';
   const substring =
-      Python.valueToCode(block, 'FIND', Python.ORDER_NONE) || '\'\'';
+      Python.valueToCode(block, 'FIND', Python.ORDER_NONE) || "''";
   const text =
-      Python.valueToCode(block, 'VALUE', Python.ORDER_MEMBER) || '\'\'';
+      Python.valueToCode(block, 'VALUE', Python.ORDER_MEMBER) || "''";
   const code = text + '.' + operator + '(' + substring + ')';
   if (block.workspace.options.oneBasedIndex) {
     return [code + ' + 1', Python.ORDER_ADDITIVE];
@@ -126,7 +126,7 @@ Python['text_charAt'] = function(block) {
   const where = block.getFieldValue('WHERE') || 'FROM_START';
   const textOrder =
       (where === 'RANDOM') ? Python.ORDER_NONE : Python.ORDER_MEMBER;
-  const text = Python.valueToCode(block, 'VALUE', textOrder) || '\'\'';
+  const text = Python.valueToCode(block, 'VALUE', textOrder) || "''";
   switch (where) {
     case 'FIRST': {
       const code = text + '[0]';
@@ -148,10 +148,11 @@ Python['text_charAt'] = function(block) {
     }
     case 'RANDOM': {
       Python.definitions_['import_random'] = 'import random';
-      const functionName = Python.provideFunction_('text_random_letter', [
-        'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(text):',
-        '  x = int(random.random() * len(text))', '  return text[x];'
-      ]);
+      const functionName = Python.provideFunction_('text_random_letter', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(text):
+  x = int(random.random() * len(text))
+  return text[x]
+`);
       const code = functionName + '(' + text + ')';
       return [code, Python.ORDER_FUNCTION_CALL];
     }
@@ -164,7 +165,7 @@ Python['text_getSubstring'] = function(block) {
   const where1 = block.getFieldValue('WHERE1');
   const where2 = block.getFieldValue('WHERE2');
   const text =
-      Python.valueToCode(block, 'STRING', Python.ORDER_MEMBER) || '\'\'';
+      Python.valueToCode(block, 'STRING', Python.ORDER_MEMBER) || "''";
   let at1;
   switch (where1) {
     case 'FROM_START':
@@ -217,7 +218,7 @@ Python['text_changeCase'] = function(block) {
     'TITLECASE': '.title()'
   };
   const operator = OPERATORS[block.getFieldValue('CASE')];
-  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || '\'\'';
+  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || "''";
   const code = text + operator;
   return [code, Python.ORDER_FUNCTION_CALL];
 };
@@ -230,30 +231,33 @@ Python['text_trim'] = function(block) {
     'BOTH': '.strip()'
   };
   const operator = OPERATORS[block.getFieldValue('MODE')];
-  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || '\'\'';
+  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || "''";
   const code = text + operator;
   return [code, Python.ORDER_FUNCTION_CALL];
 };
 
 Python['text_print'] = function(block) {
   // Print statement.
-  const msg = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || '\'\'';
+  const msg = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || "''";
   return 'print(' + msg + ')\n';
 };
 
 Python['text_prompt_ext'] = function(block) {
   // Prompt function.
-  const functionName = Python.provideFunction_('text_prompt', [
-    'def ' + Python.FUNCTION_NAME_PLACEHOLDER_ + '(msg):', '  try:',
-    '    return raw_input(msg)', '  except NameError:', '    return input(msg)'
-  ]);
+  const functionName = Python.provideFunction_('text_prompt', `
+def ${Python.FUNCTION_NAME_PLACEHOLDER_}(msg):
+  try:
+    return raw_input(msg)
+  except NameError:
+    return input(msg)
+`);
   let msg;
   if (block.getField('TEXT')) {
     // Internal message.
     msg = Python.quote_(block.getFieldValue('TEXT'));
   } else {
     // External message.
-    msg = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || '\'\'';
+    msg = Python.valueToCode(block, 'TEXT', Python.ORDER_NONE) || "''";
   }
   let code = functionName + '(' + msg + ')';
   const toNumber = block.getFieldValue('TYPE') === 'NUMBER';
@@ -266,22 +270,22 @@ Python['text_prompt_ext'] = function(block) {
 Python['text_prompt'] = Python['text_prompt_ext'];
 
 Python['text_count'] = function(block) {
-  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || '\'\'';
-  const sub = Python.valueToCode(block, 'SUB', Python.ORDER_NONE) || '\'\'';
+  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || "''";
+  const sub = Python.valueToCode(block, 'SUB', Python.ORDER_NONE) || "''";
   const code = text + '.count(' + sub + ')';
   return [code, Python.ORDER_FUNCTION_CALL];
 };
 
 Python['text_replace'] = function(block) {
-  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || '\'\'';
-  const from = Python.valueToCode(block, 'FROM', Python.ORDER_NONE) || '\'\'';
-  const to = Python.valueToCode(block, 'TO', Python.ORDER_NONE) || '\'\'';
+  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || "''";
+  const from = Python.valueToCode(block, 'FROM', Python.ORDER_NONE) || "''";
+  const to = Python.valueToCode(block, 'TO', Python.ORDER_NONE) || "''";
   const code = text + '.replace(' + from + ', ' + to + ')';
   return [code, Python.ORDER_MEMBER];
 };
 
 Python['text_reverse'] = function(block) {
-  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || '\'\'';
+  const text = Python.valueToCode(block, 'TEXT', Python.ORDER_MEMBER) || "''";
   const code = text + '[::-1]';
   return [code, Python.ORDER_MEMBER];
 };