rapydscript-ng 0.8.0 → 0.8.2

package/src/utils.pyj

@@ -4,27 +4,32 @@ from __python__ import hash_literals
 
 has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty)
 
+
 def array_to_hash(a):
     ret = Object.create(None)
     for i in range(len(a)):
         ret[a[i]] = True
     return ret
 
+
 def slice(a, start):
     return Array.prototype.slice.call(a, start or 0)
 
+
 def characters(str_):
-    return str_.split("")
+    return str_.split('')
+
 
 def member(name, array):
-    for i in range(array.length-1, -1, -1):
+    for i in range(array.length - 1, -1, -1):
         if array[i] is name:
             return True
     return False
 
+
 def repeat_string(str_, i):
     if i <= 0:
-        return ""
+        return ''
     if i is 1:
         return str_
     d = repeat_string(str_, i >> 1)
@@ -33,11 +38,12 @@ def repeat_string(str_, i):
         d += str_
     return d
 
-class DefaultsError(ValueError):
 
+class DefaultsError(ValueError):
     def __init__(self, name, defs):
         ValueError.__init__(self, name + ' is not a supported option. Supported options are: ' + str(Object.keys(defs)))
 
+
 def defaults(args, defs, croak):
     if args is True:
         args = {}
@@ -51,15 +57,17 @@ def defaults(args, defs, croak):
         ret[i] = args[i] if args and has_prop(args, i) else defs[i]
     return ret
 
+
 def merge(obj, ext):
     for i in ext:
         obj[i] = ext[i]
     return obj
 
+
 def noop():
     pass
 
-MAP = def():
+MAP = def ():
     def MAP(a, f, backwards):
         ret = []
         top = []
@@ -84,7 +92,7 @@ MAP = def():
 
         if Array.isArray(a):
             if backwards:
-                for i in range(a.length-1, -1, -1):
+                for i in range(a.length - 1, -1, -1):
                     if doit():
                         break
                 ret.reverse()
@@ -99,14 +107,15 @@ MAP = def():
                     break
         return top.concat(ret)
 
-    MAP.at_top = def(val):
+    MAP.at_top = def (val):
         return new AtTop(val)
-    MAP.splice = def(val):
+    MAP.splice = def (val):
         return new Splice(val)
-    MAP.last = def(val):
+    MAP.last = def (val):
         return new Last(val)
 
     skip = MAP.skip = {}
+
     def AtTop(val):
         this.v = val
 
@@ -119,20 +128,24 @@ MAP = def():
     return MAP
 .call(this)
 
+
 def push_uniq(array, el):
     if array.indexOf(el) < 0:
         array.push(el)
 
+
 def string_template(text, props):
-    return text.replace(/\{(.+?)\}/g, def(str_, p):
+    return text.replace(/\{(.+?)\}/g, def (str_, p):
         return props[p]
     )
 
+
 def remove(array, el):
-    for i in range(array.length-1, -1, -1):
+    for i in range(array.length - 1, -1, -1):
         if array[i] is el:
             array.splice(i, 1)
 
+
 def mergeSort(array, cmp):
     if array.length < 2:
         return array.slice()
@@ -167,24 +180,28 @@ def mergeSort(array, cmp):
         return merge(left, right)
     return _ms(array)
 
+
 def set_difference(a, b):
-    return a.filter(def(el):
+    return a.filter(def (el):
         return b.indexOf(el) < 0
     )
 
+
 def set_intersection(a, b):
-    return a.filter(def(el):
+    return a.filter(def (el):
         return b.indexOf(el) >= 0
     )
 
+
 def make_predicate(words):
     if jstype(words) is 'string':
-        words = words.split(" ")
+        words = words.split(' ')
     a = Object.create(None)
     for k in words:
         a[k] = True
     return a
 
+
 def cache_file_name(src, cache_dir):
     if cache_dir:
         src = str.replace(src, '\\', '/')

package/test/fmt.pyj

@@ -129,14 +129,36 @@ async def run_tests():
                 {'line_length': 40})
 
     # --- reflow of simple multi-line statements ----------------------------
+    # By default, source line breaks are preserved (no joining).
+    await check('no-join-default',
+                'x = fn(\n    a,\n    b,\n    c\n)\n',
+                'x = fn(\n    a,\n    b,\n    c\n)\n')
+    # With join_lines=True the statement is collapsed onto one line.
     await check('reflow-simple-call',
                 'x = fn(\n    a,\n    b,\n    c\n)\n',
-                'x = fn(a, b, c)\n')
+                'x = fn(a, b, c)\n',
+                {'join_lines': True})
+    # A multi-line statement that is too long even in source form gets wrapped
+    # regardless of join_lines.
+    await check('no-join-wrap-long',
+                'x = very_long_function_name(\n    argument_one,\n    argument_two,\n    argument_three\n)\n',
+                'x = very_long_function_name(\n    argument_one,\n    argument_two,\n    argument_three\n)\n',
+                {'line_length': 40})
 
     # --- RapydScript specific constructs are preserved ----------------------
     await check('preserve-anon-function',
-                "params = {\n    'onclick': def(event):\n        alert('hi')\n    ,\n    'x': 5\n}\n",
-                "params = {\n    'onclick': def(event):\n        alert('hi')\n    ,\n    'x': 5\n}\n")
+                "params = {\n    'onclick': def (event):\n        alert('hi')\n    ,\n    'x': 5\n}\n",
+                "params = {\n    'onclick': def (event):\n        alert('hi')\n    ,\n    'x': 5\n}\n")
+    # Assignments inside an anonymous def passed as an argument must keep spaces
+    # around '='; they are not kwargs even though they are inside the outer call.
+    await check('anon-def-arg-assignment',
+                "window.addEventListener('beforeunload', def (event):\n    self.disable=True\n    self.ws.close()\n)\n",
+                "window.addEventListener('beforeunload', def (event):\n    self.disable = True\n    self.ws.close()\n)\n")
+    # Inline anonymous def inside a call: kwargs that follow the def must not
+    # gain spaces (they are not assignments in the def body).
+    await check('inline-anon-def-arg-kwargs',
+                "xhr = ajax('url', def ():pass;, method='POST', flag=False)\n",
+                "xhr = ajax('url', def (): pass;, method='POST', flag=False)\n")
     await check('preserve-chain',
                 "$(element)\n.css('background-color', 'red')\n.show()\n",
                 "$(element)\n.css('background-color', 'red')\n.show()\n")
