just-bash 0.1.5__py3-none-any.whl

just_bash/interpreter/builtins/alias.py

@@ -0,0 +1,154 @@
+"""Alias builtin implementation.
+
+Usage: alias [-p] [name[=value] ...]
+
+Define or display aliases.
+
+Options:
+  -p    Print all aliases in reusable format
+"""
+
+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)
+
+
+def get_aliases(ctx: "InterpreterContext") -> dict[str, str]:
+    """Get the aliases dictionary from context."""
+    # Store aliases in a special env variable as a serialized format
+    # Or use a dedicated attribute on state
+    if not hasattr(ctx.state, '_aliases'):
+        ctx.state._aliases = {}
+    return ctx.state._aliases
+
+
+def set_alias(ctx: "InterpreterContext", name: str, value: str) -> None:
+    """Set an alias."""
+    aliases = get_aliases(ctx)
+    aliases[name] = value
+
+
+def unset_alias(ctx: "InterpreterContext", name: str) -> bool:
+    """Unset an alias. Returns True if it existed."""
+    aliases = get_aliases(ctx)
+    if name in aliases:
+        del aliases[name]
+        return True
+    return False
+
+
+async def handle_alias(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the alias builtin."""
+    # Parse options
+    print_format = False
+    names = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "-p":
+            print_format = True
+        elif arg == "--":
+            names.extend(args[i + 1:])
+            break
+        elif arg.startswith("-"):
+            return _result("", f"bash: alias: {arg}: invalid option\n", 1)
+        else:
+            names.append(arg)
+        i += 1
+
+    aliases = get_aliases(ctx)
+
+    # No arguments: show all aliases
+    if not names:
+        output = []
+        for name in sorted(aliases.keys()):
+            value = aliases[name]
+            output.append(f"alias {name}='{value}'")
+        if output:
+            return _result("\n".join(output) + "\n", "", 0)
+        return _result("", "", 0)
+
+    # Process arguments
+    output = []
+    exit_code = 0
+
+    for arg in names:
+        if "=" in arg:
+            # Define alias: name=value
+            eq_pos = arg.index("=")
+            name = arg[:eq_pos]
+            value = arg[eq_pos + 1:]
+            set_alias(ctx, name, value)
+        else:
+            # Show alias
+            name = arg
+            if name in aliases:
+                value = aliases[name]
+                output.append(f"alias {name}='{value}'")
+            else:
+                output.append(f"bash: alias: {name}: not found")
+                exit_code = 1
+
+    if output:
+        return _result("\n".join(output) + "\n", "", exit_code)
+    return _result("", "", exit_code)
+
+
+async def handle_unalias(
+    ctx: "InterpreterContext", args: list[str]
+) -> "ExecResult":
+    """Execute the unalias builtin.
+
+    Usage: unalias [-a] name [name ...]
+
+    Options:
+      -a    Remove all aliases
+    """
+    # Parse options
+    remove_all = False
+    names = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "-a":
+            remove_all = True
+        elif arg == "--":
+            names.extend(args[i + 1:])
+            break
+        elif arg.startswith("-"):
+            return _result("", f"bash: unalias: {arg}: invalid option\n", 1)
+        else:
+            names.append(arg)
+        i += 1
+
+    aliases = get_aliases(ctx)
+
+    if remove_all:
+        aliases.clear()
+        return _result("", "", 0)
+
+    if not names:
+        return _result("", "bash: unalias: usage: unalias [-a] name [name ...]\n", 1)
+
+    exit_code = 0
+    stderr_parts = []
+
+    for name in names:
+        if not unset_alias(ctx, name):
+            stderr_parts.append(f"bash: unalias: {name}: not found")
+            exit_code = 1
+
+    stderr = "\n".join(stderr_parts) + "\n" if stderr_parts else ""
+    return _result("", stderr, exit_code)

just_bash/interpreter/builtins/cd.py

@@ -0,0 +1,76 @@
+"""Cd builtin implementation.
+
+Usage: cd [dir]
+       cd -
+
+Change the current working directory to dir. If dir is not specified,
+change to $HOME. If dir is -, change to $OLDPWD.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+
+async def handle_cd(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the cd builtin."""
+    from ...types import ExecResult
+
+    # Determine target directory
+    if not args:
+        # cd with no args goes to HOME
+        target = ctx.state.env.get("HOME", "/")
+    elif args[0] == "-":
+        # cd - goes to previous directory
+        target = ctx.state.previous_dir
+        if not target:
+            return ExecResult(
+                stdout="",
+                stderr="bash: cd: OLDPWD not set\n",
+                exit_code=1,
+            )
+    else:
+        target = args[0]
+
+    # Resolve the path
+    new_dir = ctx.fs.resolve_path(ctx.state.cwd, target)
+
+    # Verify directory exists
+    try:
+        exists = await ctx.fs.exists(new_dir)
+        if not exists:
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: cd: {target}: No such file or directory\n",
+                exit_code=1,
+            )
+
+        is_dir = await ctx.fs.is_directory(new_dir)
+        if not is_dir:
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: cd: {target}: Not a directory\n",
+                exit_code=1,
+            )
+    except Exception as e:
+        return ExecResult(
+            stdout="",
+            stderr=f"bash: cd: {target}: {e}\n",
+            exit_code=1,
+        )
+
+    # Update state
+    old_dir = ctx.state.cwd
+    ctx.state.previous_dir = old_dir
+    ctx.state.cwd = new_dir
+    ctx.state.env["OLDPWD"] = old_dir
+    ctx.state.env["PWD"] = new_dir
+
+    # If cd - was used, print the new directory
+    stdout = ""
+    if args and args[0] == "-":
+        stdout = new_dir + "\n"
+
+    return ExecResult(stdout=stdout, stderr="", exit_code=0)

just_bash/interpreter/builtins/control.py

@@ -0,0 +1,127 @@
+"""Control flow builtins: break, continue, return, exit.
+
+These builtins control the flow of script execution.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..types import InterpreterContext
+    from ...types import ExecResult
+
+from ..errors import BreakError, ContinueError, ReturnError, ExitError
+
+
+async def handle_break(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the break builtin.
+
+    Usage: break [n]
+
+    Exit from within a for, while, until, or select loop.
+    If n is specified, break out of n enclosing loops.
+    """
+    levels = 1
+    if args:
+        try:
+            levels = int(args[0])
+            if levels < 1:
+                levels = 1
+        except ValueError:
+            from ...types import ExecResult
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: break: {args[0]}: numeric argument required\n",
+                exit_code=1,
+            )
+
+    # Check if we're in a loop
+    if ctx.state.loop_depth < 1:
+        from ...types import ExecResult
+        return ExecResult(
+            stdout="",
+            stderr="",  # bash doesn't print error for break outside loop
+            exit_code=0,
+        )
+
+    raise BreakError(levels=levels)
+
+
+async def handle_continue(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the continue builtin.
+
+    Usage: continue [n]
+
+    Resume the next iteration of an enclosing for, while, until, or select loop.
+    If n is specified, resume at the nth enclosing loop.
+    """
+    levels = 1
+    if args:
+        try:
+            levels = int(args[0])
+            if levels < 1:
+                levels = 1
+        except ValueError:
+            from ...types import ExecResult
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: continue: {args[0]}: numeric argument required\n",
+                exit_code=1,
+            )
+
+    # Check if we're in a loop
+    if ctx.state.loop_depth < 1:
+        from ...types import ExecResult
+        return ExecResult(
+            stdout="",
+            stderr="",  # bash doesn't print error for continue outside loop
+            exit_code=0,
+        )
+
+    raise ContinueError(levels=levels)
+
+
+async def handle_return(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the return builtin.
+
+    Usage: return [n]
+
+    Return from a shell function or sourced script.
+    n is the return value (0-255). If n is omitted, the return value is
+    the exit status of the last command executed.
+    """
+    exit_code = ctx.state.last_exit_code
+    if args:
+        try:
+            exit_code = int(args[0]) & 255  # Mask to 0-255
+        except ValueError:
+            from ...types import ExecResult
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: return: {args[0]}: numeric argument required\n",
+                exit_code=1,
+            )
+
+    raise ReturnError(exit_code)
+
+
+async def handle_exit(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the exit builtin.
+
+    Usage: exit [n]
+
+    Exit the shell with status n. If n is omitted, the exit status is
+    that of the last command executed.
+    """
+    exit_code = ctx.state.last_exit_code
+    if args:
+        try:
+            exit_code = int(args[0]) & 255  # Mask to 0-255
+        except ValueError:
+            from ...types import ExecResult
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: exit: {args[0]}: numeric argument required\n",
+                exit_code=1,
+            )
+
+    raise ExitError(exit_code)

just_bash/interpreter/builtins/declare.py

@@ -0,0 +1,336 @@
+"""Declare/typeset builtin implementation.
+
+Usage: declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]
+       typeset [-aAfFgiIlnrtux] [-p] [name[=value] ...]
+
+Options:
+  -a  indexed array
+  -A  associative array
+  -f  functions only
+  -F  function names only
+  -g  global scope (in function context)
+  -i  integer attribute
+  -l  lowercase
+  -n  nameref
+  -p  print declarations
+  -r  readonly
+  -t  trace (functions)
+  -u  uppercase
+  -x  export
+"""
+
+import re
+from typing import TYPE_CHECKING, Optional
+
+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_declare(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
+    """Execute the declare/typeset builtin."""
+    # Parse options
+    options = {
+        "array": False,        # -a: indexed array
+        "assoc": False,        # -A: associative array
+        "function": False,     # -f: functions
+        "func_names": False,   # -F: function names only
+        "global": False,       # -g: global scope
+        "integer": False,      # -i: integer
+        "lowercase": False,    # -l: lowercase
+        "nameref": False,      # -n: nameref
+        "print": False,        # -p: print declarations
+        "readonly": False,     # -r: readonly
+        "trace": False,        # -t: trace
+        "uppercase": False,    # -u: uppercase
+        "export": False,       # -x: export
+    }
+
+    names: list[str] = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        if arg == "--":
+            names.extend(args[i + 1:])
+            break
+
+        if arg.startswith("-") and len(arg) > 1 and arg[1] != "-":
+            # Parse short options
+            for c in arg[1:]:
+                if c == "a":
+                    options["array"] = True
+                elif c == "A":
+                    options["assoc"] = True
+                elif c == "f":
+                    options["function"] = True
+                elif c == "F":
+                    options["func_names"] = True
+                elif c == "g":
+                    options["global"] = True
+                elif c == "i":
+                    options["integer"] = True
+                elif c == "l":
+                    options["lowercase"] = True
+                elif c == "n":
+                    options["nameref"] = True
+                elif c == "p":
+                    options["print"] = True
+                elif c == "r":
+                    options["readonly"] = True
+                elif c == "t":
+                    options["trace"] = True
+                elif c == "u":
+                    options["uppercase"] = True
+                elif c == "x":
+                    options["export"] = True
+                else:
+                    return _result(
+                        "",
+                        f"bash: declare: -{c}: invalid option\n",
+                        2
+                    )
+        else:
+            names.append(arg)
+
+        i += 1
+
+    # Print mode: show variable declarations
+    if options["print"]:
+        return _print_declarations(ctx, names, options)
+
+    # No names: list variables with matching attributes
+    if not names:
+        return _list_variables(ctx, options)
+
+    # Process each name/assignment
+    exit_code = 0
+    stderr_parts = []
+
+    for name_arg in names:
+        # Parse name and optional value
+        if "=" in name_arg:
+            eq_idx = name_arg.index("=")
+            name = name_arg[:eq_idx]
+            value_str = name_arg[eq_idx + 1:]
+        else:
+            name = name_arg
+            value_str = None
+
+        # Handle array subscript in name: arr[idx]
+        subscript = None
+        if "[" in name and name.endswith("]"):
+            bracket_idx = name.index("[")
+            subscript = name[bracket_idx + 1:-1]
+            name = name[:bracket_idx]
+
+        # Validate identifier
+        if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name):
+            stderr_parts.append(f"bash: declare: `{name_arg}': not a valid identifier\n")
+            exit_code = 1
+            continue
+
+        # Handle array declaration
+        if options["array"] or options["assoc"]:
+            # Initialize array if not already set
+            array_key = f"{name}__is_array"
+            if array_key not in ctx.state.env:
+                ctx.state.env[array_key] = "assoc" if options["assoc"] else "indexed"
+
+            if value_str is not None:
+                # Parse array assignment: (a b c) or ([0]=a [1]=b)
+                if value_str.startswith("(") and value_str.endswith(")"):
+                    inner = value_str[1:-1].strip()
+                    _parse_array_assignment(ctx, name, inner, options["assoc"])
+                elif subscript is not None:
+                    # arr[idx]=value
+                    ctx.state.env[f"{name}_{subscript}"] = value_str
+                else:
+                    # Simple value assignment to array[0]
+                    ctx.state.env[f"{name}_0"] = value_str
+        else:
+            # Regular variable
+            if value_str is not None:
+                # Apply transformations
+                if options["integer"]:
+                    # Evaluate as integer
+                    try:
+                        value_str = str(_eval_integer(value_str, ctx))
+                    except Exception:
+                        value_str = "0"
+
+                if options["lowercase"]:
+                    value_str = value_str.lower()
+                elif options["uppercase"]:
+                    value_str = value_str.upper()
+
+                if subscript is not None:
+                    # Array element
+                    ctx.state.env[f"{name}_{subscript}"] = value_str
+                else:
+                    ctx.state.env[name] = value_str
+            elif name not in ctx.state.env:
+                # Declare without value - just set type info
+                if options["integer"]:
+                    ctx.state.env[f"{name}__is_integer"] = "1"
+                if options["lowercase"]:
+                    ctx.state.env[f"{name}__is_lower"] = "1"
+                if options["uppercase"]:
+                    ctx.state.env[f"{name}__is_upper"] = "1"
+
+    return _result("", "".join(stderr_parts), exit_code)
+
+
+def _parse_array_assignment(ctx: "InterpreterContext", name: str, inner: str, is_assoc: bool) -> None:
+    """Parse and assign array values from (a b c) or ([key]=value ...) syntax."""
+    # Clear existing array elements
+    to_remove = [k for k in ctx.state.env if k.startswith(f"{name}_") and not k.startswith(f"{name}__")]
+    for k in to_remove:
+        del ctx.state.env[k]
+
+    # Simple word splitting for now - doesn't handle all quoting cases
+    idx = 0
+    i = 0
+
+    while i < len(inner):
+        # Skip whitespace
+        while i < len(inner) and inner[i] in " \t":
+            i += 1
+
+        if i >= len(inner):
+            break
+
+        # Check for [key]=value syntax
+        if inner[i] == "[":
+            # Find closing bracket
+            j = i + 1
+            while j < len(inner) and inner[j] != "]":
+                j += 1
+            if j < len(inner) and j + 1 < len(inner) and inner[j + 1] == "=":
+                key = inner[i + 1:j]
+                # Find value
+                value_start = j + 2
+                value_end = value_start
+                in_quote = None
+                while value_end < len(inner):
+                    c = inner[value_end]
+                    if in_quote:
+                        if c == in_quote:
+                            in_quote = None
+                        value_end += 1
+                    elif c in "\"'":
+                        in_quote = c
+                        value_end += 1
+                    elif c in " \t":
+                        break
+                    else:
+                        value_end += 1
+
+                value = inner[value_start:value_end]
+                # Remove surrounding quotes if present
+                if len(value) >= 2 and value[0] in "\"'" and value[-1] == value[0]:
+                    value = value[1:-1]
+
+                ctx.state.env[f"{name}_{key}"] = value
+                i = value_end
+                continue
+
+        # Simple value - assign to next index
+        value_start = i
+        value_end = i
+        in_quote = None
+        while value_end < len(inner):
+            c = inner[value_end]
+            if in_quote:
+                if c == in_quote:
+                    in_quote = None
+                value_end += 1
+            elif c in "\"'":
+                in_quote = c
+                value_end += 1
+            elif c in " \t":
+                break
+            else:
+                value_end += 1
+
+        value = inner[value_start:value_end]
+        # Remove surrounding quotes if present
+        if len(value) >= 2 and value[0] in "\"'" and value[-1] == value[0]:
+            value = value[1:-1]
+
+        ctx.state.env[f"{name}_{idx}"] = value
+        idx += 1
+        i = value_end
+
+
+def _eval_integer(expr: str, ctx: "InterpreterContext") -> int:
+    """Evaluate a simple integer expression."""
+    # Handle variable references
+    expr = expr.strip()
+
+    # Try direct integer
+    try:
+        return int(expr)
+    except ValueError:
+        pass
+
+    # Try variable reference
+    if re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", expr):
+        val = ctx.state.env.get(expr, "0")
+        try:
+            return int(val)
+        except ValueError:
+            return 0
+
+    return 0
+
+
+def _print_declarations(ctx: "InterpreterContext", names: list[str], options: dict) -> "ExecResult":
+    """Print variable declarations."""
+    lines = []
+
+    if not names:
+        # Print all matching variables
+        for name in sorted(ctx.state.env.keys()):
+            if name.startswith("_") or "__" in name:
+                continue
+            if name in ("?", "#", "$", "!", "-", "*", "@"):
+                continue
+
+            val = ctx.state.env[name]
+            lines.append(f'declare -- {name}="{val}"')
+    else:
+        for name in names:
+            if name in ctx.state.env:
+                val = ctx.state.env[name]
+                lines.append(f'declare -- {name}="{val}"')
+            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}')
+
+    return _result("\n".join(lines) + "\n" if lines else "", "", 0)
+
+
+def _list_variables(ctx: "InterpreterContext", options: dict) -> "ExecResult":
+    """List variables with matching attributes."""
+    lines = []
+
+    for name in sorted(ctx.state.env.keys()):
+        if name.startswith("_") or "__" in name:
+            continue
+        if name in ("?", "#", "$", "!", "-", "*", "@"):
+            continue
+
+        val = ctx.state.env[name]
+        lines.append(f'declare -- {name}="{val}"')
+
+    return _result("\n".join(lines) + "\n" if lines else "", "", 0)