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

just_bash/commands/sed/sed.py

@@ -31,6 +31,59 @@ from dataclasses import dataclass
 from ...types import CommandContext, ExecResult
 
 
+def _bre_to_python(pattern: str) -> str:
+    """Convert a BRE (Basic Regular Expression) pattern to Python ERE.
+
+    In BRE: +, ?, (, ), {, }, | are literal; \\+, \\?, \\(, \\), \\{, \\}, \\| are special.
+    In Python ERE: +, ?, (, ), {, }, | are special; \\+, \\?, etc. are literal.
+    """
+    result = []
+    i = 0
+    in_bracket = False
+    while i < len(pattern):
+        ch = pattern[i]
+        if in_bracket:
+            result.append(ch)
+            if ch == "]" and i > 0:
+                in_bracket = False
+            i += 1
+            continue
+        if ch == "[":
+            in_bracket = True
+            result.append(ch)
+            i += 1
+            # Handle ] as first char in bracket (literal)
+            if i < len(pattern) and pattern[i] == "^":
+                result.append(pattern[i])
+                i += 1
+            if i < len(pattern) and pattern[i] == "]":
+                result.append(pattern[i])
+                i += 1
+            continue
+        if ch == "\\" and i + 1 < len(pattern):
+            nxt = pattern[i + 1]
+            if nxt in "+?(){}|":
+                # BRE \+ \? \( \) \{ \} \| → ERE special
+                result.append(nxt)
+                i += 2
+                continue
+            else:
+                # Other escape sequences pass through
+                result.append(ch)
+                result.append(nxt)
+                i += 2
+                continue
+        if ch in "+?(){}|":
+            # Literal in BRE → escape for Python ERE
+            result.append("\\")
+            result.append(ch)
+            i += 1
+            continue
+        result.append(ch)
+        i += 1
+    return "".join(result)
+
+
 @dataclass
 class SedAddress:
     """Represents a sed address."""
@@ -48,6 +101,7 @@ class SedCommand_:
 
     cmd: str  # s, d, p, a, i, y, q, h, H, g, G, x, n, N, etc.
     address: SedAddress | None = None
+    negate: bool = False  # ! address negation
     pattern: re.Pattern | None = None
     replacement: str | None = None
     flags: str = ""
@@ -258,18 +312,55 @@ class SedCommand:
         commands: list[SedCommand_] = []
 
         for script in scripts:
-            # Handle multiple commands separated by semicolons or newlines
-            for cmd_str in re.split(r"[;\n]", script):
+            # Split respecting brace nesting
+            for cmd_str in self._split_script(script):
                 cmd_str = cmd_str.strip()
                 if not cmd_str:
                     continue
 
-                cmd = self._parse_command(cmd_str, extended_regex)
-                if cmd:
-                    commands.append(cmd)
+                # Handle grouped commands: addr{cmd1;cmd2}
+                brace_pos = cmd_str.find("{")
+                if brace_pos != -1 and cmd_str.endswith("}"):
+                    addr_prefix = cmd_str[:brace_pos]
+                    inner = cmd_str[brace_pos + 1 : -1]
+                    for inner_cmd in inner.split(";"):
+                        inner_cmd = inner_cmd.strip()
+                        if inner_cmd:
+                            full_cmd = addr_prefix + inner_cmd
+                            cmd = self._parse_command(full_cmd, extended_regex)
+                            if cmd:
+                                commands.append(cmd)
+                else:
+                    cmd = self._parse_command(cmd_str, extended_regex)
+                    if cmd:
+                        commands.append(cmd)
 
         return commands
 
+    def _split_script(self, script: str) -> list[str]:
+        """Split a script on semicolons and newlines, respecting brace nesting."""
+        parts: list[str] = []
+        current: list[str] = []
+        depth = 0
+
+        for ch in script:
+            if ch == "{":
+                depth += 1
+                current.append(ch)
+            elif ch == "}":
+                depth -= 1
+                current.append(ch)
+            elif ch in ";\n" and depth == 0:
+                parts.append("".join(current))
+                current = []
+            else:
+                current.append(ch)
+
+        if current:
+            parts.append("".join(current))
+
+        return parts
+
     def _parse_command(self, cmd_str: str, extended_regex: bool) -> SedCommand_ | None:
         """Parse a single sed command."""
         pos = 0
@@ -299,7 +390,8 @@ class SedCommand:
                 pattern = cmd_str[1:end]
                 flags = re.IGNORECASE if extended_regex else 0
                 try:
-                    address = SedAddress(type="regex", regex=re.compile(pattern, flags))
+                    py_pat = pattern if extended_regex else _bre_to_python(pattern)
+                    address = SedAddress(type="regex", regex=re.compile(py_pat, flags))
                 except re.error as e:
                     raise ValueError(f"invalid regex: {e}")
                 pos = end + 1
