SCons: Format buildsystem files with psf/black

Configured for a max line length of 120 characters.

psf/black is very opinionated and purposely doesn't leave much room for
configuration. The output is mostly OK so that should be fine for us,
but some things worth noting:

- Manually wrapped strings will be reflowed, so by using a line length
  of 120 for the sake of preserving readability for our long command
  calls, it also means that some manually wrapped strings are back on
  the same line and should be manually merged again.

- Code generators using string concatenation extensively look awful,
  since black puts each operand on a single line. We need to refactor
  these generators to use more pythonic string formatting, for which
  many options are available (`%`, `format` or f-strings).

- CI checks and a pre-commit hook will be added to ensure that future
  buildsystem changes are well-formatted.

3 files changed, 122 insertions, 123 deletions

diff --git a/platform/javascript/SCsub b/platform/javascript/SCsub
index d3cd8f76b7..7239648937 100644
--- a/platform/javascript/SCsub
+++ b/platform/javascript/SCsub
@@ -1,67 +1,63 @@
 #!/usr/bin/env python
 
-Import('env')
+Import("env")
 
 javascript_files = [
-    'audio_driver_javascript.cpp',
-    'http_client_javascript.cpp',
-    'javascript_eval.cpp',
-    'javascript_main.cpp',
-    'os_javascript.cpp',
+    "audio_driver_javascript.cpp",
+    "http_client_javascript.cpp",
+    "javascript_eval.cpp",
+    "javascript_main.cpp",
+    "os_javascript.cpp",
 ]
 
-build_targets = ['#bin/godot${PROGSUFFIX}.js', '#bin/godot${PROGSUFFIX}.wasm']
-if env['threads_enabled']:
-    build_targets.append('#bin/godot${PROGSUFFIX}.worker.js')
+build_targets = ["#bin/godot${PROGSUFFIX}.js", "#bin/godot${PROGSUFFIX}.wasm"]
+if env["threads_enabled"]:
+    build_targets.append("#bin/godot${PROGSUFFIX}.worker.js")
 
 build = env.add_program(build_targets, javascript_files)
 
 js_libraries = [
-    'http_request.js',
+    "http_request.js",
 ]
 for lib in js_libraries:
-    env.Append(LINKFLAGS=['--js-library', env.File(lib).path])
+    env.Append(LINKFLAGS=["--js-library", env.File(lib).path])
 env.Depends(build, js_libraries)
 
 js_modules = [
-    'id_handler.js',
+    "id_handler.js",
 ]
 for module in js_modules:
-    env.Append(LINKFLAGS=['--pre-js', env.File(module).path])
+    env.Append(LINKFLAGS=["--pre-js", env.File(module).path])
 env.Depends(build, js_modules)
 
 engine = [
-    'engine/preloader.js',
-    'engine/loader.js',
-    'engine/utils.js',
-    'engine/engine.js',
+    "engine/preloader.js",
+    "engine/loader.js",
+    "engine/utils.js",
+    "engine/engine.js",
 ]
-externs = [
-    env.File('#platform/javascript/engine/externs.js')
-]
-js_engine = env.CreateEngineFile('#bin/godot${PROGSUFFIX}.engine.js', engine, externs)
+externs = [env.File("#platform/javascript/engine/externs.js")]
+js_engine = env.CreateEngineFile("#bin/godot${PROGSUFFIX}.engine.js", engine, externs)
 env.Depends(js_engine, externs)
 
 wrap_list = [
     build[0],
     js_engine,
 ]
-js_wrapped = env.Textfile('#bin/godot', [env.File(f) for f in wrap_list], TEXTFILESUFFIX='${PROGSUFFIX}.wrapped.js')
+js_wrapped = env.Textfile("#bin/godot", [env.File(f) for f in wrap_list], TEXTFILESUFFIX="${PROGSUFFIX}.wrapped.js")
 
-zip_dir = env.Dir('#bin/.javascript_zip')
-out_files = [
-    zip_dir.File('godot.js'),
-    zip_dir.File('godot.wasm'),
-    zip_dir.File('godot.html')
-]
-in_files = [
-    js_wrapped,
-    build[1],
-    '#misc/dist/html/full-size.html'
-]
-if env['threads_enabled']:
+zip_dir = env.Dir("#bin/.javascript_zip")
+out_files = [zip_dir.File("godot.js"), zip_dir.File("godot.wasm"), zip_dir.File("godot.html")]
+in_files = [js_wrapped, build[1], "#misc/dist/html/full-size.html"]
+if env["threads_enabled"]:
     in_files.append(build[2])
