just-bash 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

just_bash/fs/overlay_fs.py

@@ -860,6 +860,20 @@ class OverlayFs:
             )
 
         target = real_path.readlink()
+        # Convert absolute real paths back to virtual paths to prevent leaking
+        if target.is_absolute():
+            # Resolve the target to handle symlinks in the path
+            # (e.g., macOS /var -> /private/var)
+            import os
+            resolved_target = Path(os.path.realpath(str(target)))
+            try:
+                relative = resolved_target.relative_to(self._root)
+                if self._mount_point == "/":
+                    return f"/{relative}"
+                return f"{self._mount_point}/{relative}"
+            except ValueError:
+                # Target is outside the overlay root
+                pass
         return str(target)
 
     def resolve_path(self, base: str, path: str) -> str:

just_bash/interpreter/__init__.py

@@ -1,7 +1,7 @@
 """Interpreter module for just-bash."""
 
 from .interpreter import Interpreter
-from .types import InterpreterContext, InterpreterState, ShellOptions
+from .types import InterpreterContext, InterpreterState, ShellOptions, VariableStore
 from .errors import (
     InterpreterError,
     ExitError,

just_bash/interpreter/builtins/__init__.py

@@ -20,6 +20,7 @@ from .let import handle_let
 from .readonly import handle_readonly
 from .shopt import handle_shopt
 from .alias import handle_alias, handle_unalias
+from .getopts import handle_getopts
 from .misc import (
     handle_colon,
     handle_true,
@@ -62,6 +63,7 @@ BUILTINS: dict[str, Callable[["InterpreterContext", list[str]], Awaitable["ExecR
     "shopt": handle_shopt,
     "alias": handle_alias,
     "unalias": handle_unalias,
+    "getopts": handle_getopts,
     ":": handle_colon,
     "true": handle_true,
     "false": handle_false,

just_bash/interpreter/builtins/control.py

@@ -27,11 +27,9 @@ async def handle_break(ctx: "InterpreterContext", args: list[str]) -> "ExecResul
             if levels < 1:
                 levels = 1
         except ValueError:
-            from ...types import ExecResult
-            return ExecResult(
-                stdout="",
+            raise ExitError(
+                128,
                 stderr=f"bash: break: {args[0]}: numeric argument required\n",
-                exit_code=1,
             )
 
     # Check if we're in a loop
@@ -61,11 +59,9 @@ async def handle_continue(ctx: "InterpreterContext", args: list[str]) -> "ExecRe
             if levels < 1:
                 levels = 1
         except ValueError:
-            from ...types import ExecResult
-            return ExecResult(
-                stdout="",
+            raise ExitError(
+                128,
                 stderr=f"bash: continue: {args[0]}: numeric argument required\n",
-                exit_code=1,
             )
 
     # Check if we're in a loop

just_bash/interpreter/builtins/declare.py

@@ -23,7 +23,7 @@ import re
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from ..types import InterpreterContext
+    from ..types import InterpreterContext, VariableStore
     from ...types import ExecResult
 
 
@@ -102,6 +102,10 @@ async def handle_declare(ctx: "InterpreterContext", args: list[str]) -> "ExecRes
 
         i += 1
 
+    # Handle -f or -F options (functions)
+    if options["function"] or options["func_names"]:
+        return _handle_functions(ctx, names, options)
+
     # Print mode: show variable declarations
     if options["print"]:
         return _print_declarations(ctx, names, options)
@@ -137,6 +141,32 @@ async def handle_declare(ctx: "InterpreterContext", args: list[str]) -> "ExecRes
             exit_code = 1
             continue
 
+        # Handle nameref declaration
+        from ..types import VariableStore
+        if options["nameref"] and isinstance(ctx.state.env, VariableStore):
+            if value_str is not None:
+                ctx.state.env.set_nameref(name, value_str)
+            else:
+                # declare -n without value just marks as nameref type
+                ctx.state.env.set_attribute(name, "n")
+            continue
+
+        # Handle readonly attribute
+        if options["readonly"] and isinstance(ctx.state.env, VariableStore):
+            ctx.state.env.set_attribute(name, "r")
+            ctx.state.readonly_vars.add(name) if hasattr(ctx.state, 'readonly_vars') else None
+            if value_str is not None:
+                ctx.state.env[name] = value_str
+            continue
+
+        # Handle export attribute
+        if options["export"]:
+            if isinstance(ctx.state.env, VariableStore):
+                ctx.state.env.set_attribute(name, "x")
+            if value_str is not None:
+                ctx.state.env[name] = value_str
+            continue
+
         # Handle array declaration
         if options["array"] or options["assoc"]:
             # Initialize array if not already set
@@ -157,6 +187,16 @@ async def handle_declare(ctx: "InterpreterContext", args: list[str]) -> "ExecRes
                     ctx.state.env[f"{name}_0"] = value_str
         else:
             # Regular variable
+            # Set attributes via metadata
+            from ..types import VariableStore
+            if isinstance(ctx.state.env, VariableStore):
+                if options["integer"]:
+                    ctx.state.env.set_attribute(name, "i")
+                if options["lowercase"]:
+                    ctx.state.env.set_attribute(name, "l")
+                if options["uppercase"]:
+                    ctx.state.env.set_attribute(name, "u")
+
             if value_str is not None:
                 # Apply transformations
                 if options["integer"]:
@@ -177,7 +217,7 @@ async def handle_declare(ctx: "InterpreterContext", args: list[str]) -> "ExecRes
                 else:
                     ctx.state.env[name] = value_str
             elif name not in ctx.state.env:
-                # Declare without value - just set type info
+                # Declare without value - just set type info (legacy compat)
                 if options["integer"]:
                     ctx.state.env[f"{name}__is_integer"] = "1"
                 if options["lowercase"]:
@@ -271,8 +311,10 @@ def _parse_array_assignment(ctx: "InterpreterContext", name: str, inner: str, is
 
 
 def _eval_integer(expr: str, ctx: "InterpreterContext") -> int:
-    """Evaluate a simple integer expression."""
-    # Handle variable references
+    """Evaluate an integer expression for declare -i."""
+    from ..expansion import evaluate_arithmetic_sync
+    from ...parser.parser import Parser
+
     expr = expr.strip()
 
     # Try direct integer
@@ -289,48 +331,303 @@ def _eval_integer(expr: str, ctx: "InterpreterContext") -> int:
         except ValueError:
             return 0
 
+    # Try arithmetic expression evaluation
+    try:
+        parser = Parser()
+        arith_expr = parser._parse_arith_comma(expr)
+        return evaluate_arithmetic_sync(ctx, arith_expr)
+    except Exception:
+        pass
+
     return 0
 
 
+def _get_attr_flags(env, name: str, ctx: "InterpreterContext") -> str:
+    """Get the declare attribute flags for a variable."""
+    from ..types import VariableStore
+    flags = ""
+    if isinstance(env, VariableStore):
+        attrs = env.get_attributes(name)
+        for attr in "rxilunt":
+            if attr in attrs:
+                flags += attr
+    elif name in ctx.state.readonly_vars:
+        flags += "r"
+    # Check array type
+    is_array = env.get(f"{name}__is_array")
+    if is_array == "assoc":
+        flags += "A"
+    elif is_array:
+        flags += "a"
+    return flags
+
+
+def _format_array_decl(env, name: str, flags: str) -> str:
+    """Format an array variable declaration."""
+    is_assoc = env.get(f"{name}__is_array") == "assoc"
+    prefix = f"{name}_"
+    elements = []
+    for key in sorted(env.keys()):
+        if key.startswith(prefix) and not key.startswith(f"{name}__"):
+            idx_part = key[len(prefix):]
+            val = env[key]
+            elements.append((idx_part, val))
+
+    if not is_assoc:
+        # Sort indexed arrays by numeric index
+        try:
+            elements.sort(key=lambda x: int(x[0]))
+        except ValueError:
+            pass
+
+    flag_str = f"-{flags}" if flags else "-a"
+    pairs = " ".join(f'[{idx}]="{val}"' for idx, val in elements)
+    if elements:
+        return f"declare {flag_str} {name}=({pairs})"
+    else:
+        return f"declare {flag_str} {name}=()"
+
+
+def _format_var_decl(env, name: str, ctx: "InterpreterContext") -> str | None:
+    """Format a single variable declaration. Returns None if not found."""
+    from ..types import VariableStore
+    flags = _get_attr_flags(env, name, ctx)
+
+    # Check for nameref
+    if isinstance(env, VariableStore) and env.is_nameref(name):
+        meta = env._metadata.get(name)
+        target = meta.nameref_target if meta else ""
+        flag_str = f"-{flags}" if flags else "-n"
+        return f'declare {flag_str} {name}="{target}"'
+
+    # Check for array
+    is_array = env.get(f"{name}__is_array")
+    if is_array:
+        return _format_array_decl(env, name, flags)
+
+    # Regular variable
+    if name in env:
+        val = env[name]
+        flag_str = f"-{flags}" if flags else "--"
+        return f'declare {flag_str} {name}="{val}"'
+
+    return None
+
+
 def _print_declarations(ctx: "InterpreterContext", names: list[str], options: dict) -> "ExecResult":
     """Print variable declarations."""
     lines = []
+    env = ctx.state.env
+    exit_code = 0
 
     if not names:
-        # Print all matching variables
-        for name in sorted(ctx.state.env.keys()):
-            if name.startswith("_") or "__" in name:
+        # Print all variables
+        # Collect unique variable names (skip internal keys)
+        seen = set()
+        for key in sorted(env.keys()):
+            if "__" in key:
+                # Extract base name from array keys like arr_0, arr__is_array
+                continue
+            if key.startswith("_"):
+                continue
+            if key in ("?", "#", "$", "!", "-", "*", "@"):
                 continue
-            if name in ("?", "#", "$", "!", "-", "*", "@"):
+            # Skip positional params and single-digit keys
+            if key.isdigit():
                 continue
 
-            val = ctx.state.env[name]
-            lines.append(f'declare -- {name}="{val}"')
+            seen.add(key)
+
+        # Also add arrays
+        for key in env.keys():
+            if key.endswith("__is_array"):
+                arr_name = key[:-len("__is_array")]
+                if not arr_name.startswith("_"):
+                    seen.add(arr_name)
+
+        for name in sorted(seen):
+            decl = _format_var_decl(env, name, ctx)
+            if decl:
+                lines.append(decl)
     else:
         for name in names:
-            if name in ctx.state.env:
-                val = ctx.state.env[name]
-                lines.append(f'declare -- {name}="{val}"')
+            decl = _format_var_decl(env, name, ctx)
+            if decl:
+                lines.append(decl)
             else:
-                # Check if it's an array
-                is_array = ctx.state.env.get(f"{name}__is_array")
-                if is_array:
-                    lines.append(f'declare -{("A" if is_array == "assoc" else "a")} {name}')
+                # Variable not found
+                lines_err = f"bash: declare: {name}: not found\n"
+                exit_code = 1
 
-    return _result("\n".join(lines) + "\n" if lines else "", "", 0)
+    stdout = "\n".join(lines) + "\n" if lines else ""
+    stderr = ""
+    if exit_code != 0 and not lines:
+        stderr = f"bash: declare: {names[0]}: not found\n" if names else ""
+    return _result(stdout, stderr, exit_code)
+
+
+def _handle_functions(ctx: "InterpreterContext", names: list[str], options: dict) -> "ExecResult":
+    """Handle declare -f (list function bodies) and -F (list function names)."""
+    functions = ctx.state.functions
+    lines = []
+    exit_code = 0
+
+    if options["func_names"]:
+        # -F: list function names only
+        if names:
+            for name in names:
+                if name in functions:
+                    lines.append(f"declare -f {name}")
+                else:
+                    exit_code = 1
+        else:
+            for name in sorted(functions.keys()):
+                lines.append(f"declare -f {name}")
+    else:
+        # -f: list function definitions
+        if names:
+            for name in names:
+                if name in functions:
+                    lines.append(_format_function_def(name, functions[name]))
+                else:
+                    exit_code = 1
+        else:
+            for name in sorted(functions.keys()):
+                lines.append(_format_function_def(name, functions[name]))
+
+    # If also -p, treat as print mode for functions
+    if options["print"] and not options["func_names"]:
+        # declare -fp: same as declare -f
+        pass
+
+    stdout = "\n".join(lines) + "\n" if lines else ""
+    return _result(stdout, "", exit_code)
+
+
+def _format_function_def(name: str, func_node) -> str:
+    """Format a function definition for output."""
+    # Try to reconstruct the function body from the AST
+    # For simplicity, output a placeholder that matches bash format
+    body = _ast_to_source(func_node.body) if func_node.body else "    :"
+    return f"{name} () \n{{\n{body}\n}}"
+
+
+def _ast_to_source(node) -> str:
+    """Best-effort AST to source code conversion."""
+    # This is a simplified reconstruction - bash's declare -f does perfect roundtrip
+    # but we can't easily reconstruct from AST without storing the original source
+    from ...ast.types import GroupNode, SimpleCommandNode, StatementNode
+    parts = []
+
+    body_stmts = []
+    if hasattr(node, 'body'):
+        body_stmts = node.body
+    elif hasattr(node, 'statements'):
+        body_stmts = node.statements
+
+    if not body_stmts:
+        return "    :"
+
+    for stmt in body_stmts:
+        line = _stmt_to_source(stmt)
+        if line:
+            parts.append(f"    {line}")
+
+    return "\n".join(parts) if parts else "    :"
+
+
+def _stmt_to_source(node) -> str:
+    """Convert a statement node to source."""
+    from ...ast.types import SimpleCommandNode
+    if hasattr(node, 'pipelines'):
+        cmd_parts = []
+        for i, pipeline in enumerate(node.pipelines):
+            if i > 0 and i - 1 < len(node.operators):
+                cmd_parts.append(node.operators[i - 1])
+            pipeline_str = _pipeline_to_source(pipeline)
+            cmd_parts.append(pipeline_str)
+        return " ".join(cmd_parts)
+    return ""
+
+
+def _pipeline_to_source(node) -> str:
+    """Convert a pipeline node to source."""
+    parts = []
+    for i, cmd in enumerate(node.commands):
+        if i > 0:
+            parts.append("|")
+        parts.append(_cmd_to_source(cmd))
+    result = " ".join(parts)
+    if node.negated:
+        result = f"! {result}"
+    return result
+
+
+def _cmd_to_source(node) -> str:
+    """Convert a command node to source."""
+    from ...ast.types import SimpleCommandNode
+    if isinstance(node, SimpleCommandNode) or (hasattr(node, 'type') and node.type == "SimpleCommand"):
+        parts = []
+        if node.name:
+            parts.append(_word_to_source(node.name))
+        for arg in node.args:
+            parts.append(_word_to_source(arg))
+        return " ".join(parts)
+    return ""
+
+
+def _word_to_source(word) -> str:
+    """Convert a word node to approximate source."""
+    parts = []
+    for part in word.parts:
+        if hasattr(part, 'value'):
+            parts.append(part.value)
+        elif hasattr(part, 'parts'):
+            inner = ""
+            for p in part.parts:
+                if hasattr(p, 'value'):
+                    inner += p.value
+                elif hasattr(p, 'parameter'):
+                    inner += f"${p.parameter}"
+            if part.type == "DoubleQuoted":
+                parts.append(f'"{inner}"')
+            elif part.type == "SingleQuoted":
+                parts.append(f"'{inner}'")
+            else:
+                parts.append(inner)
+        elif hasattr(part, 'parameter'):
+            parts.append(f"${part.parameter}")
+    return "".join(parts)
 
 
 def _list_variables(ctx: "InterpreterContext", options: dict) -> "ExecResult":
     """List variables with matching attributes."""
+    env = ctx.state.env
     lines = []
 
-    for name in sorted(ctx.state.env.keys()):
-        if name.startswith("_") or "__" in name:
+    # Collect unique variable names
+    seen = set()
+    for key in sorted(env.keys()):
+        if "__" in key:
             continue
-        if name in ("?", "#", "$", "!", "-", "*", "@"):
+        if key.startswith("_"):
             continue
-
-        val = ctx.state.env[name]
-        lines.append(f'declare -- {name}="{val}"')
+        if key in ("?", "#", "$", "!", "-", "*", "@"):
+            continue
+        if key.isdigit():
+            continue
+        seen.add(key)
+
+    # Also add arrays
+    for key in env.keys():
+        if key.endswith("__is_array"):
+            arr_name = key[:-len("__is_array")]
+            if not arr_name.startswith("_"):
+                seen.add(arr_name)
+
+    for name in sorted(seen):
+        decl = _format_var_decl(env, name, ctx)
+        if decl:
+            lines.append(decl)
 
     return _result("\n".join(lines) + "\n" if lines else "", "", 0)

just_bash/interpreter/builtins/getopts.py

@@ -0,0 +1,163 @@
+"""Getopts builtin implementation.
+
+Usage: getopts optstring name [args]
+
+Parse positional parameters as options.
+
+The optstring contains the option letters to be recognized.
+If a letter is followed by a colon, the option requires an argument.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_getopts(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the getopts builtin."""
+    from ...types import ExecResult
+
+    if len(args) < 2:
+        return ExecResult(
+            stdout="",
+            stderr="bash: getopts: usage: getopts optstring name [arg ...]\n",
+            exit_code=2,
+        )
+
+    optstring = args[0]
+    name = args[1]
+
+    # Validate variable name
+    import re
+    valid_name = bool(re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name))
+
+    # Get the arguments to parse (from args[2:] or positional params)
+    if len(args) > 2:
+        parse_args = args[2:]
+    else:
+        # Use positional parameters
+        parse_args = []
+        i = 1
+        while str(i) in ctx.state.env:
+            parse_args.append(ctx.state.env[str(i)])
+            i += 1
+
+    # Get current OPTIND (1-based)
+    try:
+        optind = int(ctx.state.env.get("OPTIND", "1"))
+    except ValueError:
+        optind = 1
+
+    # Check if we've exhausted all arguments
+    if optind > len(parse_args):
+        ctx.state.env[name] = "?"
+        return ExecResult(stdout="", stderr="", exit_code=1)
+
+    current_arg = parse_args[optind - 1]
+
+    # Check if current arg is an option
+    if not current_arg.startswith("-") or current_arg == "-" or current_arg == "--":
+        ctx.state.env[name] = "?"
+        if current_arg == "--":
+            ctx.state.env["OPTIND"] = str(optind + 1)
+        return ExecResult(stdout="", stderr="", exit_code=1)
+
+    # Get the option character
+    # Handle multi-character processing within a single -abc argument
+    optchar_idx_key = "__getopts_charpos"
+    try:
+        charpos = int(ctx.state.env.get(optchar_idx_key, "1"))
+    except ValueError:
+        charpos = 1
+
+    if charpos >= len(current_arg):
+        # Move to next argument
+        optind += 1
+        charpos = 1
+        if optind > len(parse_args):
+            ctx.state.env[name] = "?"
+            ctx.state.env["OPTIND"] = str(optind)
+            ctx.state.env.pop(optchar_idx_key, None)
+            return ExecResult(stdout="", stderr="", exit_code=1)
+        current_arg = parse_args[optind - 1]
+        if not current_arg.startswith("-") or current_arg == "-" or current_arg == "--":
+            ctx.state.env[name] = "?"
+            ctx.state.env["OPTIND"] = str(optind + (1 if current_arg == "--" else 0))
+            ctx.state.env.pop(optchar_idx_key, None)
+            return ExecResult(stdout="", stderr="", exit_code=1)
+
+    opt_char = current_arg[charpos]
+
+    # Check if this option is valid
+    opt_idx = optstring.find(opt_char)
+    stderr = ""
+
+    if opt_idx == -1:
+        # Invalid option
+        ctx.state.env[name] = "?"
+        if optstring.startswith(":"):
+            # Silent mode: OPTARG = the invalid option character
+            ctx.state.env["OPTARG"] = opt_char
+        else:
+            # Normal mode: OPTARG is unset, print error
+            ctx.state.env.pop("OPTARG", None)
+            stderr = f"bash: getopts: illegal option -- {opt_char}\n"
+
+        # Advance position
+        if charpos + 1 < len(current_arg):
+            ctx.state.env[optchar_idx_key] = str(charpos + 1)
+        else:
+            ctx.state.env["OPTIND"] = str(optind + 1)
+            ctx.state.env.pop(optchar_idx_key, None)
+
+        return ExecResult(stdout="", stderr=stderr, exit_code=0)
+
+    # Valid option - check if it requires an argument
+    needs_arg = opt_idx + 1 < len(optstring) and optstring[opt_idx + 1] == ":"
+
+    if needs_arg:
+        # Check for argument
+        if charpos + 1 < len(current_arg):
+            # Argument is the rest of this token
+            ctx.state.env["OPTARG"] = current_arg[charpos + 1:]
+            ctx.state.env["OPTIND"] = str(optind + 1)
+            ctx.state.env.pop(optchar_idx_key, None)
+        elif optind < len(parse_args):
+            # Argument is the next token
+            ctx.state.env["OPTARG"] = parse_args[optind]
+            ctx.state.env["OPTIND"] = str(optind + 2)
+            ctx.state.env.pop(optchar_idx_key, None)
+        else:
+            # Missing argument
+            if optstring.startswith(":"):
+                ctx.state.env[name] = ":"
+                ctx.state.env["OPTARG"] = opt_char
+            else:
+                ctx.state.env[name] = "?"
+                ctx.state.env.pop("OPTARG", None)
+                stderr = f"bash: getopts: option requires an argument -- {opt_char}\n"
+            ctx.state.env["OPTIND"] = str(optind + 1)
+            ctx.state.env.pop(optchar_idx_key, None)
+            return ExecResult(stdout="", stderr=stderr, exit_code=0)
+    else:
+        # No argument needed
+        ctx.state.env.pop("OPTARG", None)
+        if charpos + 1 < len(current_arg):
+            # More options in this token
+            ctx.state.env[optchar_idx_key] = str(charpos + 1)
+        else:
+            # Move to next argument
+            ctx.state.env["OPTIND"] = str(optind + 1)
+            ctx.state.env.pop(optchar_idx_key, None)
+
+    if valid_name:
+        ctx.state.env[name] = opt_char
+        return ExecResult(stdout="", stderr=stderr, exit_code=0)
+    else:
+        return ExecResult(
+            stdout="",
+            stderr=stderr + f"bash: getopts: `{name}': not a valid identifier\n",
+            exit_code=1,
+        )

just_bash/interpreter/builtins/let.py

@@ -23,7 +23,7 @@ async def handle_let(
     ctx: "InterpreterContext", args: list[str]
 ) -> "ExecResult":
     """Execute the let builtin."""
-    from ..expansion import evaluate_arithmetic_sync
+    from ..expansion import evaluate_arithmetic
     from ...parser.parser import Parser
 
     if not args:
@@ -36,7 +36,7 @@ async def handle_let(
         try:
             # Parse and evaluate the arithmetic expression
             arith_expr = parser._parse_arithmetic_expression(expr_str)
-            last_value = evaluate_arithmetic_sync(ctx, arith_expr)
+            last_value = await evaluate_arithmetic(ctx, arith_expr)
         except Exception as e:
             return _result("", f"bash: let: {expr_str}: syntax error\n", 1)