@@ -320,11 +412,12 @@ class SedCommand:
                             end2 = self._find_delimiter(cmd_str, pos + 1, "/")
                             if end2 != -1:
                                 pattern2 = cmd_str[pos + 1:end2]
+                                py_pat2 = pattern2 if extended_regex else _bre_to_python(pattern2)
                                 try:
                                     address = SedAddress(
                                         type="range",
                                         regex=address.regex,
-                                        end_regex=re.compile(pattern2, flags),
+                                        end_regex=re.compile(py_pat2, flags),
                                     )
                                 except re.error as e:
                                     raise ValueError(f"invalid regex: {e}")
@@ -334,11 +427,21 @@ class SedCommand:
         while pos < len(cmd_str) and cmd_str[pos] in " \t":
             pos += 1
 
+        # Check for negation
+        negate = False
+        if pos < len(cmd_str) and cmd_str[pos] == "!":
+            negate = True
+            pos += 1
+            # Skip whitespace after !
+            while pos < len(cmd_str) and cmd_str[pos] in " \t":
+                pos += 1
+
         if pos >= len(cmd_str):
             return None
 
         cmd_char = cmd_str[pos]
         pos += 1
+        result = None
 
         if cmd_char == "s":
             # Substitution
@@ -370,11 +473,12 @@ class SedCommand:
                 regex_flags |= re.IGNORECASE
 
             try:
-                compiled = re.compile(pattern, regex_flags)
+                py_pat = pattern if extended_regex else _bre_to_python(pattern)
+                compiled = re.compile(py_pat, regex_flags)
             except re.error as e:
                 raise ValueError(f"invalid regex: {e}")
 
