scratch-blocks 2.1.19 → 2.1.21

package/i18n/create_messages.py

@@ -1,162 +0,0 @@
-#!/usr/bin/python
-
-# Generate .js files defining Blockly core and language messages.
-#
-# Copyright 2013 Google Inc.
-# https://developers.google.com/blockly/
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import codecs
-import os
-import re
-import sys
-from common import read_json_file
-
-
-_NEWLINE_PATTERN = re.compile('[\n\r]')
-
-
-def string_is_ascii(s):
-  # This approach is better for compatibility
-  return all(ord(c) < 128 for c in s)
-
-def load_constants(filename):
-  """Read in constants file, which must be output in every language."""
-  constant_defs = read_json_file(filename);
-  constants_text = '\n'
-  for key in constant_defs:
-    value = constant_defs[key]
-    value = value.replace('"', '\\"')
-    constants_text += '\nBlockly.Msg["{0}"] = "{1}";'.format(key, value)
-  return constants_text
-
-def main():
-  """Generate .js files defining Blockly core and language messages."""
-
-  # Process command-line arguments.
-  parser = argparse.ArgumentParser(description='Convert JSON files to JS.')
-  parser.add_argument('--source_lang', default='en',
-                      help='ISO 639-1 source language code')
-  parser.add_argument('--source_lang_file',
-                      default=os.path.join('json', 'en.json'),
-                      help='Path to .json file for source language')
-  parser.add_argument('--source_synonym_file',
-                      default=os.path.join('json', 'synonyms.json'),
-                      help='Path to .json file with synonym definitions')
-  parser.add_argument('--source_constants_file',
-                      default=os.path.join('json', 'constants.json'),
-                      help='Path to .json file with constant definitions')
-  parser.add_argument('--output_dir', default='js/',
-                      help='relative directory for output files')
-  parser.add_argument('--key_file', default='keys.json',
-                      help='relative path to input keys file')
-  parser.add_argument('--quiet', action='store_true', default=False,
-                      help='do not write anything to standard output')
-  parser.add_argument('files', nargs='+', help='input files')
-  args = parser.parse_args()
-  if not args.output_dir.endswith(os.path.sep):
-    args.output_dir += os.path.sep
-
-  # Read in source language .json file, which provides any values missing
-  # in target languages' .json files.
-  source_defs = read_json_file(os.path.join(os.curdir, args.source_lang_file))
-  # Make sure the source file doesn't contain a newline or carriage return.
-  for key, value in source_defs.items():
-    if _NEWLINE_PATTERN.search(value):
-      print('ERROR: definition of {0} in {1} contained a newline character.'.
-            format(key, args.source_lang_file))
-      sys.exit(1)
-  sorted_keys = sorted(source_defs.keys())
-
-  # Read in synonyms file, which must be output in every language.
-  synonym_defs = read_json_file(os.path.join(
-      os.curdir, args.source_synonym_file))
-  # synonym_defs is also being sorted to ensure the same order is kept
-  synonym_text = '\n'.join(['Blockly.Msg.{0} = Blockly.Msg.{1};'.format(
-      key, synonym_defs[key]) for key in sorted(synonym_defs)])
-
-  # Read in constants file, which must be output in every language.
-  constants_text = load_constants(os.path.join(os.curdir, args.source_constants_file))
-
-  # Create each output file.
-  for arg_file in args.files:
-    (_, filename) = os.path.split(arg_file)
-    target_lang = filename[:filename.index('.')]
-    if target_lang not in ('qqq', 'keys', 'synonyms', 'constants'):
-      target_defs = read_json_file(os.path.join(os.curdir, arg_file))
-
-      # Verify that keys are 'ascii'
-      bad_keys = [key for key in target_defs if not string_is_ascii(key)]
-      if bad_keys:
-        print(u'These keys in {0} contain non ascii characters: {1}'.format(
-            filename, ', '.join(bad_keys)))
-
-      # If there's a '\n' or '\r', remove it and print a warning.
-      for key, value in target_defs.items():
-        if _NEWLINE_PATTERN.search(value):
-          print(u'WARNING: definition of {0} in {1} contained '
-                'a newline character.'.
-                format(key, arg_file))
-          target_defs[key] = _NEWLINE_PATTERN.sub(' ', value)
-
-      # Output file.
-      outname = os.path.join(os.curdir, args.output_dir, target_lang + '.js')
-      with codecs.open(outname, 'w', 'utf-8') as outfile:
-        outfile.write(
-            """// This file was automatically generated.  Do not modify.
-
-'use strict';
-
-goog.provide('Blockly.Msg.{0}');
-
-goog.require('Blockly.Msg');
-
-""".format(target_lang.replace('-', '.')))
-        # For each key in the source language file, output the target value
-        # if present; otherwise, output the source language value with a
-        # warning comment.
-        for key in sorted_keys:
-          if key in target_defs:
-            value = target_defs[key]
-            comment = ''
-            del target_defs[key]
-          else:
-            value = source_defs[key]
-            comment = '  // untranslated'
-          value = value.replace('"', '\\"')
-          outfile.write(u'Blockly.Msg["{0}"] = "{1}";{2}\n'.format(
-              key, value, comment))
-
-        # Announce any keys defined only for target language.
-        if target_defs:
-          extra_keys = [key for key in target_defs if key not in synonym_defs]
-          synonym_keys = [key for key in target_defs if key in synonym_defs]
-          if not args.quiet:
-            if extra_keys:
-              print(u'These extra keys appeared in {0}: {1}'.format(
-                  filename, ', '.join(extra_keys)))
-            if synonym_keys:
-              print(u'These synonym keys appeared in {0}: {1}'.format(
-                  filename, ', '.join(synonym_keys)))
-
-        outfile.write(synonym_text)
-        outfile.write(constants_text)
-
-      if not args.quiet:
-        print('Created {0}.'.format(outname))
-
-
-if __name__ == '__main__':
-  main()