-    out_files.append(zip_dir.File('godot.worker.js'))
+    out_files.append(zip_dir.File("godot.worker.js"))
 
 zip_files = env.InstallAs(out_files, in_files)
-env.Zip('#bin/godot', zip_files, ZIPROOT=zip_dir, ZIPSUFFIX='${PROGSUFFIX}${ZIPSUFFIX}', ZIPCOMSTR='Archving $SOURCES as $TARGET')
+env.Zip(
+    "#bin/godot",
+    zip_files,
+    ZIPROOT=zip_dir,
+    ZIPSUFFIX="${PROGSUFFIX}${ZIPSUFFIX}",
+    ZIPCOMSTR="Archving $SOURCES as $TARGET",
+)
diff --git a/platform/javascript/detect.py b/platform/javascript/detect.py
index fb02752aa7..9486e10717 100644
--- a/platform/javascript/detect.py
+++ b/platform/javascript/detect.py
@@ -2,37 +2,39 @@ import os
 
 from emscripten_helpers import parse_config, run_closure_compiler, create_engine_file
 
+
 def is_active():
     return True
 
 
 def get_name():
-    return 'JavaScript'
+    return "JavaScript"
 
 
 def can_build():
-    return 'EM_CONFIG' in os.environ or os.path.exists(os.path.expanduser('~/.emscripten'))
+    return "EM_CONFIG" in os.environ or os.path.exists(os.path.expanduser("~/.emscripten"))
 
 
 def get_opts():
     from SCons.Variables import BoolVariable
+
     return [
         # eval() can be a security concern, so it can be disabled.
-        BoolVariable('javascript_eval', 'Enable JavaScript eval interface', True),
-        BoolVariable('threads_enabled', 'Enable WebAssembly Threads support (limited browser support)', False),
-        BoolVariable('use_closure_compiler', 'Use closure compiler to minimize Javascript code', False),
+        BoolVariable("javascript_eval", "Enable JavaScript eval interface", True),
+        BoolVariable("threads_enabled", "Enable WebAssembly Threads support (limited browser support)", False),
+        BoolVariable("use_closure_compiler", "Use closure compiler to minimize Javascript code", False),
     ]
 
 
 def get_flags():
     return [
-        ('tools', False),
-        ('builtin_pcre2_with_jit', False),
+        ("tools", False),
+        ("builtin_pcre2_with_jit", False),
         # Disabling the mbedtls module reduces file size.
         # The module has little use due to the limited networking functionality
         # in this platform. For the available networking methods, the browser
         # manages TLS.
-        ('module_mbedtls_enabled', False),
+        ("module_mbedtls_enabled", False),
     ]
 
 
@@ -40,125 +42,125 @@ def configure(env):
 
     ## Build type
 
-    if env['target'] == 'release':
+    if env["target"] == "release":
         # Use -Os to prioritize optimizing for reduced file size. This is
         # particularly valuable for the web platform because it directly
         # decreases download time.
         # -Os reduces file size by around 5 MiB over -O3. -Oz only saves about
         # 100 KiB over -Os, which does not justify the negative impact on
         # run-time performance.
-        env.Append(CCFLAGS=['-Os'])
-        env.Append(LINKFLAGS=['-Os'])
-    elif env['target'] == 'release_debug':
-        env.Append(CCFLAGS=['-Os'])
-        env.Append(LINKFLAGS=['-Os'])
-        env.Append(CPPDEFINES=['DEBUG_ENABLED'])
+        env.Append(CCFLAGS=["-Os"])
+        env.Append(LINKFLAGS=["-Os"])
+    elif env["target"] == "release_debug":
+        env.Append(CCFLAGS=["-Os"])
+        env.Append(LINKFLAGS=["-Os"])
+        env.Append(CPPDEFINES=["DEBUG_ENABLED"])
         # Retain function names for backtraces at the cost of file size.