-            return SedCommand_(
+            result = SedCommand_(
                 cmd="s",
                 address=address,
                 pattern=compiled,
@@ -404,7 +508,7 @@ class SedCommand:
             if len(source) != len(dest):
                 raise ValueError("y command requires equal length strings")
 
-            return SedCommand_(
+            result = SedCommand_(
                 cmd="y",
                 address=address,
                 source=source,
@@ -412,91 +516,95 @@ class SedCommand:
             )
 
         elif cmd_char == "d":
-            return SedCommand_(cmd="d", address=address)
+            result = SedCommand_(cmd="d", address=address)
 
         elif cmd_char == "=":
             # Print line number
-            return SedCommand_(cmd="=", address=address)
+            result = SedCommand_(cmd="=", address=address)
 
         elif cmd_char == "p":
-            return SedCommand_(cmd="p", address=address)
+            result = SedCommand_(cmd="p", address=address)
 
         elif cmd_char == "l":
             # List pattern space with escapes
-            return SedCommand_(cmd="l", address=address)
+            result = SedCommand_(cmd="l", address=address)
 
         elif cmd_char == "F":
             # Print filename
-            return SedCommand_(cmd="F", address=address)
+            result = SedCommand_(cmd="F", address=address)
 
         elif cmd_char == "q":
-            return SedCommand_(cmd="q", address=address)
+            result = SedCommand_(cmd="q", address=address)
 
         elif cmd_char in ("a", "i", "c"):
             # Append, insert, or change
             text = cmd_str[pos:].lstrip()
             if text.startswith("\\"):
                 text = text[1:].lstrip()
-            return SedCommand_(cmd=cmd_char, address=address, text=text)
+            result = SedCommand_(cmd=cmd_char, address=address, text=text)
 
         elif cmd_char in ("h", "H", "g", "G", "x"):
             # Hold space commands
-            return SedCommand_(cmd=cmd_char, address=address)
+            result = SedCommand_(cmd=cmd_char, address=address)
 
         elif cmd_char in ("n", "N"):
             # Next line commands
-            return SedCommand_(cmd=cmd_char, address=address)
+            result = SedCommand_(cmd=cmd_char, address=address)
 
         elif cmd_char in ("P", "D"):
             # Print/delete first line of pattern space
-            return SedCommand_(cmd=cmd_char, address=address)
+            result = SedCommand_(cmd=cmd_char, address=address)
 
         elif cmd_char == "b":
             # Branch to label
             label = cmd_str[pos:].strip()
-            return SedCommand_(cmd="b", address=address, label=label)
+            result = SedCommand_(cmd="b", address=address, label=label)
 
         elif cmd_char == "t":
             # Branch on successful substitute
             label = cmd_str[pos:].strip()
-            return SedCommand_(cmd="t", address=address, label=label)
+            result = SedCommand_(cmd="t", address=address, label=label)
 
         elif cmd_char == "T":
             # Branch on failed substitute
             label = cmd_str[pos:].strip()
-            return SedCommand_(cmd="T", address=address, label=label)
+            result = SedCommand_(cmd="T", address=address, label=label)
 
         elif cmd_char == ":":
             # Label definition
             label = cmd_str[pos:].strip()
-            return SedCommand_(cmd=":", label=label)
+            result = SedCommand_(cmd=":", label=label)
 
         elif cmd_char == "r":
             # Read file
             filename = cmd_str[pos:].strip()
-            return SedCommand_(cmd="r", address=address, filename=filename)
+            result = SedCommand_(cmd="r", address=address, filename=filename)
 
         elif cmd_char == "w":
             # Write to file
             filename = cmd_str[pos:].strip()
-            return SedCommand_(cmd="w", address=address, filename=filename)
+            result = SedCommand_(cmd="w", address=address, filename=filename)
 
         elif cmd_char == "R":
             # Read single line from file
             filename = cmd_str[pos:].strip()
-            return SedCommand_(cmd="R", address=address, filename=filename)
+            result = SedCommand_(cmd="R", address=address, filename=filename)
 
         elif cmd_char == "{":
             # Start of block (handled in parsing)
-            return None
+            pass
 
         elif cmd_char == "}":
             # End of block (handled in parsing)
-            return None
+            pass
 
         else:
             raise ValueError(f"unknown command: {cmd_char}")
 
+        if result is not None and negate:
+            result.negate = True
+        return result
+
     def _find_delimiter(self, s: str, start: int, delim: str) -> int:
         """Find the next unescaped delimiter."""
         i = start
@@ -570,8 +678,11 @@ class SedCommand:
                     cmd_idx += 1
                     continue
 
-                # Check if address matches
-                if not self._address_matches(cmd.address, line_num, total_lines, pattern_space, in_range, cmd_idx):
+                # Check if address matches (with negation support)
+                matches = self._address_matches(cmd.address, line_num, total_lines, pattern_space, in_range, cmd_idx)
+                if cmd.negate:
+                    matches = not matches
+                if not matches:
                     cmd_idx += 1
                     continue
 

just_bash/commands/shuf/__init__.py

@@ -0,0 +1,5 @@
+"""Shuf command."""
+
+from .shuf import ShufCommand
+
+__all__ = ["ShufCommand"]

just_bash/commands/shuf/shuf.py

@@ -0,0 +1,242 @@
+"""Shuf command implementation.
+
+Usage: shuf [OPTION]... [FILE]
+   or: shuf -e [OPTION]... [ARG]...
+   or: shuf -i LO-HI [OPTION]...
+
+Write a random permutation of the input lines to standard output.
+
+Options:
+  -e, --echo              treat each ARG as an input line
+  -i, --input-range=LO-HI treat each number LO through HI as an input line
+  -n, --head-count=COUNT  output at most COUNT lines
+  -o, --output=FILE       write result to FILE instead of standard output
+  -r, --repeat            output lines can be repeated (requires -n)
+  --random-source=FILE    get random bytes from FILE
+"""
+
+import random
+from ...types import CommandContext, ExecResult
+
+
+class ShufCommand:
+    """The shuf command."""
+
+    name = "shuf"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the shuf command."""
+        # Parse arguments
+        echo_mode = False
+        input_range = None
+        head_count = None
+        output_file = None
+        repeat = False
+        random_source = None
+        input_args: list[str] = []
+        input_file = None
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+
+            if arg in ("-e", "--echo"):
+                echo_mode = True
+            elif arg in ("-r", "--repeat"):
+                repeat = True
+            elif arg == "-n":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'n'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                try:
+                    head_count = int(args[i])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-n"):
+                try:
+                    head_count = int(arg[2:])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("--head-count="):
+                try:
+                    head_count = int(arg[13:])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{arg[13:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-i":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'i'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                input_range = args[i]
+            elif arg.startswith("-i"):
+                input_range = arg[2:]
+            elif arg.startswith("--input-range="):
+                input_range = arg[14:]
+            elif arg == "-o":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'o'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                output_file = args[i]
+            elif arg.startswith("-o"):
+                output_file = arg[2:]
+            elif arg.startswith("--output="):
+                output_file = arg[9:]
+            elif arg.startswith("--random-source="):
+                random_source = arg[16:]
+            elif arg == "--random-source":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'random-source'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                random_source = args[i]
+            elif arg.startswith("-") and len(arg) > 1 and arg != "-":
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                if echo_mode:
+                    input_args.append(arg)
+                elif input_file is None:
+                    input_file = arg
+                else:
+                    input_args.append(arg)
+
+            i += 1
+
+        # Set up random generator
+        rng = random.Random()
+        if random_source:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, random_source)
+                seed_data = await ctx.fs.read_file(path)
+                # Use hash of file content as seed
+                rng.seed(hash(seed_data))
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: {random_source}: No such file or directory\n",
+                    exit_code=1,
+                )
+
+        # Get input lines
+        lines: list[str] = []
+
+        if input_range:
+            # Parse range LO-HI
+            if "-" not in input_range:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            parts = input_range.split("-", 1)
+            try:
+                lo = int(parts[0])
+                hi = int(parts[1])
+            except ValueError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            if lo > hi:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            lines = [str(n) for n in range(lo, hi + 1)]
+        elif echo_mode:
+            lines = input_args
+        else:
+            # Read from file or stdin
+            if input_file:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, input_file)
+                    content = await ctx.fs.read_file(path)
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: {input_file}: No such file or directory\n",
+                        exit_code=1,
+                    )
+            else:
+                content = ctx.stdin
+
+            if content:
+                # Split into lines, preserving empty lines but removing final newline
+                if content.endswith("\n"):
+                    content = content[:-1]
+                if content:
+                    lines = content.split("\n")
+
+        # Handle empty input
+        if not lines:
+            if output_file:
+                path = ctx.fs.resolve_path(ctx.cwd, output_file)
+                await ctx.fs.write_file(path, "")
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Generate output
+        output_lines: list[str] = []
+
+        if repeat:
+            # With repeat, we can output more lines than input
+            count = head_count if head_count is not None else len(lines)
+            for _ in range(count):
+                output_lines.append(rng.choice(lines))
+        else:
+            # Shuffle and optionally limit
+            shuffled = lines.copy()
+            rng.shuffle(shuffled)
+            if head_count is not None:
+                output_lines = shuffled[:head_count]
+            else:
+                output_lines = shuffled
+
+        # Build output
+        output = "\n".join(output_lines)
+        if output:
+            output += "\n"
+
+        # Write to file or stdout
+        if output_file:
+            path = ctx.fs.resolve_path(ctx.cwd, output_file)
+            await ctx.fs.write_file(path, output)
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/commands/stat/stat.py

@@ -113,6 +113,15 @@ class StatCommand:
         # %G - group name (hardcoded for virtual FS)
         result = result.replace("%G", "group")
 
+        # %Y - modification time as seconds since Epoch
+        result = result.replace("%Y", str(int(stat.mtime)))
+
+        # %X - access time as seconds since Epoch (same as mtime for our FS)
+        result = result.replace("%X", str(int(stat.mtime)))
+
+        # %Z - change time as seconds since Epoch (same as mtime for our FS)
+        result = result.replace("%Z", str(int(stat.mtime)))
+
         return result + "\n"
 
     def _default_format(self, path: str, stat) -> str:

just_bash/commands/time/__init__.py

@@ -0,0 +1,5 @@
+"""Time command."""
+
+from .time import TimeCommand
+
+__all__ = ["TimeCommand"]

just_bash/commands/time/time.py

@@ -0,0 +1,74 @@
+"""Time command implementation.
+
+Usage: time [-p] [COMMAND [ARGS]...]
+
+Run COMMAND and print timing statistics.
+
+Options:
+  -p    Use POSIX output format
+"""
+
+import time as time_module
+from ...types import CommandContext, ExecResult
+
+
+class TimeCommand:
+    """The time command."""
+
+    name = "time"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the time command."""
+        posix_format = False
+        command_args: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-p" and not command_args:
+                posix_format = True
+            elif arg == "--":
+                command_args.extend(args[i + 1:])
+                break
+            else:
+                command_args.extend(args[i:])
+                break
+            i += 1
+
+        # If no command, just show timing for empty command
+        if not command_args:
+            if posix_format:
+                timing = "real 0.00\nuser 0.00\nsys 0.00\n"
+            else:
+                timing = "\nreal\t0m0.000s\nuser\t0m0.000s\nsys\t0m0.000s\n"
+            return ExecResult(stdout="", stderr=timing, exit_code=0)
+
+        # Execute the command and measure time
+        if ctx.exec is None:
+            return ExecResult(
+                stdout="",
+                stderr="time: cannot execute subcommand\n",
+                exit_code=1,
+            )
+
+        # Build command string
+        command_str = " ".join(command_args)
+
+        start_time = time_module.time()
+        result = await ctx.exec(command_str, {"cwd": ctx.cwd})
+        elapsed = time_module.time() - start_time
+
+        # Format timing output
+        if posix_format:
+            timing = f"real {elapsed:.2f}\nuser 0.00\nsys 0.00\n"
+        else:
+            minutes = int(elapsed // 60)
+            seconds = elapsed % 60
+            timing = f"\nreal\t{minutes}m{seconds:.3f}s\nuser\t0m0.000s\nsys\t0m0.000s\n"
+
+        return ExecResult(
+            stdout=result.stdout,
+            stderr=result.stderr + timing,
+            exit_code=result.exit_code,
+        )