package/i18n/create_scratch_msgs.js

@@ -1,68 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const glob = require('glob')
-const assert = require('assert')
-
-// Globals
-const PATH_INPUT = path.resolve(__dirname, '../msg/json/*.json')
-const PATH_OUTPUT = path.resolve(__dirname, '../msg')
-
-let en = fs.readFileSync(path.resolve(__dirname, '../msg/json/en.json'))
-en = JSON.parse(en)
-const enKeys = Object.keys(en).sort().toString()
-
-// Check that translation is valid:
-// entry: array [key, translation]  corresponding to a single string from <locale>.json
-// - messages with placeholders have the same number of placeholders
-// - messages must not have newlines embedded
-const validateEntry = function (entry) {
-  const re = /(%\d)/g
-  const [key, translation] = entry
-  const enMatch = en[key].match(re)
-  const tMatch = translation.match(re)
-  const enCount = enMatch ? enMatch.length : 0
-  const tCount = tMatch ? tMatch.length : 0
-  assert.strictEqual(tCount, enCount, `${key}:${en[key]} - "${translation}" placeholder mismatch`)
-  if (enCount > 0) {
-    assert.notStrictEqual(tMatch, null, `${key} is missing a placeholder: ${translation}`)
-    assert.strictEqual(
-      tMatch.sort().toString(),
-      enMatch.sort().toString(),
-      `${key} is missing or has duplicate placeholders: ${translation}`,
-    )
-  }
-  assert.strictEqual(translation.match(/[\n]/), null, `${key} contains a newline character ${translation}`)
-}
-
-const validate = function (json, name) {
-  assert.strictEqual(Object.keys(json).sort().toString(), enKeys, `${name}: Locale json keys do not match en.json`)
-  Object.entries(json).forEach(validateEntry)
-}
-
-let file = `// This file was automatically generated.  Do not modify.
-
-'use strict';
-
-goog.provide('Blockly.ScratchMsgs.allLocales');
-
-goog.require('Blockly.ScratchMsgs');
-
-`
-
-let files = glob.sync(PATH_INPUT)
-files.forEach(function (uri) {
-  const name = path.parse(uri).name
-  if (name !== 'qqq' && name !== 'synonyms') {
-    let body = fs.readFileSync(uri)
-    // Convert file body into an object (let this throw if invalid JSON)
-    body = JSON.parse(body)
-    validate(body, name)
-    file += '\n'
-    file += `Blockly.ScratchMsgs.locales["${name}"] =\n`
-    file += JSON.stringify(body, null, 4)
-    file += ';\n'
-  }
-})
-
-// write combined file
-fs.writeFileSync(`${PATH_OUTPUT}/scratch_msgs.js`, file)

package/i18n/dedup_json.py

