just-bash 0.1.8__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/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,
+        )

just_bash/commands/touch/touch.py

@@ -7,11 +7,56 @@ A FILE argument that does not exist is created empty.
 
 Options:
   -c, --no-create  do not create any files
+  -d, --date=DATE  parse DATE and use it instead of current time
 """
 
+import time
+import re
 from ...types import CommandContext, ExecResult
 
 
+def parse_date(date_str: str) -> float | None:
+    """Parse a date string and return timestamp.
+
+    Supports:
+    - YYYY-MM-DD
+    - YYYY/MM/DD
+    - YYYY-MM-DD HH:MM:SS
+    - ISO 8601 variations
+    """
+    date_str = date_str.strip().strip("'\"")
+
+    # Try various date formats
+    patterns = [
+        # YYYY-MM-DD HH:MM:SS
+        (r"^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$",
+         lambda m: (int(m[1]), int(m[2]), int(m[3]), int(m[4]), int(m[5]), int(m[6]))),
+        # YYYY-MM-DD
+        (r"^(\d{4})-(\d{2})-(\d{2})$",
+         lambda m: (int(m[1]), int(m[2]), int(m[3]), 0, 0, 0)),
+        # YYYY/MM/DD
+        (r"^(\d{4})/(\d{2})/(\d{2})$",
+         lambda m: (int(m[1]), int(m[2]), int(m[3]), 0, 0, 0)),
+        # YYYY/MM/DD HH:MM:SS
+        (r"^(\d{4})/(\d{2})/(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$",
+         lambda m: (int(m[1]), int(m[2]), int(m[3]), int(m[4]), int(m[5]), int(m[6]))),
+    ]
+
+    for pattern, extractor in patterns:
+        match = re.match(pattern, date_str)
+        if match:
+            year, month, day, hour, minute, second = extractor(match)
+            try:
+                import calendar
+                # Create a struct_time and convert to timestamp
+                t = (year, month, day, hour, minute, second, 0, 0, -1)
+                return calendar.timegm(t)
+            except (ValueError, OverflowError):
+                return None
+
+    return None
+
+
 class TouchCommand:
     """The touch command."""
 
@@ -20,6 +65,7 @@ class TouchCommand:
     async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
         """Execute the touch command."""
         no_create = False
+        date_time: float | None = None
         files: list[str] = []
 
         # Parse arguments
@@ -32,6 +78,32 @@ class TouchCommand:
             elif arg.startswith("--"):
                 if arg == "--no-create":
                     no_create = True
+                elif arg.startswith("--date="):
+                    date_str = arg[7:]
+                    date_time = parse_date(date_str)
+                    if date_time is None:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"touch: invalid date '{date_str}'\n",
+                            exit_code=1,
+                        )
+                elif arg == "--date":
+                    # Next arg is the date
+                    if i + 1 >= len(args):
+                        return ExecResult(
+                            stdout="",
+                            stderr="touch: option '--date' requires an argument\n",
+                            exit_code=1,
+                        )
+                    i += 1
+                    date_str = args[i]
+                    date_time = parse_date(date_str)
+                    if date_time is None:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"touch: invalid date '{date_str}'\n",
+                            exit_code=1,
+                        )
                 else:
                     return ExecResult(
                         stdout="",
@@ -39,15 +111,49 @@ class TouchCommand:
                         exit_code=1,
                     )
             elif arg.startswith("-") and arg != "-":
-                for c in arg[1:]:
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
                     if c == "c":
                         no_create = True
+                    elif c == "d":
+                        # -d DATE: next part or next arg is the date
+                        if j + 1 < len(arg):
+                            # Date is rest of this arg
+                            date_str = arg[j + 1:]
+                            date_time = parse_date(date_str)
+                            if date_time is None:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"touch: invalid date '{date_str}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        elif i + 1 < len(args):
+                            # Date is next arg
+                            i += 1
+                            date_str = args[i]
+                            date_time = parse_date(date_str)
+                            if date_time is None:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"touch: invalid date '{date_str}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="touch: option requires an argument -- 'd'\n",
+                                exit_code=1,
+                            )
                     else:
                         return ExecResult(
                             stdout="",
                             stderr=f"touch: invalid option -- '{c}'\n",
                             exit_code=1,
                         )
+                    j += 1
             else:
                 files.append(arg)
             i += 1
@@ -62,6 +168,10 @@ class TouchCommand:
         stderr = ""
         exit_code = 0
 
+        # Use current time if no date specified
+        if date_time is None:
+            date_time = time.time()
+
         for f in files:
             try:
                 path = ctx.fs.resolve_path(ctx.cwd, f)
@@ -69,23 +179,23 @@ class TouchCommand:
                 try:
                     stat = await ctx.fs.stat(path)
                     if stat.is_directory:
-                        # Touching a directory - we can't easily update dir mtime
-                        # in current implementation, so just continue
+                        # Update directory timestamp if possible
+                        await ctx.fs.utimes(path, date_time, date_time)
                         continue
-                    # File exists - read and re-write to update timestamp
-                    content = await ctx.fs.read_file(path)
-                    await ctx.fs.write_file(path, content)
+                    # File exists - use utimes to update timestamp
+                    await ctx.fs.utimes(path, date_time, date_time)
                 except FileNotFoundError:
                     # File doesn't exist
                     if no_create:
                         continue
-                    # Create empty file
+                    # Create empty file and set its time
                     await ctx.fs.write_file(path, "")
+                    await ctx.fs.utimes(path, date_time, date_time)
             except FileNotFoundError:
                 stderr += f"touch: cannot touch '{f}': No such file or directory\n"
                 exit_code = 1
             except IsADirectoryError:
-                # Touching a directory is fine, just update timestamp (no-op)
+                # Touching a directory is fine
                 pass
 
         return ExecResult(stdout="", stderr=stderr, exit_code=exit_code)

just_bash/commands/whoami/__init__.py

@@ -0,0 +1,5 @@
+"""Whoami command."""
+
+from .whoami import WhoamiCommand
+
+__all__ = ["WhoamiCommand"]

just_bash/commands/whoami/whoami.py

@@ -0,0 +1,18 @@
+"""Whoami command implementation.
+
+Usage: whoami
+
+Print the effective username.
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class WhoamiCommand:
+    """The whoami command."""
+
+    name = "whoami"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the whoami command."""
+        return ExecResult(stdout="user\n", stderr="", exit_code=0)

just_bash/fs/in_memory_fs.py

@@ -609,6 +609,28 @@ class InMemoryFs:
 
         return entry.target
 
+    async def utimes(self, path: str, atime: float, mtime: float) -> None:
+        """Set access and modification times for a file."""
+        resolved = self._resolve_path_with_symlinks(path)
+        entry = self._data.get(resolved)
+        if entry is None:
+            raise FileNotFoundError(f"No such file or directory: {path}")
+        # Update mtime (we only track mtime, atime is ignored)
+        if entry.type == "file":
+            self._data[resolved] = FileEntry(
+                content=entry.content, mode=entry.mode, mtime=mtime
+            )
+        elif entry.type == "directory":
+            self._data[resolved] = DirectoryEntry(mode=entry.mode, mtime=mtime)
+        elif entry.type == "symlink":
+            self._data[resolved] = SymlinkEntry(
+                target=entry.target, mode=entry.mode, mtime=mtime
+            )
+
+    async def realpath(self, path: str) -> str:
+        """Resolve path to absolute canonical path (resolve all symlinks)."""
+        return self._resolve_path_with_symlinks(path)
+
     def resolve_path(self, base: str, path: str) -> str:
         """Resolve a path relative to a base."""
         if path.startswith("/"):