-        env.Append(LINKFLAGS=['--profiling-funcs'])
-    else: # 'debug'
-        env.Append(CPPDEFINES=['DEBUG_ENABLED'])
-        env.Append(CCFLAGS=['-O1', '-g'])
-        env.Append(LINKFLAGS=['-O1', '-g'])
-        env.Append(LINKFLAGS=['-s', 'ASSERTIONS=1'])
-
-    if env['tools']:
-        if not env['threads_enabled']:
-            raise RuntimeError("Threads must be enabled to build the editor. Please add the 'threads_enabled=yes' option")
+        env.Append(LINKFLAGS=["--profiling-funcs"])
+    else:  # 'debug'
+        env.Append(CPPDEFINES=["DEBUG_ENABLED"])
+        env.Append(CCFLAGS=["-O1", "-g"])
+        env.Append(LINKFLAGS=["-O1", "-g"])
+        env.Append(LINKFLAGS=["-s", "ASSERTIONS=1"])
+
+    if env["tools"]:
+        if not env["threads_enabled"]:
+            raise RuntimeError(
+                "Threads must be enabled to build the editor. Please add the 'threads_enabled=yes' option"
+            )
         # Tools need more memory. Initial stack memory in bytes. See `src/settings.js` in emscripten repository (will be renamed to INITIAL_MEMORY).
-        env.Append(LINKFLAGS=['-s', 'TOTAL_MEMORY=33554432'])
+        env.Append(LINKFLAGS=["-s", "TOTAL_MEMORY=33554432"])
     else:
         # Disable exceptions and rtti on non-tools (template) builds
         # These flags help keep the file size down.
-        env.Append(CCFLAGS=['-fno-exceptions', '-fno-rtti'])
+        env.Append(CCFLAGS=["-fno-exceptions", "-fno-rtti"])
         # Don't use dynamic_cast, necessary with no-rtti.
-        env.Append(CPPDEFINES=['NO_SAFE_CAST'])
+        env.Append(CPPDEFINES=["NO_SAFE_CAST"])
 
     ## Copy env variables.
-    env['ENV'] = os.environ
+    env["ENV"] = os.environ
 
     # LTO
-    if env['use_lto']:
-        env.Append(CCFLAGS=['-s', 'WASM_OBJECT_FILES=0'])
-        env.Append(LINKFLAGS=['-s', 'WASM_OBJECT_FILES=0'])
-        env.Append(LINKFLAGS=['--llvm-lto',  '1'])
+    if env["use_lto"]:
+        env.Append(CCFLAGS=["-s", "WASM_OBJECT_FILES=0"])
+        env.Append(LINKFLAGS=["-s", "WASM_OBJECT_FILES=0"])
+        env.Append(LINKFLAGS=["--llvm-lto", "1"])
 
     # Closure compiler
-    if env['use_closure_compiler']:
+    if env["use_closure_compiler"]:
         # For emscripten support code.
-        env.Append(LINKFLAGS=['--closure', '1'])
+        env.Append(LINKFLAGS=["--closure", "1"])
         # Register builder for our Engine files
-        jscc = env.Builder(generator=run_closure_compiler, suffix='.cc.js', src_suffix='.js')
-        env.Append(BUILDERS = {'BuildJS' : jscc})
+        jscc = env.Builder(generator=run_closure_compiler, suffix=".cc.js", src_suffix=".js")
+        env.Append(BUILDERS={"BuildJS": jscc})
 
     # Add method that joins/compiles our Engine files.
     env.AddMethod(create_engine_file, "CreateEngineFile")
 
     # Closure compiler extern and support for ecmascript specs (const, let, etc).
-    env['ENV']['EMCC_CLOSURE_ARGS'] = '--language_in ECMASCRIPT6'
+    env["ENV"]["EMCC_CLOSURE_ARGS"] = "--language_in ECMASCRIPT6"
 
     em_config = parse_config()
-    env.PrependENVPath('PATH', em_config['EMCC_ROOT'])
+    env.PrependENVPath("PATH", em_config["EMCC_ROOT"])
 
-    env['CC'] = 'emcc'
-    env['CXX'] = 'em++'
-    env['LINK'] = 'emcc'
+    env["CC"] = "emcc"
+    env["CXX"] = "em++"
+    env["LINK"] = "emcc"
 
-    env['AR'] = 'emar'
-    env['RANLIB'] = 'emranlib'
+    env["AR"] = "emar"
+    env["RANLIB"] = "emranlib"
 
     # Use TempFileMunge since some AR invocations are too long for cmd.exe.
     # Use POSIX-style paths, required with TempFileMunge.
