just-bash 0.1.5__py3-none-any.whl

just_bash/interpreter/builtins/export.py

@@ -0,0 +1,56 @@
+"""Export builtin implementation.
+
+Usage: export [name[=value] ...]
+
+Mark variables for export to child processes. If no arguments are given,
+list all exported variables.
+"""
+
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_export(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the export builtin."""
+    from ...types import ExecResult
+
+    # No arguments: list all exported variables
+    if not args:
+        lines = []
+        for k, v in sorted(ctx.state.env.items()):
+            # Skip internal variables
+            if k.startswith("PIPESTATUS_") or k == "?" or k == "#":
+                continue
+            # Escape special characters in value
+            escaped_v = v.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'declare -x {k}="{escaped_v}"')
+        return ExecResult(stdout="\n".join(lines) + "\n" if lines else "", stderr="", exit_code=0)
+
+    # Process each argument
+    for arg in args:
+        # Skip options
+        if arg.startswith("-"):
+            continue
+
+        if "=" in arg:
+            name, value = arg.split("=", 1)
+        else:
+            # Export existing variable or create empty
+            name = arg
+            value = ctx.state.env.get(arg, "")
+
+        # Validate identifier
+        if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name):
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: export: '{name}': not a valid identifier\n",
+                exit_code=1,
+            )
+
+        ctx.state.env[name] = value
+
+    return ExecResult(stdout="", stderr="", exit_code=0)

just_bash/interpreter/builtins/let.py

@@ -0,0 +1,44 @@
+"""Let builtin implementation.
+
+Usage: let expr [expr ...]
+
+Evaluates arithmetic expressions. Each expr is evaluated as an arithmetic
+expression. Returns 0 if the last expression evaluates to non-zero, 1 otherwise.
+"""
+
+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_let(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the let builtin."""
+    from ..expansion import evaluate_arithmetic_sync
+    from ...parser.parser import Parser
+
+    if not args:
+        return _result("", "bash: let: expression expected\n", 1)
+
+    parser = Parser()
+    last_value = 0
+
+    for expr_str in args:
+        try:
+            # Parse and evaluate the arithmetic expression
+            arith_expr = parser._parse_arithmetic_expression(expr_str)
+            last_value = evaluate_arithmetic_sync(ctx, arith_expr)
+        except Exception as e:
+            return _result("", f"bash: let: {expr_str}: syntax error\n", 1)
+
+    # Return 0 if last value is non-zero, 1 if zero
+    return _result("", "", 0 if last_value != 0 else 1)

just_bash/interpreter/builtins/local.py

@@ -0,0 +1,57 @@
+"""Local builtin implementation.
+
+Usage: local [name[=value] ...]
+
+Create local variables for use within a function. When the function
+returns, any local variables are restored to their previous values.
+"""
+
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_local(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the local builtin."""
+    from ...types import ExecResult
+
+    # Check if we're inside a function
+    if not ctx.state.local_scopes:
+        return ExecResult(
+            stdout="",
+            stderr="bash: local: can only be used in a function\n",
+            exit_code=1,
+        )
+
+    current_scope = ctx.state.local_scopes[-1]
+
+    for arg in args:
+        # Skip options
+        if arg.startswith("-"):
+            continue
+
+        if "=" in arg:
+            name, value = arg.split("=", 1)
+        else:
+            name = arg
+            value = ""
+
+        # Validate identifier
+        if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name):
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: local: '{name}': not a valid identifier\n",
+                exit_code=1,
+            )
+
+        # Save original value for restoration (if not already saved)
+        if name not in current_scope:
+            current_scope[name] = ctx.state.env.get(name)
+
+        # Set the new value
+        ctx.state.env[name] = value
+
+    return ExecResult(stdout="", stderr="", exit_code=0)

just_bash/interpreter/builtins/mapfile.py

@@ -0,0 +1,152 @@
+"""Mapfile/readarray builtin implementation.
+
+Usage: mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+       readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+
+Reads lines from stdin into an array variable.
+
+Options:
+  -d delim    Use delim as line delimiter instead of newline
+  -n count    Read at most count lines (0 means all)
+  -O origin   Begin assigning at index origin (default 0)
+  -s count    Skip the first count lines
+  -t          Remove trailing delimiter from each line
+  array       Name of array variable (default: MAPFILE)
+"""
+
+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_mapfile(
+    ctx: "InterpreterContext", args: list[str], stdin: str = ""
+) -> "ExecResult":
+    """Execute the mapfile/readarray builtin."""
+    # Parse options
+    delimiter = "\n"
+    max_count = 0  # 0 means unlimited
+    origin = 0
+    skip_count = 0
+    strip_trailing = False
+    array_name = "MAPFILE"
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        if arg == "--":
+            if i + 1 < len(args):
+                array_name = args[i + 1]
+            break
+
+        if arg == "-d" and i + 1 < len(args):
+            delimiter = args[i + 1]
+            # Handle escape sequences
+            if delimiter == "\\n":
+                delimiter = "\n"
+            elif delimiter == "\\t":
+                delimiter = "\t"
+            elif delimiter == "":
+                delimiter = "\0"  # NUL delimiter
+            i += 2
+            continue
+
+        if arg == "-n" and i + 1 < len(args):
+            try:
+                max_count = int(args[i + 1])
+            except ValueError:
+                return _result("", f"bash: mapfile: {args[i + 1]}: invalid count\n", 1)
+            i += 2
+            continue
+
+        if arg == "-O" and i + 1 < len(args):
+            try:
+                origin = int(args[i + 1])
+            except ValueError:
+                return _result("", f"bash: mapfile: {args[i + 1]}: invalid origin\n", 1)
+            i += 2
+            continue
+
+        if arg == "-s" and i + 1 < len(args):
+            try:
+                skip_count = int(args[i + 1])
+            except ValueError:
+                return _result("", f"bash: mapfile: {args[i + 1]}: invalid count\n", 1)
+            i += 2
+            continue
+
+        if arg == "-t":
+            strip_trailing = True
+            i += 1
+            continue
+
+        if arg.startswith("-"):
+            # Unknown option - might be combined like -tn
+            for c in arg[1:]:
+                if c == "t":
+                    strip_trailing = True
+                elif c == "d":
+                    return _result("", "bash: mapfile: -d: option requires an argument\n", 1)
+                elif c == "n":
+                    return _result("", "bash: mapfile: -n: option requires an argument\n", 1)
+                elif c == "O":
+                    return _result("", "bash: mapfile: -O: option requires an argument\n", 1)
+                elif c == "s":
+                    return _result("", "bash: mapfile: -s: option requires an argument\n", 1)
+                else:
+                    return _result("", f"bash: mapfile: -{c}: invalid option\n", 2)
+            i += 1
+            continue
+
+        # Not an option - must be array name
+        array_name = arg
+        i += 1
+
+    # Clear existing array elements
+    prefix = f"{array_name}_"
+    to_remove = [k for k in ctx.state.env if k.startswith(prefix) and not k.startswith(f"{array_name}__")]
+    for k in to_remove:
+        del ctx.state.env[k]
+
+    # Mark as array
+    ctx.state.env[f"{array_name}__is_array"] = "indexed"
+
+    # Split input by delimiter
+    if not stdin:
+        return _result("", "", 0)
+
+    if delimiter == "\n":
+        lines = stdin.split("\n")
+        # Remove last empty element if input ends with newline
+        if lines and lines[-1] == "":
+            lines = lines[:-1]
+    else:
+        lines = stdin.split(delimiter)
+
+    # Skip first N lines
+    if skip_count > 0:
+        lines = lines[skip_count:]
+
+    # Limit to N lines
+    if max_count > 0:
+        lines = lines[:max_count]
+
+    # Store lines in array
+    for idx, line in enumerate(lines):
+        if strip_trailing:
+            # Remove trailing delimiter (already split, so just strip the char if present)
+            if delimiter != "\n" and line.endswith(delimiter):
+                line = line[:-len(delimiter)]
+
+        ctx.state.env[f"{array_name}_{origin + idx}"] = line
+
+    return _result("", "", 0)

just_bash/interpreter/builtins/misc.py

@@ -0,0 +1,378 @@
+"""Miscellaneous builtins: colon, true, false, type, command, builtin, exec, wait.
+
+These are simple builtins that don't need their own files.
+"""
+
+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_colon(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the : (colon) builtin - null command, always succeeds."""
+    return _result("", "", 0)
+
+
+async def handle_true(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the true builtin - always succeeds."""
+    return _result("", "", 0)
+
+
+async def handle_false(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the false builtin - always fails."""
+    return _result("", "", 1)
+
+
+async def handle_type(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the type builtin - display information about command type.
+
+    Usage: type [-afptP] name [name ...]
+
+    Options:
+      -a    Display all locations containing an executable named name
+      -f    Suppress shell function lookup
+      -p    Display path to executable (like which)
+      -P    Force path search even for builtins
+      -t    Output a single word: alias, keyword, function, builtin, file, or ''
+    """
+    from .alias import get_aliases
+
+    # Parse options
+    show_all = False
+    no_functions = False
+    path_only = False
+    force_path = False
+    type_only = False
+    names = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            names.extend(args[i + 1:])
+            break
+        elif arg.startswith("-") and len(arg) > 1:
+            for c in arg[1:]:
+                if c == "a":
+                    show_all = True
+                elif c == "f":
+                    no_functions = True
+                elif c == "p":
+                    path_only = True
+                elif c == "P":
+                    force_path = True
+                elif c == "t":
+                    type_only = True
+                else:
+                    return _result("", f"bash: type: -{c}: invalid option\n", 1)
+        else:
+            names.append(arg)
+        i += 1
+
+    if not names:
+        return _result("", "bash: type: usage: type [-afptP] name [name ...]\n", 1)
+
+    # Keywords
+    keywords = {
+        "if", "then", "else", "elif", "fi", "case", "esac", "for", "select",
+        "while", "until", "do", "done", "in", "function", "time", "coproc",
+        "{", "}", "!", "[[", "]]"
+    }
+
+    # Get builtins
+    from . import BUILTINS
+
+    # Get aliases
+    aliases = get_aliases(ctx)
+
+    # Get functions
+    functions = getattr(ctx.state, 'functions', {})
+
+    output = []
+    exit_code = 0
+
+    for name in names:
+        found = False
+
+        # Check alias (unless -f)
+        if not no_functions and name in aliases:
+            found = True
+            if type_only:
+                output.append("alias")
+            elif path_only:
+                pass  # -p doesn't show aliases
+            else:
+                output.append(f"{name} is aliased to `{aliases[name]}'")
+            if not show_all:
+                continue
+
+        # Check keyword
+        if name in keywords:
+            found = True
+            if type_only:
+                output.append("keyword")
+            elif not path_only:
+                output.append(f"{name} is a shell keyword")
+            if not show_all:
+                continue
+
+        # Check function (unless -f or -P)
+        if not no_functions and not force_path and name in functions:
+            found = True
+            if type_only:
+                output.append("function")
+            elif not path_only:
+                output.append(f"{name} is a function")
+            if not show_all:
+                continue
+
+        # Check builtin (unless -P)
+        if not force_path and name in BUILTINS:
+            found = True
+            if type_only:
+                output.append("builtin")
+            elif not path_only:
+                output.append(f"{name} is a shell builtin")
+            if not show_all:
+                continue
+
+        # Check command registry
+        from ...commands import COMMAND_NAMES
+        if name in COMMAND_NAMES:
+            found = True
+            if type_only:
+                output.append("file")
+            elif path_only:
+                output.append(name)
+            else:
+                output.append(f"{name} is {name}")
+            if not show_all:
+                continue
+
+        if not found:
+            if type_only:
+                output.append("")
+            else:
+                output.append(f"bash: type: {name}: not found")
+            exit_code = 1
+
+    if output:
+        return _result("\n".join(output) + "\n", "", exit_code)
+    return _result("", "", exit_code)
+
+
+async def handle_command(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the command builtin - run command bypassing functions.
+
+    Usage: command [-pVv] command [arguments ...]
+
+    Options:
+      -p    Use a default path to search for command
+      -v    Display description of command (like type)
+      -V    Display verbose description of command
+    """
+    # Parse options
+    describe = False
+    verbose = False
+    use_default_path = False
+    cmd_args = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            cmd_args = args[i + 1:]
+            break
+        elif arg.startswith("-") and len(arg) > 1 and not cmd_args:
+            for c in arg[1:]:
+                if c == "p":
+                    use_default_path = True
+                elif c == "v":
+                    describe = True
+                elif c == "V":
+                    verbose = True
+                else:
+                    return _result("", f"bash: command: -{c}: invalid option\n", 1)
+        else:
+            cmd_args = args[i:]
+            break
+        i += 1
+
+    if not cmd_args:
+        if describe or verbose:
+            return _result("", "", 0)
+        return _result("", "", 0)
+
+    cmd_name = cmd_args[0]
+
+    # Handle -v or -V: describe the command
+    if describe or verbose:
+        from . import BUILTINS
+        from ...commands import COMMAND_NAMES
+
+        if cmd_name in BUILTINS:
+            if verbose:
+                return _result(f"{cmd_name} is a shell builtin\n", "", 0)
+            else:
+                return _result(f"{cmd_name}\n", "", 0)
+        elif cmd_name in COMMAND_NAMES:
+            if verbose:
+                return _result(f"{cmd_name} is {cmd_name}\n", "", 0)
+            else:
+                return _result(f"{cmd_name}\n", "", 0)
+        else:
+            return _result("", f"bash: command: {cmd_name}: not found\n", 1)
+
+    # Execute the command, bypassing functions
+    # Store current function state and temporarily hide the function
+    functions = getattr(ctx.state, 'functions', {})
+    hidden_func = functions.pop(cmd_name, None)
+
+    try:
+        # Build command string with proper quoting
+        def shell_quote(s: str) -> str:
+            if not s or any(c in s for c in ' \t\n\'"\\$`!'):
+                return "'" + s.replace("'", "'\\''") + "'"
+            return s
+
+        cmd_str = " ".join(shell_quote(a) for a in cmd_args)
+        result = await ctx.exec_fn(cmd_str, None, None)
+        return result
+    finally:
+        # Restore function if it was hidden
+        if hidden_func is not None:
+            functions[cmd_name] = hidden_func
+
+
+async def handle_builtin(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the builtin builtin - run shell builtin directly.
+
+    Usage: builtin [shell-builtin [args]]
+    """
+    if not args:
+        return _result("", "", 0)
+
+    builtin_name = args[0]
+    builtin_args = args[1:]
+
+    from . import BUILTINS
+
+    if builtin_name not in BUILTINS:
+        return _result("", f"bash: builtin: {builtin_name}: not a shell builtin\n", 1)
+
+    handler = BUILTINS[builtin_name]
+    return await handler(ctx, builtin_args)
+
+
+async def handle_exec(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the exec builtin - replace shell with command.
+
+    Usage: exec [-cl] [-a name] [command [arguments ...]]
+
+    In a sandboxed environment, this just executes the command normally
+    since we can't actually replace the process.
+
+    Options:
+      -c    Execute command with empty environment
+      -l    Pass dash as zeroth argument (login shell)
+      -a name  Pass name as zeroth argument
+    """
+    # Parse options
+    clear_env = False
+    login_shell = False
+    arg0_name = None
+    cmd_args = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            cmd_args = args[i + 1:]
+            break
+        elif arg == "-c" and not cmd_args:
+            clear_env = True
+        elif arg == "-l" and not cmd_args:
+            login_shell = True
+        elif arg == "-a" and not cmd_args and i + 1 < len(args):
+            i += 1
+            arg0_name = args[i]
+        elif arg.startswith("-") and not cmd_args:
+            # Combined options
+            for c in arg[1:]:
+                if c == "c":
+                    clear_env = True
+                elif c == "l":
+                    login_shell = True
+                else:
+                    return _result("", f"bash: exec: -{c}: invalid option\n", 1)
+        else:
+            cmd_args = args[i:]
+            break
+        i += 1
+
+    # If no command, exec just affects redirections (which we don't handle here)
+    if not cmd_args:
+        return _result("", "", 0)
+
+    # In sandboxed mode, just execute the command
+    def shell_quote(s: str) -> str:
+        if not s or any(c in s for c in ' \t\n\'"\\$`!'):
+            return "'" + s.replace("'", "'\\''") + "'"
+        return s
+
+    cmd_str = " ".join(shell_quote(a) for a in cmd_args)
+    result = await ctx.exec_fn(cmd_str, None, None)
+    return result
+
+
+async def handle_wait(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the wait builtin - wait for background jobs.
+
+    Usage: wait [-fn] [-p var] [id ...]
+
+    In a sandboxed environment without true background jobs,
+    this is mostly a no-op but returns success.
+
+    Options:
+      -f    Wait for job termination (not just state change)
+      -n    Wait for any job to complete
+      -p var  Store PID in var
+    """
+    # Parse options
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--":
+            break
+        elif arg.startswith("-"):
+            # Accept but ignore options since we don't have real job control
+            if arg == "-p" and i + 1 < len(args):
+                i += 1
+        i += 1
+
+    # No real job control in sandboxed environment, return success
+    return _result("", "", 0)