rapydscript-ng 0.8.0 → 0.8.2

package/tools/self.mjs

@@ -163,10 +163,25 @@ async function run_single_compile(base_path, src_path, lib_path, profile) {
     return compiler_changed;
 }
 
+async function write_stdlib_modules(src_path, out_path) {
+    var lib_dir = path.join(src_path, 'lib');
+    var entries = await fs.promises.readdir(lib_dir);
+    var modules = entries
+        .filter(function (name) { return name.slice(-4) === '.pyj'; })
+        .map(function (name) { return name.slice(0, -4); })
+        .sort();
+    await fs.promises.writeFile(
+        path.join(out_path, 'stdlib_modules.json'),
+        JSON.stringify(modules),
+        'utf-8'
+    );
+}
+
 export default async function compile_self(base_path, src_path, lib_path, complete, profile) {
     var changed;
     do {
         changed = await run_single_compile(base_path, src_path, lib_path, profile);
         lib_path = path.join(path.dirname(lib_path), 'dev');
     } while (changed && complete);
+    await write_stdlib_modules(src_path, lib_path);
 }

package/tools/test.mjs

@@ -144,9 +144,109 @@ export default async function(argv, base_path, src_path, lib_path) {
         if (!failed) console.log(colored(file, 'green') + ": test completed successfully\n");
         else { console.log(colored(file, 'red') + ":\ttest failed\n"); }
     }
+    // Run the bun standalone binary test when doing a full test suite run and bun
+    // is available.  Individual file runs (argv.files.length > 0) skip it.
+    if (!argv.files.length) {
+        const bun_test_name = 'bun_standalone_binary';
+        let bun_ok = false;
+        try {
+            bun_ok = await run_bun_standalone_test(base_path, colored);
+        } catch (e) {
+            console.error(colored(bun_test_name, 'red') + ': unexpected error: ' + (e.stack || e));
+        }
+        if (bun_ok) {
+            console.log(colored(bun_test_name, 'green') + ': test completed successfully\n');
+        } else {
+            failures.push(bun_test_name);
+            console.log(colored(bun_test_name, 'red') + ':\ttest failed\n');
+        }
+    }
+
     if (failures.length) {
         console.log(colored('There were ' + failures.length + ' test failure(s):', 'red'));
         console.log.apply(console, failures);
     } else console.log(colored('All tests passed!', 'green'));
     process.exit((failures.length) ? 1 : 0);
 }
+
+async function run_bun_standalone_test(base_path, colored) {
+    const { spawnSync } = await import('child_process');
+    const test_name = 'bun_standalone_binary';
+
+    // Check if bun is available.
+    const bun_check = spawnSync('bun', ['--version'], { encoding: 'utf-8' });
+    if (bun_check.error || bun_check.status !== 0) {
+        console.log(colored(test_name, 'yellow') + ': bun not found, skipping');
+        return true;
+    }
+
+    // Generate bin/rapydscript.mjs via build.ts.
+    const build_ts = path.join(base_path, 'bin', 'build.ts');
+    const gen_result = spawnSync('bun', [build_ts], { encoding: 'utf-8', cwd: base_path });
+    if (gen_result.status !== 0) {
+        console.error(colored(test_name, 'red') + ': build.ts failed:\n' + (gen_result.stderr || gen_result.stdout));
+        return false;
+    }
+
+    // Compile the standalone binary.
+    const binary_path = path.join(os.tmpdir(), 'rapydscript-bun-test-binary');
+    const entry_mjs = path.join(base_path, 'bin', 'rapydscript.mjs');
+    const compile_result = spawnSync(
+        'bun', ['build', entry_mjs, '--compile', '--outfile', binary_path],
+        { encoding: 'utf-8', cwd: base_path }
+    );
+    if (compile_result.status !== 0) {
+        console.error(colored(test_name, 'red') + ': bun build --compile failed:\n' + (compile_result.stderr || compile_result.stdout));
+        return false;
+    }
+
+    // Create test fixtures in a temp directory.
+    const tmp_dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rs-bun-test-'));
+    try {
+        // A local module the test will import from the filesystem.
+        await fs.promises.writeFile(path.join(tmp_dir, 'greeter.pyj'),
+            'def greet(name):\n    return "Hello, " + name\n');
+
+        // Main source: imports a stdlib module (re) AND the local module.
+        const src_file = path.join(tmp_dir, 'main.pyj');
+        await fs.promises.writeFile(src_file, [
+            'import re',
+            'from greeter import greet',
+            '',
+            'pattern = re.compile(r"world", re.I)',
+            'result = pattern.sub("RapydScript", "Hello world")',
+            'if result != "Hello RapydScript":',
+            '    raise AssertionError("re.sub gave: " + result)',
+            '',
+            'msg = greet("world")',
+            'if msg != "Hello, world":',
+            '    raise AssertionError("greet gave: " + msg)',
+        ].join('\n'));
+
+        const out_file = path.join(tmp_dir, 'main.js');
+
+        // Compile main.pyj with the standalone binary.
+        const run_result = spawnSync(
+            binary_path, [src_file, '--output', out_file],
+            { encoding: 'utf-8', cwd: tmp_dir }
+        );
+        if (run_result.status !== 0) {
+            console.error(colored(test_name, 'red') + ': standalone binary compilation failed:\n' +
+                (run_result.stderr || run_result.stdout));
+            return false;
+        }
+
+        // Execute the compiled output with node to verify correctness.
+        const js_code = await fs.promises.readFile(out_file, 'utf-8');
+        try {
+            vm.runInNewContext(js_code, { console }, { filename: out_file });
+        } catch (e) {
+            console.error(colored(test_name, 'red') + ': compiled output threw:\n' + (e.stack || e));
+            return false;
+        }
+
+        return true;
+    } finally {
+        await fs.promises.rm(tmp_dir, { recursive: true, force: true });
+    }
+}

