just-bash 0.1.5__py3-none-any.whl

just_bash/interpreter/builtins/readonly.py

@@ -0,0 +1,80 @@
+"""Readonly builtin implementation.
+
+Usage: readonly [-p] [name[=value] ...]
+
+Marks variables as readonly. Once a variable is marked readonly, it cannot
+be reassigned or unset.
+
+Options:
+  -p    Display all readonly variables
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+def _result(stdout: str, stderr: str, exit_code: int) -> "ExecResult":
+    """Create an ExecResult."""
+    from ...types import ExecResult
+    return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+
+async def handle_readonly(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the readonly builtin."""
+    # Parse options
+    show_all = False
+    names = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "-p":
+            show_all = True
+        elif arg == "--":
+            names.extend(args[i + 1:])
+            break
+        elif arg.startswith("-"):
+            # Unknown option - ignore for now
+            pass
+        else:
+            names.append(arg)
+        i += 1
+
+    # If no names and -p or no args, show all readonly variables
+    if not names or show_all:
+        output = []
+        readonly_vars = ctx.state.env.get("__readonly__", "").split()
+        for var in sorted(readonly_vars):
+            if var in ctx.state.env:
+                value = ctx.state.env[var]
+                output.append(f"declare -r {var}=\"{value}\"")
+            else:
+                output.append(f"declare -r {var}")
+        if output:
+            return _result("\n".join(output) + "\n", "", 0)
+        return _result("", "", 0)
+
+    # Mark variables as readonly
+    readonly_set = set(ctx.state.env.get("__readonly__", "").split())
+
+    for name_value in names:
+        if "=" in name_value:
+            name, value = name_value.split("=", 1)
+            # Check if already readonly
+            if name in readonly_set:
+                return _result("", f"bash: readonly: {name}: readonly variable\n", 1)
+            ctx.state.env[name] = value
+        else:
+            name = name_value
+
+        readonly_set.add(name)
+
+    # Store readonly set
+    ctx.state.env["__readonly__"] = " ".join(sorted(readonly_set))
+
+    return _result("", "", 0)

just_bash/interpreter/builtins/set.py

