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

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("/"):

just_bash/fs/overlay_fs.py

@@ -155,6 +155,9 @@ class OverlayFs:
 
     def _is_under_mount(self, path: str) -> bool:
         """Check if a normalized path is under the mount point."""
+        # Special case: root mount point means all paths are under it
+        if self._mount_point == "/":
+            return True
         return path == self._mount_point or path.startswith(self._mount_point + "/")
 
     def _to_real_path(self, virtual_path: str) -> Path | None:
@@ -172,7 +175,11 @@ class OverlayFs:
             return self._root
 
         # Strip mount point prefix
-        relative = normalized[len(self._mount_point) + 1:]  # +1 for the /
+        # Special case: when mount_point is "/", just strip the leading "/"
+        if self._mount_point == "/":
+            relative = normalized[1:]  # Just strip the leading /
+        else:
+            relative = normalized[len(self._mount_point) + 1:]  # +1 for the /
         return self._root / relative
 
     def _is_deleted(self, path: str) -> bool:
@@ -853,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