package/tools/web_repl_export.mjs

@@ -10,6 +10,10 @@ import path from 'path';
 import * as utils from './utils.mjs';
 
 export default async function run_web_repl_export(base_path, lib_path, argv) {
+    if (globalThis.__rapydscript_embedded__) {
+        console.error('web-repl-export requires the full source repository and cannot run from a standalone binary.');
+        process.exit(1);
+    }
     var output_dir = argv.files[0];
     if (!output_dir) {
         console.error('Usage: rapydscript web-repl-export /path/to/export/directory');

package/tree-sitter/package.json

@@ -36,7 +36,7 @@
         "pyj"
       ],
       "highlights": [
-        "queries/rapydscript/highlights.scm"
+        "queries/highlights.scm"
       ]
     }
   ]

package/tree-sitter/tree-sitter.json

@@ -10,7 +10,7 @@
         "pyj"
       ],
       "highlights": [
-        "queries/rapydscript/highlights.scm"
+        "queries/highlights.scm"
       ],
       "injection-regex": "^(rapydscript|pyj)$"
     }

package/editor-plugins/nvim/rapydscript/README.md

@@ -1,184 +0,0 @@
-# rapydscript.nvim
-
-Neovim plugin that wires up the RapydScript LSP server (`rapydscript lsp`) as a
-native Neovim LSP client for `.pyj` files.
-
-## Features
-
-Provided by the LSP server — no extra plugins required:
-
-- **Completions** — in-scope symbols, builtins, keywords, and member completion (`mod.<TAB>`)
-- **Diagnostics** — lint checks and unresolved import warnings, updated as you type
-- **Hover** (`K`) — kind, origin, and docstring of the symbol under the cursor
-- **Go to definition** (`gd`) — including jumping into imported modules
-- **Find references** (`gr`) — resolved across files through the import graph
-- **Rename** (`<leader>rn`) — renames everywhere across the workspace
-- **Code actions** (`<leader>ca`) — remove unused import/local, add `# noqa`, format document
-- **Document formatting** (`<leader>f`) — same as `rapydscript fmt`
-- **Document symbols** — outline view via any symbols picker
-
-## Requirements
-
-- Neovim ≥ 0.10
-- `rapydscript` on your `$PATH` (install with `npm install -g rapydscript-ng`), or the
-  plugin directory must be inside a RapydScript repository checkout (the repo's own
-  `bin/rapydscript` is used automatically as a fallback)
-- **Syntax highlighting only**: a C compiler on your `$PATH` is required to compile the
-  tree-sitter parser the first time the plugin loads.  On Linux/macOS any `cc`-compatible
-  compiler works (gcc, clang, etc.).  On Windows, `cl` (MSVC) or `clang-cl` must be
-  available — run Neovim from a Visual Studio Developer Command Prompt, or add the
-  compiler to your `PATH` manually.  LSP features work regardless of whether compilation
-  succeeds.
-
-## Installation
-
-### lazy.nvim
-
-```lua
-{
-    dir = '/path/to/editor-plugins/nvim/rapydscript',
-    ft = 'rapydscript',
-    opts = {},
-}
-```
-
-**Example with options:**
-
-```lua
-{
-    dir = "/path/to/editor-plugins/nvim/rapydscript",
-    ft = "rapydscript",
-    opts = {
-        line_length   = 100,
-        preferred_quote = "double",
-    },
-}
-```
-
-### Manual (no plugin manager)
-
-Add the plugin directory to your runtime path and call `setup()`:
-
-```lua
--- in ~/.config/nvim/init.lua
-vim.opt.rtp:prepend("/path/to/rapydscript/nvim-lsp-plugin")
-require("rapydscript").setup()
-```
-
-## Configuration reference
-
-| Key | Type | Default | Description |
-|-----|------|---------|-------------|
-| `cmd` | `string[]` | `{"rapydscript","lsp"}` | Command used to start the server |
-| `import_path_patterns` | `string[]` | `{".", "src", "src/pyj"}` | Glob patterns relative to the project root; matching directories that contain `.pyj` files are passed automatically as `--import-path` |
-| `line_length` | `number\|nil` | `nil` | Max line length for the formatter, passed as `--line-length` |
-| `preferred_quote` | `string\|nil` | `nil` | `"single"` or `"double"`, passed as `--preferred-quote` |
-| `filetypes` | `string[]` | `{"rapydscript"}` | Filetypes that trigger server attachment |
-| `root_markers` | `string[]` | `{".git","package.json","rapydscript.json"}` | Files/dirs used to detect the project root |
-
-### Automatic import path detection
-
-When a project root is found (via `root_markers`), the plugin expands each pattern in
-`import_path_patterns` as a glob relative to that root.  Any matching directory that
-contains at least one `.pyj` file is added to the server's import search path
-automatically — no manual configuration needed for standard project layouts.
-
-If no project root is detected the setting has no effect.
-
-To add custom search locations alongside the defaults:
-
-```lua
-opts = {
-    import_path_patterns = { ".", "src", "src/pyj", "vendor/pyj" },
-}
-```
-
-To disable auto-detection entirely, pass an empty list:
-
-```lua
-opts = {
-    import_path_patterns = {},
-}
-```
-
-## Changing settings at runtime
-
-The server accepts live setting updates via the LSP
-`workspace/didChangeConfiguration` notification — no restart needed.  Call
-`require("rapydscript").update_settings(opts)` with any subset of the two
-settings keys:
-
-```lua
-require("rapydscript").update_settings({
-    line_length    = 100,               -- new max line length for the formatter
-    preferred_quote = "double",         -- "single" or "double"
-})
-```
-
-Only the keys you pass are updated; the rest keep their current values.
-
-### Neovim user commands
-
-A convenient way to expose this as editor commands — add to your config after
-`setup()`:
-
-```lua
--- :RapydLineLength 100
-vim.api.nvim_create_user_command("RapydLineLength", function(args)
-    require("rapydscript").update_settings({ line_length = tonumber(args.args) })
-end, { nargs = 1, desc = "Set RapydScript LSP line length" })
-
--- :RapydQuote double
-vim.api.nvim_create_user_command("RapydQuote", function(args)
-    require("rapydscript").update_settings({ preferred_quote = args.args })
-end, { nargs = 1, desc = "Set RapydScript LSP preferred quote style" })
-```
-
-### In lazy.nvim config
-
-If you want the commands available automatically, put them in the `config`
-function:
-
-```lua
-{
-    dir = "/path/to/rapydscript/nvim-lsp-plugin",
-    ft = "rapydscript",
-    opts = { line_length = 100 },
-    config = function(_, opts)
-        require("rapydscript").setup(opts)
-
-        vim.api.nvim_create_user_command("RapydLineLength", function(args)
-            require("rapydscript").update_settings({ line_length = tonumber(args.args) })
-        end, { nargs = 1 })
-
-        vim.api.nvim_create_user_command("RapydQuote", function(args)
-            require("rapydscript").update_settings({ preferred_quote = args.args })
-        end, { nargs = 1 })
-    end,
-}
-```
-
-Changes to `line_length` and `preferred_quote` take effect on the next format operation.
-
-## Keymaps
-
-The plugin does not define any keymaps — it relies on the standard Neovim LSP
-keymaps that are set up by `vim.lsp.buf.*`.  A minimal set to add to your LSP
-`on_attach` or a `LspAttach` autocmd:
-
-```lua
-vim.api.nvim_create_autocmd("LspAttach", {
-    callback = function(ev)
-        local buf = ev.buf
-        local map = function(mode, lhs, rhs)
-            vim.keymap.set(mode, lhs, rhs, { buffer = buf })
-        end
-        map("n", "K",           vim.lsp.buf.hover)
-        map("n", "gd",          vim.lsp.buf.definition)
-        map("n", "gr",          vim.lsp.buf.references)
-        map("n", "<leader>rn",  vim.lsp.buf.rename)
-        map("n", "<leader>ca",  vim.lsp.buf.code_action)
-        map("n", "<leader>f",   function() vim.lsp.buf.format({ async = true }) end)
-    end,
-})
-```