-    env['ARCOM_POSIX'] = env['ARCOM'].replace(
-        '$TARGET', '$TARGET.posix').replace(
-        '$SOURCES', '$SOURCES.posix')
-    env['ARCOM'] = '${TEMPFILE(ARCOM_POSIX)}'
+    env["ARCOM_POSIX"] = env["ARCOM"].replace("$TARGET", "$TARGET.posix").replace("$SOURCES", "$SOURCES.posix")
+    env["ARCOM"] = "${TEMPFILE(ARCOM_POSIX)}"
 
     # All intermediate files are just LLVM bitcode.
-    env['OBJPREFIX'] = ''
-    env['OBJSUFFIX'] = '.bc'
-    env['PROGPREFIX'] = ''
+    env["OBJPREFIX"] = ""
+    env["OBJSUFFIX"] = ".bc"
+    env["PROGPREFIX"] = ""
     # Program() output consists of multiple files, so specify suffixes manually at builder.
-    env['PROGSUFFIX'] = ''
-    env['LIBPREFIX'] = 'lib'
-    env['LIBSUFFIX'] = '.bc'
-    env['LIBPREFIXES'] = ['$LIBPREFIX']
-    env['LIBSUFFIXES'] = ['$LIBSUFFIX']
+    env["PROGSUFFIX"] = ""
+    env["LIBPREFIX"] = "lib"
+    env["LIBSUFFIX"] = ".bc"
+    env["LIBPREFIXES"] = ["$LIBPREFIX"]
+    env["LIBSUFFIXES"] = ["$LIBSUFFIX"]
 
-    env.Prepend(CPPPATH=['#platform/javascript'])
-    env.Append(CPPDEFINES=['JAVASCRIPT_ENABLED', 'UNIX_ENABLED'])
+    env.Prepend(CPPPATH=["#platform/javascript"])
+    env.Append(CPPDEFINES=["JAVASCRIPT_ENABLED", "UNIX_ENABLED"])
 
-    if env['javascript_eval']:
-        env.Append(CPPDEFINES=['JAVASCRIPT_EVAL_ENABLED'])
+    if env["javascript_eval"]:
+        env.Append(CPPDEFINES=["JAVASCRIPT_EVAL_ENABLED"])
 
     # Thread support (via SharedArrayBuffer).
-    if env['threads_enabled']:
-        env.Append(CPPDEFINES=['PTHREAD_NO_RENAME'])
-        env.Append(CCFLAGS=['-s', 'USE_PTHREADS=1'])
-        env.Append(LINKFLAGS=['-s', 'USE_PTHREADS=1'])
-        env.Append(LINKFLAGS=['-s', 'PTHREAD_POOL_SIZE=4'])
-        env.Append(LINKFLAGS=['-s', 'WASM_MEM_MAX=2048MB'])
+    if env["threads_enabled"]:
+        env.Append(CPPDEFINES=["PTHREAD_NO_RENAME"])
+        env.Append(CCFLAGS=["-s", "USE_PTHREADS=1"])
+        env.Append(LINKFLAGS=["-s", "USE_PTHREADS=1"])
+        env.Append(LINKFLAGS=["-s", "PTHREAD_POOL_SIZE=4"])
+        env.Append(LINKFLAGS=["-s", "WASM_MEM_MAX=2048MB"])
     else:
-        env.Append(CPPDEFINES=['NO_THREADS'])
+        env.Append(CPPDEFINES=["NO_THREADS"])
 
     # Reduce code size by generating less support code (e.g. skip NodeJS support).
-    env.Append(LINKFLAGS=['-s', 'ENVIRONMENT=web,worker'])
+    env.Append(LINKFLAGS=["-s", "ENVIRONMENT=web,worker"])
 
     # We use IDBFS in javascript_main.cpp. Since Emscripten 1.39.1 it needs to
     # be linked explicitly.
-    env.Append(LIBS=['idbfs.js'])
+    env.Append(LIBS=["idbfs.js"])
 