@@ -1,73 +0,0 @@
-#!/usr/bin/python
-
-# Consolidates duplicate key-value pairs in a JSON file.
-# If the same key is used with different values, no warning is given,
-# and there is no guarantee about which key-value pair will be output.
-# There is also no guarantee as to the order of the key-value pairs
-# output.
-#
-# Copyright 2013 Google Inc.
-# https://developers.google.com/blockly/
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import codecs
-import json
-from common import InputError
-
-
-def main():
-  """Parses arguments and iterates over files.
-
-  Raises:
-    IOError: An I/O error occurred with an input or output file.
-    InputError: Input JSON could not be parsed.
-  """
-
-  # Set up argument parser.
-  parser = argparse.ArgumentParser(
-      description='Removes duplicate key-value pairs from JSON files.')
-  parser.add_argument('--suffix', default='',
-                      help='optional suffix for output files; '
-                      'if empty, files will be changed in place')
-  parser.add_argument('files', nargs='+', help='input files')
-  args = parser.parse_args()
-
-  # Iterate over files.
-  for filename in args.files:
-    # Read in json using Python libraries.  This eliminates duplicates.
-    print('Processing ' + filename + '...')
-    try:
-      with codecs.open(filename, 'r', 'utf-8') as infile:
-        j = json.load(infile)
-    except ValueError as e:
-      print('Error reading ' + filename)
-      raise InputError(filename, str(e))
-
-    # Built up output strings as an array to make output of delimiters easier.
-    output = []
-    for key in j:
-      if key != '@metadata':
-        output.append('\t"' + key + '": "' +
-                      j[key].replace('\n', '\\n') + '"')
-
-    # Output results.
-    with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:
-      outfile.write('{\n')
-      outfile.write(',\n'.join(output))
-      outfile.write('\n}\n')
-
-
-if __name__ == '__main__':
-  main()

package/i18n/js_to_json.js