package/editor-plugins/nvim/rapydscript/ftdetect/rapydscript.lua

@@ -1,10 +0,0 @@
-#! /usr/bin/env lua
---
--- rapydscript.lua
--- Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
---
--- Distributed under terms of the MIT license.
---
-
-
-vim.filetype.add({ extension = { pyj = 'rapydscript' } })

package/editor-plugins/nvim/rapydscript/lua/rapydscript/health.lua

@@ -1,88 +0,0 @@
-local M = {}
-
-local function ver_str(v)
-    return v and table.concat(v, ".") or "unknown"
-end
-
-function M.check()
-    local h = vim.health
-    local rs_ok, rs = pcall(require, "rapydscript")
-    if not rs_ok then
-        h.start("rapydscript")
-        h.error("Failed to load plugin: " .. tostring(rs))
-        return
-    end
-
-    -- Binary -------------------------------------------------------------------
-    h.start("rapydscript binary")
-    local info = rs._binary_info
-    local sys  = info.system
-    local repo = info.repo
-
-    if sys then
-        if sys.rejected then
-            h.error(string.format(
-                "System binary rejected: %s  (v%s < minimum 0.8.0)",
-                sys.path, ver_str(sys.version)
-            ))
-        elseif sys.version then
-            h.ok(string.format("System binary: %s  (v%s)", sys.path, ver_str(sys.version)))
-        else
-            h.warn(string.format("System binary: %s  (version unknown)", sys.path))
-        end
-    else
-        h.warn("rapydscript not found on PATH")
-    end
-
-    if repo then
-        h.ok(string.format("Repo binary:   %s  (v%s)", repo.path, ver_str(repo.version)))
-    else
-        h.info("No repo binary present")
-    end
-
-    if not sys and not repo then
-        h.error("No rapydscript binary found — LSP will not start")
-    end
-
-    -- Tree-sitter --------------------------------------------------------------
-    h.start("rapydscript tree-sitter")
-    if rs._ts_so then
-        h.ok("Parser compiled: " .. rs._ts_so)
-    else
-        h.warn("Tree-sitter parser not compiled (syntax highlighting unavailable)")
-    end
-
-    -- LSP clients --------------------------------------------------------------
-    h.start("rapydscript LSP")
-    local clients = vim.lsp.get_clients({ name = "rapydscript" })
-    if #clients == 0 then
-        h.warn("No active rapydscript LSP client")
-    else
-        for _, client in ipairs(clients) do
-            local cmd_str = type(client.config.cmd) == "table"
-                and table.concat(client.config.cmd, " ")
-                or tostring(client.config.cmd)
-            h.ok(string.format("Client #%d  root: %s", client.id, client.config.root_dir or "?"))
-            h.info("cmd: " .. cmd_str)
-        end
-    end
-
-    -- Settings -----------------------------------------------------------------
-    h.start("rapydscript settings")
-    local opts = rs._active_opts
-    if not opts then
-        h.warn("setup() has not been called — showing defaults")
-        opts = rs.defaults
-    else
-        h.ok("setup() called")
-    end
-
-    h.info("cmd:                    " .. table.concat(opts.cmd, " "))
-    h.info("line_length:            " .. tostring(opts.line_length))
-    h.info("preferred_quote:        " .. tostring(opts.preferred_quote))
-    h.info("filetypes:              " .. table.concat(opts.filetypes, ", "))
-    h.info("root_markers:           " .. table.concat(opts.root_markers, ", "))
-    h.info("import_path_patterns:   " .. table.concat(opts.import_path_patterns, ", "))
-end
-
-return M