-    env.Append(LINKFLAGS=['-s', 'BINARYEN=1'])
-    env.Append(LINKFLAGS=['-s', 'MODULARIZE=1', '-s', 'EXPORT_NAME="Godot"'])
+    env.Append(LINKFLAGS=["-s", "BINARYEN=1"])
+    env.Append(LINKFLAGS=["-s", "MODULARIZE=1", "-s", 'EXPORT_NAME="Godot"'])
 
     # Allow increasing memory buffer size during runtime. This is efficient
     # when using WebAssembly (in comparison to asm.js) and works well for
     # us since we don't know requirements at compile-time.
-    env.Append(LINKFLAGS=['-s', 'ALLOW_MEMORY_GROWTH=1'])
+    env.Append(LINKFLAGS=["-s", "ALLOW_MEMORY_GROWTH=1"])
 
     # This setting just makes WebGL 2 APIs available, it does NOT disable WebGL 1.
-    env.Append(LINKFLAGS=['-s', 'USE_WEBGL2=1'])
+    env.Append(LINKFLAGS=["-s", "USE_WEBGL2=1"])
 
-    env.Append(LINKFLAGS=['-s', 'INVOKE_RUN=0'])
+    env.Append(LINKFLAGS=["-s", "INVOKE_RUN=0"])
 
     # callMain for manual start, FS for preloading.
-    env.Append(LINKFLAGS=['-s', 'EXTRA_EXPORTED_RUNTIME_METHODS=["callMain", "FS"]'])
+    env.Append(LINKFLAGS=["-s", 'EXTRA_EXPORTED_RUNTIME_METHODS=["callMain", "FS"]'])
diff --git a/platform/javascript/emscripten_helpers.py b/platform/javascript/emscripten_helpers.py
index bda5b40a74..a55c9d3f48 100644
--- a/platform/javascript/emscripten_helpers.py
+++ b/platform/javascript/emscripten_helpers.py
@@ -1,7 +1,8 @@
 import os
 
+
 def parse_config():
-    em_config_file = os.getenv('EM_CONFIG') or os.path.expanduser('~/.emscripten')
+    em_config_file = os.getenv("EM_CONFIG") or os.path.expanduser("~/.emscripten")
     if not os.path.exists(em_config_file):
         raise RuntimeError("Emscripten configuration file '%s' does not exist" % em_config_file)
 
@@ -13,25 +14,25 @@ def parse_config():
             exec(f.read(), em_config)
         except StandardError as e:
             raise RuntimeError("Emscripten configuration file '%s' is invalid:\n%s" % (em_config_file, e))
-    normalized['EMCC_ROOT'] = em_config.get('EMSCRIPTEN_ROOT')
-    normalized['NODE_JS'] = em_config.get('NODE_JS')
-    normalized['CLOSURE_BIN'] = os.path.join(normalized['EMCC_ROOT'], 'node_modules', '.bin', 'google-closure-compiler')
+    normalized["EMCC_ROOT"] = em_config.get("EMSCRIPTEN_ROOT")
+    normalized["NODE_JS"] = em_config.get("NODE_JS")
+    normalized["CLOSURE_BIN"] = os.path.join(normalized["EMCC_ROOT"], "node_modules", ".bin", "google-closure-compiler")
     return normalized
 
 
 def run_closure_compiler(target, source, env, for_signature):
     cfg = parse_config()
-    cmd = [cfg['NODE_JS'], cfg['CLOSURE_BIN']]
-    cmd.extend(['--compilation_level', 'ADVANCED_OPTIMIZATIONS'])
-    for f in env['JSEXTERNS']:
-        cmd.extend(['--externs', f.get_abspath()])
+    cmd = [cfg["NODE_JS"], cfg["CLOSURE_BIN"]]
+    cmd.extend(["--compilation_level", "ADVANCED_OPTIMIZATIONS"])
+    for f in env["JSEXTERNS"]:
+        cmd.extend(["--externs", f.get_abspath()])
     for f in source:
-        cmd.extend(['--js', f.get_abspath()])
-    cmd.extend(['--js_output_file', target[0].get_abspath()])
-    return ' '.join(cmd)
+        cmd.extend(["--js", f.get_abspath()])
+    cmd.extend(["--js_output_file", target[0].get_abspath()])
+    return " ".join(cmd)
 
 
 def create_engine_file(env, target, source, externs):
-    if env['use_closure_compiler']:
+    if env["use_closure_compiler"]:
         return env.BuildJS(target, source, JSEXTERNS=externs)
     return env.Textfile(target, [env.File(s) for s in source])