@@ -160,7 +182,14 @@ async def run_tests():
 
     # --- inline anonymous function on a single line -------------------------
     await check('inline-anon', 'add = def(a,b): return a+b\n',
-                'add = def(a, b): return a + b\n')
+                'add = def (a, b): return a + b\n')
+    # --- anonymous function assignment: space always inserted between def and ( --
+    await check('anon-def-assignment',
+                "func = def(event):\n    pass\n",
+                "func = def (event):\n    pass\n")
+    await check('anon-def-assignment-already-spaced',
+                "func = def (event):\n    pass\n",
+                "func = def (event):\n    pass\n")
 
     # --- shebang preserved --------------------------------------------------
     await check('shebang', '#!/usr/bin/env rapydscript\nx=1\n',
@@ -183,6 +212,67 @@ async def run_tests():
     assrt.ok(errs3.length >= 1, 'check_report must flag over-length lines')
     assrt.ok(errs3.join('\n').indexOf('exceeds') >= 0, 'check_report over-length message content')
 
+    # --- import organization ------------------------------------------------
+    # __python__ group is first; stdlib group is second; other group is third.
+    # Blank line separates each non-empty group from the next.
+    await check('import-organize-three-groups',
+                'import my_module\nimport math\nfrom __python__ import os\n',
+                'from __python__ import os\n\nimport math\n\nimport my_module\n')
+    # stdlib (math, re, ...) in group 2; other imports in group 3, blank line between.
+    await check('import-organize-two-groups',
+                'import my_module\nimport math\n',
+                'import math\n\nimport my_module\n')
+    # from-imports in stdlib group follow bare imports (isort convention).
+    await check('import-organize-from-after-bare',
+                'from re import match\nimport math\nimport my_module\n',
+                'import math\nfrom re import match\n\nimport my_module\n')
+    # Sorting within a group: alphabetical by module then by names.
+    await check('import-organize-sort-stdlib',
+                'import re\nimport math\n',
+                'import math\nimport re\n')
+    await check('import-organize-sort-other',
+                'import zebra\nimport apple\n',
+                'import apple\nimport zebra\n')
+    # Only stdlib: no blank-line separator.
+    await check('import-organize-stdlib-only',
+                'import re\nimport math\n',
+                'import math\nimport re\n')
+    # Only other: no blank-line separator.
+    await check('import-organize-other-only',
+                'import zebra\nimport apple\n',
+                'import apple\nimport zebra\n')
+    # Only __python__: no blank-line separator.
+    await check('import-organize-python-only',
+                'from __python__ import sys\nfrom __python__ import os\n',
+                'from __python__ import os\nfrom __python__ import sys\n')
+    # __python__ with stdlib only: blank line between them.
+    await check('import-organize-python-and-stdlib',
+                'import math\nfrom __python__ import os\n',
+                'from __python__ import os\n\nimport math\n')
+    # __python__ with other only: blank line between them.
+    await check('import-organize-python-and-other',
+                'import my_module\nfrom __python__ import os\n',
+                'from __python__ import os\n\nimport my_module\n')
+    # Already organized: idempotent (checked automatically by check()).
+    await check('import-organize-already-organized',
+                'import math\n\nimport my_module\n',
+                'import math\n\nimport my_module\n')
+    await check('import-organize-python-already-organized',
+                'from __python__ import os\n\nimport math\n\nimport my_module\n',
+                'from __python__ import os\n\nimport math\n\nimport my_module\n')
+    # Code after imports is untouched; blank line between imports and code is preserved.
+    await check('import-organize-with-code',
+                'import my_module\nimport math\n\nx = 1\n',
+                'import math\n\nimport my_module\n\nx = 1\n')
+    # from-imports within other group are sorted by module then names.
+    await check('import-organize-from-other',
+                'from zebra import z\nfrom apple import a\n',
+                'from apple import a\nfrom zebra import z\n')
+    # Mixed bare and from-imports across groups.
+    await check('import-organize-mixed',
+                'from my_mod import func\nimport re\nimport math\n',
+                'import math\nimport re\n\nfrom my_mod import func\n')
+
     # --- collect_pyj_files (directory recursion) ----------------------------
     tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-fmt-'))
     fs.mkdirSync(path.join(tmp, 'sub'))

package/test/generic.pyj

@@ -39,6 +39,15 @@ assrt.equal(-1 < 0 == 1 < 0, False)
 # Empty tuple
 assrt.deepEqual((), [])
 
+# Tuples with newlines inside parentheses
+assrt.deepEqual((1,
+2), [1, 2])
+assrt.deepEqual((1,
+2,
+3), [1, 2, 3])
+assrt.deepEqual((1,
+                 2), [1, 2])
+
 # Conditional operators
 assrt.equal(1 if True else 2, 1)
 assrt.equal(1

package/test/lsp.pyj

@@ -206,6 +206,40 @@ async def test_configuration_change():
     lsp.apply_configuration(ctx, {'importPath': ''})
     assrt.equal(ctx.import_dirs.length, 0, 'empty importPath string should clear import_dirs')
 
+async def test_organize_imports():
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-lsp-org-'))
+    ctx = lsp.create_server_context({
+        'import_dirs': [tmp], 'libdir': libdir, 'workspace_roots': [tmp],
+        'line_length': 80, 'preferred_quote': 'single',
+    })
+    # Unorganized: stdlib after other -> edits are produced.
+    unorganized = 'import my_module\nimport math\n\nx = 1\n'
+    edits = lsp.organize_imports_document(ctx, unorganized)
+    assrt.ok(Array.isArray(edits) and edits.length > 0,
+             'organize_imports_document must return edits for unorganized imports')
+    assrt.ok(edits[0].newText.indexOf('import math') < edits[0].newText.indexOf('import my_module'),
+             'stdlib import (math) must come before other import in organized output')
+    assrt.ok(edits[0].newText.indexOf('\n\n') >= 0,
+             'organized output must have a blank line between stdlib and other groups')
+    # from __python__ import ... goes first, before stdlib.
+    with_python = 'import math\nfrom __python__ import os\n\nx = 1\n'
+    edits_py = lsp.organize_imports_document(ctx, with_python)
+    assrt.ok(Array.isArray(edits_py) and edits_py.length > 0,
+             'organize_imports_document must return edits when __python__ import is out of place')
+    assrt.ok(edits_py[0].newText.indexOf('from __python__') < edits_py[0].newText.indexOf('import math'),
+             '__python__ group must come before stdlib group in organized output')
+    # Already organized: no edits.
+    organized = 'import math\n\nimport my_module\n\nx = 1\n'
+    edits2 = lsp.organize_imports_document(ctx, organized)
+    assrt.equal(edits2.length, 0,
+                'organize_imports_document must return no edits for already-organized imports')
+    # No imports: no edits.
+    no_imports = 'x = 1\ny = 2\n'
+    edits3 = lsp.organize_imports_document(ctx, no_imports)
+    assrt.equal(edits3.length, 0,
+                'organize_imports_document must return no edits when there are no imports')
+    fs.rmSync(tmp, {'recursive': True})
+
 async def run_tests():
     await test_diagnostics()
     await test_hover_and_definition()
@@ -218,5 +252,6 @@ async def run_tests():
     await test_error_recovery_still_analyzes()
     await test_parser_recovery_flag()
     await test_configuration_change()
+    await test_organize_imports()
 
 __test_async_done__ = run_tests()

package/test/str.pyj

@@ -57,6 +57,14 @@ def test_interpolation():
     ae(f'{a}'f'{a}', '11')
     ae(f'a''b', 'ab')
     ae(f'{a}''b', '1b')
+    # Test plain string followed by f-string (regression: was parsed as a call expression)
+    ae('a' f'b', 'ab')
+    ae('a' f'{a}', 'a1')
+    ae('prefix ' f'{a}', 'prefix 1')
+    ae('a'  f'{a}', 'a1')
+    ae('a' f'{a}' 'b', 'a1b')
+    ae('a' f'{a}' f'{a}', 'a11')
+    ae(rf'raw{a}' f' and {a}', 'raw1 and 1')
 
 somevar = 33
 test('somevar=33', '{somevar=}', somevar=somevar)

package/tools/cli.mjs

@@ -449,18 +449,29 @@ If no files or directories are specified, the source code is read from
 STDIN and the formatted result is written to STDOUT.`);
 
 opt("line_length", 'l', 'string', '80', `The maximum allowed line length. Lines longer than this
-are wrapped where it is safe to do so. Defaults to 80.`);
+are wrapped where it is safe to do so. Defaults to 80.
+If not specified, the value is read from pyproject.toml
+(searched upward from the current directory) under
+[tool.ruff], [tool.black], or [tool.isort].`);
 
 opt("preferred_quote", 'q', 'string', 'single', `The preferred quote character for string literals. Either
 "single" or "double". A string is only re-quoted when doing
 so does not increase the number of backslash escapes.
-Defaults to single.`, ['single', 'double']);
+Defaults to single. If not specified, the value is read from
+pyproject.toml (searched upward from the current directory)
+under [tool.ruff.format], [tool.ruff.lint.flake8-quotes],
+or [tool.flake8].`, ['single', 'double']);
 
 opt("check_only", 'c', 'bool', false, `Do not modify files. Instead, print the names of files that
 would be reformatted (and any lines that exceed the maximum
 length) to STDERR. Exit with a status of 1 if any issues are
 found, otherwise 0.`);
 
+opt("join_lines", 'j', 'bool', false, `Join multi-line statements that fit within the maximum line
+length onto a single line. Disabled by default: source line
+breaks inside statements are preserved as long as no line
+exceeds the maximum length.`);
+
 create_group('lsp', "", `Run a Language Server Protocol (LSP) server for RapydScript.
 The server communicates over stdin/stdout using the standard
 LSP JSON-RPC framing and provides code completion, diagnostics,
@@ -484,10 +495,20 @@ RAPYDSCRIPT_IMPORT_PATH for this, with identical syntax.`);
 
 opt("line_length", 'l', 'string', '80', `The maximum allowed line length used by the document formatter.
 Lines longer than this are wrapped where it is safe to do so.
-Defaults to 80.`);
+Defaults to 80. If not specified, the value is read from
+pyproject.toml (searched upward from the working directory)
+under [tool.ruff], [tool.black], or [tool.isort].`);
 
 opt("preferred_quote", 'q', 'string', 'single', `The preferred quote character used by the document formatter.
-Either "single" or "double". Defaults to single.`, ['single', 'double']);
+Either "single" or "double". Defaults to single. If not
+specified, the value is read from pyproject.toml (searched
+upward from the working directory) under [tool.ruff.format],
+[tool.ruff.lint.flake8-quotes], or [tool.flake8].`, ['single', 'double']);
+
+opt("join_lines", 'j', 'bool', false, `Join multi-line statements that fit within the maximum line
+length onto a single line. Disabled by default: source line
+breaks inside statements are preserved as long as no line
+exceeds the maximum length.`);
 
 
 export var argv = parse_args();

package/tools/compile.mjs

@@ -9,7 +9,7 @@ import fs from 'fs';
 import path from 'path';
 import vm from 'vm';
 import { createRequire } from 'module';
-import { create_compiler } from './compiler.mjs';
+import { create_compiler, EMBEDDED_STDLIB_PREFIX } from './compiler.mjs';
 import * as utils from './utils.mjs';
 import { generate_source_map } from './sourcemap.mjs';
 import tree_shake from './treeshake.mjs';
@@ -83,7 +83,10 @@ export default async function(start_time, argv, base_path, src_path, lib_path) {
 
     if (!argv.omit_baselib) {
         var which = (OUTPUT_OPTIONS.beautify) ? 'pretty' : 'ugly';
-        OUTPUT_OPTIONS.baselib_plain = await fs.promises.readFile(path.join(lib_path, 'baselib-plain-' + which + '.js'), 'utf-8');
+        const baselib_key = 'baselib-plain-' + which + '.js';
+        const embedded = globalThis.__rapydscript_embedded__;
+        OUTPUT_OPTIONS.baselib_plain = embedded?.[baselib_key] ??
+            await fs.promises.readFile(path.join(lib_path, baselib_key), 'utf-8');
     }
 
     var files = argv.files.slice();
@@ -96,11 +99,12 @@ export default async function(start_time, argv, base_path, src_path, lib_path) {
     }
 
     async function parse_file(code, file, toplevel) {
+        const embedded = globalThis.__rapydscript_embedded__;
         return await RapydScript.parse(code, {
             filename: file,
             toplevel: toplevel,
             basedir: (file !== '<stdin>') ? path.dirname(file) : undefined,
-            libdir: path.join(src_path, 'lib'),
+            libdir: embedded ? EMBEDDED_STDLIB_PREFIX : path.join(src_path, 'lib'),
             import_dirs: utils.get_import_dirs(argv.import_path),
             discard_asserts: argv.discard_asserts,
             module_cache_dir: cache_dir,

package/tools/compiler.mjs

@@ -53,9 +53,15 @@ async function find_compiler_dir() {
     return { base, compiler_dir };
 }
 
+// Sentinel libdir value used when stdlib files come from the embedded asset VFS
+// rather than the real filesystem.  The compiler's readfile/stat_file callbacks
+// intercept paths that start with this prefix.
+const EMBEDDED_STDLIB_PREFIX = '__stdlib__';
+
 async function create_compiler(opts) {
     opts = opts || {};
     var vfs = opts.virtual_file_system;
+    const embedded = globalThis.__rapydscript_embedded__;
 
     const { base, compiler_dir } = await find_compiler_dir();
 
@@ -83,6 +89,32 @@ async function create_compiler(opts) {
             const content = await readfile(p, 'utf-8');
             return { mtimeMs: null, content };
         };
+    } else if (embedded) {
+        // Compiled standalone binary: stdlib lives in the embedded asset VFS.
+        // Paths prefixed with EMBEDDED_STDLIB_PREFIX are served from memory;
+        // all other paths (user source files, cache) still hit the real filesystem.
+        readfile = async (p, enc) => {
+            if (p.startsWith('__stdlib__/')) {
+                const name = p.slice('__stdlib__/'.length);
+                if (embedded.stdlib && embedded.stdlib[name] !== undefined) return embedded.stdlib[name];
+            }
+            return fs.promises.readFile(p, enc);
+        };
+        // Silently drop writes that target embedded virtual paths (e.g. stdlib cache files).
+        writefile = async (p, data) => {
+            if (p.startsWith('__stdlib__/')) return;
+            return fs.promises.writeFile(p, data);
+        };
+        stat_file = async (p) => {
+            if (p.startsWith('__stdlib__/')) {
+                const name = p.slice('__stdlib__/'.length);
+                if (embedded.stdlib && embedded.stdlib[name] !== undefined) return { mtimeMs: null };
+                const err = Object.assign(new Error(`stdlib not found: ${name}`), { code: 'ENOENT' });
+                throw err;
+            }
+            const st = await fs.promises.stat(p);
+            return { mtimeMs: st.mtimeMs };
+        };
     } else {
         readfile = async (p, enc) => fs.promises.readFile(p, enc);
         writefile = async (p, data) => fs.promises.writeFile(p, data);
@@ -103,7 +135,7 @@ async function create_compiler(opts) {
         exports       : compiler_exports,
     });
     var compiler_file = path.join(compiler_dir, 'compiler.js');
-    var compilerjs = await fs.promises.readFile(compiler_file, 'utf-8');
+    var compilerjs = embedded?.['compiler.js'] ?? await fs.promises.readFile(compiler_file, 'utf-8');
     vm.runInContext(compilerjs, compiler_context, path.relative(base, compiler_file));
     const { ast_to_json, ast_from_json, make_lazy_ast_module, encode_cache, decode_cache } = make_ast_serializer(compiler_exports);
     compiler_exports.ast_to_json = ast_to_json;
@@ -124,4 +156,4 @@ async function create_embedded_compiler(compiler, baselib, runjs, name) {
     return await embedded_compiler_factory(compiler || await create_compiler(), baselib, runjs, name, tree_shake, generate_source_map);
 }
 
-export { create_compiler, create_embedded_compiler, generate_source_map };
+export { create_compiler, create_embedded_compiler, generate_source_map, EMBEDDED_STDLIB_PREFIX };