@@ -1,54 +0,0 @@
-const es = require('event-stream')
-const fs = require('fs')
-const path = require('path')
-const assert = require('assert')
-
-// Storage object
-const storage = {}
-
-// File paths
-const PATH_INPUT = path.resolve(__dirname, '../msg/messages.js')
-const PATH_OUTPUT = path.resolve(__dirname, '../msg/json/en.json')
-
-// Match function
-const match = function (str) {
-  if (str.indexOf('Blockly.Msg.') !== 0) return false
-  assert.notStrictEqual(
-    str.indexOf('";'),
-    str.length - 2,
-    `[${str}] uses double quoted string, should use single quotes.`,
-  )
-  if (str.indexOf("';") !== str.length - 2) return false
-  return true
-}
-
-// Extract key and value from message definition
-const extract = function (str) {
-  str = str.split('Blockly.Msg.')[1].split(' ')
-  return {
-    key: str[0],
-    value: str
-      .splice(2, str.length)
-      .join(' ')
-      .slice(1, -2) // strip off initial ', and ending ';
-      .replace(/\\'/g, "'"),
-  }
-}
-
-// Stream input and push each match to the storage object
-const stream = fs.createReadStream(PATH_INPUT)
-stream
-  .pipe(es.split('\n'))
-  .pipe(
-    es.mapSync(function (str) {
-      if (!match(str)) return
-      const result = extract(str)
-      storage[result.key] = result.value
-    }),
-  )
-  .pipe(
-    es.wait(function (err) {
-      if (err) throw new Error(err)
-      fs.writeFileSync(PATH_OUTPUT, JSON.stringify(storage, null, 4))
-    }),
-  )

package/i18n/js_to_json.py

@@ -1,136 +0,0 @@
-#!/usr/bin/python
-
-# Gives the translation status of the specified apps and languages.
-#
-# Copyright 2013 Google Inc.
-# https://developers.google.com/blockly/
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Extracts messages from .js files into .json files for translation.
-
-Specifically, lines with the following formats are extracted:
-
-    /// Here is a description of the following message.
-    Blockly.SOME_KEY = 'Some value';
-
-Adjacent "///" lines are concatenated.
-
-There are two output files, each of which is proper JSON.  For each key, the
-file en.json would get an entry of the form:
-
-    "Blockly.SOME_KEY", "Some value",
-
-The file qqq.json would get:
-
-    "Blockly.SOME_KEY", "Here is a description of the following message.",
-
-Commas would of course be omitted for the final entry of each value.
-
-@author Ellen Spertus (ellen.spertus@gmail.com)
-"""
-
-import argparse
-import codecs
-import json
-import os
-import re
-from common import write_files
-
-
-_INPUT_DEF_PATTERN = re.compile("""Blockly.Msg.(\w*)\s*=\s*'(.*)';?\r?$""")
-
-_INPUT_SYN_PATTERN = re.compile(
-    """Blockly.Msg.(\w*)\s*=\s*Blockly.Msg.(\w*);""")
-
-_CONSTANT_DESCRIPTION_PATTERN = re.compile(
-    """{{Notranslate}}""", re.IGNORECASE)
-
-def main():
-  # Set up argument parser.
-  parser = argparse.ArgumentParser(description='Create translation files.')
-  parser.add_argument(
-      '--author',
-      default='Ellen Spertus <ellen.spertus@gmail.com>',
-      help='name and email address of contact for translators')
-  parser.add_argument('--lang', default='en',
-                      help='ISO 639-1 source language code')
-  parser.add_argument('--output_dir', default='json',
-                      help='relative directory for output files')
-  parser.add_argument('--input_file', default='messages.js',
-                      help='input file')
-  parser.add_argument('--quiet', action='store_true', default=False,
-                      help='only display warnings, not routine info')
-  args = parser.parse_args()
-  if (not args.output_dir.endswith(os.path.sep)):
-    args.output_dir += os.path.sep
-
-  # Read and parse input file.
-  results = []
-  synonyms = {}
-  constants = {}  # Values that are constant across all languages.
-  description = ''
-  infile = codecs.open(args.input_file, 'r', 'utf-8')
-  for line in infile:
-    if line.startswith('///'):
-      if description:
-        description = description + ' ' + line[3:].strip()
-      else:
-        description = line[3:].strip()
-    else:
-      match = _INPUT_DEF_PATTERN.match(line)
-      if match:
-        key = match.group(1)
-        value = match.group(2).replace("\\'", "'")
-        if not description:
-          print('Warning: No description for ' + result['meaning'])
-        if (description and _CONSTANT_DESCRIPTION_PATTERN.search(description)):
-          constants[key] = value
-        else:
-          result = {}
-          result['meaning'] = key
-          result['source'] = value
-          result['description'] = description
-          results.append(result)
-        description = ''
-      else:
-        match = _INPUT_SYN_PATTERN.match(line)
-        if match:
-          if description:
-            print('Warning: Description preceding definition of synonym {0}.'.
-                  format(match.group(1)))
-            description = ''
-          synonyms[match.group(1)] = match.group(2)
-  infile.close()
-
-  # Create <lang_file>.json, keys.json, and qqq.json.
-  write_files(args.author, args.lang, args.output_dir, results, False)
-
-  # Create synonyms.json.
-  synonym_file_name = os.path.join(os.curdir, args.output_dir, 'synonyms.json')
-  with open(synonym_file_name, 'w') as outfile:
-    json.dump(synonyms, outfile)
-  if not args.quiet:
-    print("Wrote {0} synonym pairs to {1}.".format(
-        len(synonyms), synonym_file_name))
-
-  # Create constants.json
-  constants_file_name = os.path.join(os.curdir, args.output_dir, 'constants.json')
-  with open(constants_file_name, 'w') as outfile:
-    json.dump(constants, outfile)
-  if not args.quiet:
-    print("Wrote {0} constant pairs to {1}.".format(
-        len(constants), synonym_file_name))
-
-if __name__ == '__main__':
-  main()

package/i18n/json_to_js.js

@@ -1,52 +0,0 @@
-const async = require('async')
-const fs = require('fs')
-const path = require('path')
-const glob = require('glob')
-
-// Globals
-const PATH_INPUT = path.resolve(__dirname, '../msg/json/en.json')
-// If you want to generate js files for other languages, comment out the line above,
-// and use the one below instead.
-// const PATH_INPUT = path.resolve(__dirname, '../msg/json/*.json');
-const PATH_OUTPUT = path.resolve(__dirname, '../msg/js')
-const CONCURRENCY_LIMIT = 4
-
-// Processing task
-const work = function (uri, callback) {
-  fs.readFile(uri, function (err, body) {
-    const name = path.parse(uri).name
-    if (err) return callback(err)
-
-    // Convert file body into an object (let this throw if invalid JSON)
-    body = JSON.parse(body)
-
-    // File storage object and preamble
-    let file = ''
-    file += '// This file was automatically generated.  Do not modify.\n'
-    file += '\n'
-    file += "'use strict';\n"
-    file += '\n'
-    file += `goog.provide(\'Blockly.Msg.${name}\');\n`
-    file += "goog.require('Blockly.Msg');\n"
-    file += '\n'
-
-    // Iterate over object and build up file
-    for (let i in body) {
-      file += `Blockly.Msg["${i}"] = "${body[i].replace(/"/g, '\\"')}";\n`
-    }
-
-    // Write file to disk
-    fs.writeFile(`${PATH_OUTPUT}/${name}.js`, file, callback)
-  })
-}
-
-// Create async processing queue
-const q = async.queue(work, CONCURRENCY_LIMIT)
-
-// Handle errors
-q.error = function (err) {
-  throw new Error(err)
-}
-
-// Get all JSON files in input directory and add to queue
-q.push(glob.sync(PATH_INPUT))