@@ -0,0 +1,234 @@
+"""Set and shift builtin implementations.
+
+set - Set or unset shell options and positional parameters.
+
+Usage: set [options] [-- arg ...]
+       set +o
+       set -o [option]
+
+Options:
+  -e  errexit    Exit immediately if a command exits with non-zero status
+  -u  nounset    Treat unset variables as an error when substituting
+  -x  xtrace     Print commands and their arguments as they are executed
+  -v  verbose    Print shell input lines as they are read
+  -o pipefail    Return exit status of last failing command in pipeline
+
+shift - Shift positional parameters.
+
+Usage: shift [n]
+
+Shift positional parameters to the left by n (default 1).
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_set(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the set builtin."""
+    from ...types import ExecResult
+
+    # No arguments: print all variables
+    if not args:
+        lines = []
+        for k, v in sorted(ctx.state.env.items()):
+            # Skip internal variables
+            if k.startswith("PIPESTATUS_") or k == "?":
+                continue
+            lines.append(f"{k}='{v}'")
+        return ExecResult(stdout="\n".join(lines) + "\n", stderr="", exit_code=0)
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        # Handle -- which starts positional parameters
+        if arg == "--":
+            # Set positional parameters from remaining args
+            new_params = args[i + 1:]
+            _set_positional_params(ctx, new_params)
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Handle -o option
+        if arg == "-o":
+            if i + 1 < len(args):
+                i += 1
+                opt_name = args[i]
+                result = _set_option(ctx, opt_name, True)
+                if result:
+                    return result
+            else:
+                # List all options
+                stdout = _list_options(ctx)
+                return ExecResult(stdout=stdout, stderr="", exit_code=0)
+
+        # Handle +o option
+        elif arg == "+o":
+            if i + 1 < len(args):
+                i += 1
+                opt_name = args[i]
+                result = _set_option(ctx, opt_name, False)
+                if result:
+                    return result
+            else:
+                # List all options in a format that can be re-input
+                stdout = _list_options_script(ctx)
+                return ExecResult(stdout=stdout, stderr="", exit_code=0)
+
+        # Handle short options like -e, -u, -x, -v
+        elif arg.startswith("-") and len(arg) > 1 and arg[1] != "-":
+            for c in arg[1:]:
+                result = _set_short_option(ctx, c, True)
+                if result:
+                    return result
+
+        elif arg.startswith("+") and len(arg) > 1:
+            for c in arg[1:]:
+                result = _set_short_option(ctx, c, False)
+                if result:
+                    return result
+
+        # Treat as positional parameter
+        else:
+            new_params = args[i:]
+            _set_positional_params(ctx, new_params)
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        i += 1
+
+    return ExecResult(stdout="", stderr="", exit_code=0)
+
+
+def _set_positional_params(ctx: "InterpreterContext", params: list[str]) -> None:
+    """Set positional parameters $1, $2, etc."""
+    # Clear existing positional parameters
+    i = 1
+    while str(i) in ctx.state.env:
+        del ctx.state.env[str(i)]
+        i += 1
+
+    # Set new positional parameters
+    for i, param in enumerate(params, start=1):
+        ctx.state.env[str(i)] = param
+
+    # Update $# (number of positional parameters)
+    ctx.state.env["#"] = str(len(params))
+
+
+def _set_option(ctx: "InterpreterContext", name: str, enable: bool) -> "ExecResult | None":
+    """Set a named option. Returns error result if invalid option."""
+    from ...types import ExecResult
+
+    options = ctx.state.options
+    if name == "errexit":
+        options.errexit = enable
+    elif name == "nounset":
+        options.nounset = enable
+    elif name == "xtrace":
+        options.xtrace = enable
+    elif name == "verbose":
+        options.verbose = enable
+    elif name == "pipefail":
+        options.pipefail = enable
+    else:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: set: {name}: invalid option name\n",
+            exit_code=1,
+        )
+    return None
+
+
+def _set_short_option(ctx: "InterpreterContext", char: str, enable: bool) -> "ExecResult | None":
+    """Set a short option like -e. Returns error result if invalid."""
+    from ...types import ExecResult
+
+    options = ctx.state.options
+    if char == "e":
+        options.errexit = enable
+    elif char == "u":
+        options.nounset = enable
+    elif char == "x":
+        options.xtrace = enable
+    elif char == "v":
+        options.verbose = enable
+    else:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: set: -{char}: invalid option\n",
+            exit_code=1,
+        )
+    return None
+
+
+def _list_options(ctx: "InterpreterContext") -> str:
+    """List all options in human-readable format."""
+    options = ctx.state.options
+    lines = [
+        f"errexit         {'on' if options.errexit else 'off'}",
+        f"nounset         {'on' if options.nounset else 'off'}",
+        f"pipefail        {'on' if options.pipefail else 'off'}",
+        f"verbose         {'on' if options.verbose else 'off'}",
+        f"xtrace          {'on' if options.xtrace else 'off'}",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+def _list_options_script(ctx: "InterpreterContext") -> str:
+    """List options in re-inputable script format."""
+    options = ctx.state.options
+    lines = [
+        f"set {'-' if options.errexit else '+'}o errexit",
+        f"set {'-' if options.nounset else '+'}o nounset",
+        f"set {'-' if options.pipefail else '+'}o pipefail",
+        f"set {'-' if options.verbose else '+'}o verbose",
+        f"set {'-' if options.xtrace else '+'}o xtrace",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+async def handle_shift(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the shift builtin."""
+    from ...types import ExecResult
+
+    # Default shift count is 1
+    n = 1
+    if args:
+        try:
+            n = int(args[0])
+        except ValueError:
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: shift: {args[0]}: numeric argument required\n",
+                exit_code=1,
+            )
+
+    if n < 0:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: shift: {n}: shift count out of range\n",
+            exit_code=1,
+        )
+
+    # Get current positional parameters
+    param_count = int(ctx.state.env.get("#", "0"))
+
+    if n > param_count:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: shift: {n}: shift count out of range\n",
+            exit_code=1,
+        )
+
+    # Collect remaining parameters
+    new_params = []
+    for i in range(n + 1, param_count + 1):
+        new_params.append(ctx.state.env.get(str(i), ""))
+
+    # Set new positional parameters
+    _set_positional_params(ctx, new_params)
+
+    return ExecResult(stdout="", stderr="", exit_code=0)

just_bash/interpreter/builtins/shopt.py

@@ -0,0 +1,201 @@
+"""Shopt builtin implementation.
+
+Usage: shopt [-pqsu] [optname ...]
+
+Shell options control various behaviors of the shell.
+
+Options:
+  -s    Enable (set) each optname
+  -u    Disable (unset) each optname
+  -q    Quiet mode, suppress output (exit status indicates if option is set)
+  -p    Print options in a form that can be reused as input
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+# Default states for shell options
+DEFAULT_SHOPTS = {
+    # Bash common options
+    "expand_aliases": True,
+    "extglob": False,
+    "extquote": True,
+    "failglob": False,
+    "globstar": False,
+    "nocasematch": False,
+    "nullglob": False,
+    "dotglob": False,
+    "lastpipe": False,
+    "xpg_echo": False,
+    "progcomp": True,
+    "histappend": False,
+    "extdebug": False,
+    "inherit_errexit": False,
+    "command_sub_errexit": False,
+    "process_sub_fail": False,
+    # Strict options (for oil/ysh compatibility)
+    "strict_array": False,
+    "strict_arith": False,
+    "strict_argv": False,
+    "strict_arg_parse": False,
+    "strict_control_flow": False,
+    "strict_nameref": False,
+    "strict_word_eval": False,
+    "strict_tilde": False,
+    "strict_status": False,
+    "strict_binding": False,
+    "strict": False,
+    # Other options
+    "eval_unsafe_arith": False,
+    "ysh": False,
+    "compat_array": False,
+    "nounset": False,
+    "parse_at": False,
+    "simple_eval_builtin": False,
+    "no_last_fork": False,
+    "no_fork_last": False,
+    "no_dash_glob": False,
+    "globskipdots": True,
+    "ignore_shopt_not_impl": False,
+    "ignore_flags_not_impl": False,
+}
+
+
+def _result(stdout: str, stderr: str, exit_code: int) -> "ExecResult":
+    """Create an ExecResult."""
+    from ...types import ExecResult
+    return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+
+def _get_shopts(ctx: "InterpreterContext") -> dict[str, bool]:
+    """Get the shell options dictionary from context."""
+    # Store shopts in env with __shopt__ prefix
+    shopts = {}
+    for name, default in DEFAULT_SHOPTS.items():
+        key = f"__shopt_{name}__"
+        if key in ctx.state.env:
+            shopts[name] = ctx.state.env[key] == "1"
+        else:
+            shopts[name] = default
+    return shopts
+
+
+def _set_shopt(ctx: "InterpreterContext", name: str, value: bool) -> None:
+    """Set a shell option."""
+    ctx.state.env[f"__shopt_{name}__"] = "1" if value else "0"
+
+
+async def handle_shopt(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the shopt builtin."""
+    # Parse options
+    set_mode = False
+    unset_mode = False
+    quiet_mode = False
+    print_mode = False
+    optnames = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "-s":
+            set_mode = True
+        elif arg == "-u":
+            unset_mode = True
+        elif arg == "-q":
+            quiet_mode = True
+        elif arg == "-p":
+            print_mode = True
+        elif arg == "--":
+            optnames.extend(args[i + 1:])
+            break
+        elif arg.startswith("-"):
+            # Handle combined flags like -su
+            for c in arg[1:]:
+                if c == "s":
+                    set_mode = True
+                elif c == "u":
+                    unset_mode = True
+                elif c == "q":
+                    quiet_mode = True
+                elif c == "p":
+                    print_mode = True
+                else:
+                    return _result("", f"bash: shopt: -{c}: invalid option\n", 1)
+        else:
+            optnames.append(arg)
+        i += 1
+
+    shopts = _get_shopts(ctx)
+
+    # If both -s and -u specified, error
+    if set_mode and unset_mode:
+        return _result("", "bash: shopt: cannot set and unset options simultaneously\n", 1)
+
+    # No optnames and no -s/-u: show all options or those matching filter
+    if not optnames and not set_mode and not unset_mode:
+        output = []
+        for name in sorted(DEFAULT_SHOPTS.keys()):
+            state = shopts.get(name, DEFAULT_SHOPTS.get(name, False))
+            state_str = "on" if state else "off"
+            if print_mode:
+                prefix = "-s" if state else "-u"
+                output.append(f"shopt {prefix} {name}")
+            else:
+                output.append(f"{name}\t{state_str}")
+        if not quiet_mode:
+            return _result("\n".join(output) + "\n" if output else "", "", 0)
+        return _result("", "", 0)
+
+    # With -s/-u but no optnames: show options that match the state
+    if not optnames and (set_mode or unset_mode) and not quiet_mode:
+        target_state = set_mode
+        output = []
+        for name in sorted(DEFAULT_SHOPTS.keys()):
+            state = shopts.get(name, DEFAULT_SHOPTS.get(name, False))
+            if state == target_state:
+                state_str = "on" if state else "off"
+                if print_mode:
+                    prefix = "-s" if state else "-u"
+                    output.append(f"shopt {prefix} {name}")
+                else:
+                    output.append(f"{name}\t{state_str}")
+        return _result("\n".join(output) + "\n" if output else "", "", 0)
+
+    # Process optnames
+    exit_code = 0
+    output = []
+
+    for name in optnames:
+        # Check if option exists
+        if name not in DEFAULT_SHOPTS:
+            # Unknown option - but if ignore_shopt_not_impl is set, silently ignore
+            if shopts.get("ignore_shopt_not_impl", False):
+                continue
+            return _result("", f"bash: shopt: {name}: invalid shell option name\n", 1)
+
+        if set_mode:
+            _set_shopt(ctx, name, True)
+        elif unset_mode:
+            _set_shopt(ctx, name, False)
+        else:
+            # Query mode
+            state = shopts.get(name, DEFAULT_SHOPTS.get(name, False))
+            if not state:
+                exit_code = 1
+            if not quiet_mode:
+                state_str = "on" if state else "off"
+                if print_mode:
+                    prefix = "-s" if state else "-u"
+                    output.append(f"shopt {prefix} {name}")
+                else:
+                    output.append(f"{name}\t{state_str}")
+
+    if output and not quiet_mode:
+        return _result("\n".join(output) + "\n", "", exit_code)
+    return _result("", "", exit_code)

just_bash/interpreter/builtins/source.py

@@ -0,0 +1,136 @@
+"""Source and eval builtin implementations.
+
+source (or .) - Execute commands from a file in the current shell.
+
+Usage: source filename [arguments]
+       . filename [arguments]
+
+Read and execute commands from filename in the current shell environment.
+If arguments are supplied, they become the positional parameters when
+filename is executed.
+
+eval - Construct a command by concatenating arguments.
+
+Usage: eval [arg ...]
+
+Concatenate arguments into a single command, then execute.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_source(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the source / . builtin."""
+    from ...types import ExecResult
+
+    if not args:
+        return ExecResult(
+            stdout="",
+            stderr="bash: source: filename argument required\n",
+            exit_code=2,
+        )
+
+    filename = args[0]
+    script_args = args[1:]
+
+    # Resolve path
+    path = ctx.fs.resolve_path(ctx.state.cwd, filename)
+
+    # Read file
+    try:
+        content = await ctx.fs.read_file(path)
+    except FileNotFoundError:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: source: {filename}: No such file or directory\n",
+            exit_code=1,
+        )
+    except Exception as e:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: source: {filename}: {e}\n",
+            exit_code=1,
+        )
+
+    # Check source depth limit
+    ctx.state.source_depth += 1
+    if ctx.state.source_depth > ctx.limits.max_call_depth:
+        ctx.state.source_depth -= 1
+        return ExecResult(
+            stdout="",
+            stderr="bash: source: maximum source depth exceeded\n",
+            exit_code=1,
+        )
+
+    # Save and set positional parameters if arguments provided
+    saved_params = {}
+    saved_count = None
+    if script_args:
+        # Save current positional parameters
+        i = 1
+        while str(i) in ctx.state.env:
+            saved_params[str(i)] = ctx.state.env[str(i)]
+            i += 1
+        saved_count = ctx.state.env.get("#", "0")
+
+        # Clear and set new positional parameters
+        i = 1
+        while str(i) in ctx.state.env:
+            del ctx.state.env[str(i)]
+            i += 1
+
+        for i, arg in enumerate(script_args, start=1):
+            ctx.state.env[str(i)] = arg
+        ctx.state.env["#"] = str(len(script_args))
+
+    try:
+        # Parse and execute
+        from ...parser import parse
+
+        ast = parse(content)
+        result = await ctx.execute_script(ast)
+        return result
+    finally:
+        ctx.state.source_depth -= 1
+
+        # Restore positional parameters if we changed them
+        if saved_count is not None:
+            # Clear current positional parameters
+            i = 1
+            while str(i) in ctx.state.env:
+                del ctx.state.env[str(i)]
+                i += 1
+
+            # Restore saved parameters
+            for k, v in saved_params.items():
+                ctx.state.env[k] = v
+            ctx.state.env["#"] = saved_count
+
+
+async def handle_eval(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the eval builtin."""
+    from ...types import ExecResult
+
+    if not args:
+        return ExecResult(stdout="", stderr="", exit_code=0)
+
+    # Concatenate arguments with spaces
+    command = " ".join(args)
+
+    # Parse and execute
+    try:
+        from ...parser import parse
+
+        ast = parse(command)
+        result = await ctx.execute_script(ast)
+        return result
+    except Exception as e:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: eval: {e}\n",
+            exit_code=1,
+        )