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

just_bash/commands/read/read.py

@@ -1,13 +1,14 @@
 """Read command implementation.
 
-Usage: read [-r] [-d delim] [-n nchars] [-p prompt] [-t timeout] [name ...]
+Usage: read [-r] [-d delim] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [name ...]
 
 Read a line from stdin and split it into fields.
 
 Options:
   -r        Do not treat backslash as escape character
   -d delim  Use delim as line delimiter instead of newline
-  -n nchars Read only nchars characters
+  -n nchars Read at most nchars characters
+  -N nchars Read exactly nchars characters (no IFS splitting, ignores delimiters)
   -p prompt Output the string prompt before reading
   -t timeout Time out after timeout seconds
 
@@ -28,7 +29,9 @@ class ReadCommand:
         raw_mode = False
         delimiter = "\n"
         nchars = None
+        no_split = False  # -N mode: no IFS splitting
         array_name = None  # -a option
+        fd_num = None  # -u option
         var_names = []
 
         i = 0
@@ -41,7 +44,9 @@ class ReadCommand:
                 array_name = args[i]
             elif arg == "-d" and i + 1 < len(args):
                 i += 1
-                delimiter = args[i]
+                delimiter = args[i] if args[i] else "\0"
+            elif arg.startswith("-d") and len(arg) > 2:
+                delimiter = arg[2:]
             elif arg == "-n" and i + 1 < len(args):
                 i += 1
                 try:
@@ -52,33 +57,99 @@ class ReadCommand:
                         stderr=f"bash: read: {args[i]}: invalid number\n",
                         exit_code=1,
                     )
+            elif arg.startswith("-n") and len(arg) > 2:
+                try:
+                    nchars = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: read: {arg[2:]}: invalid number\n",
+                        exit_code=1,
+                    )
+            elif arg == "-N" and i + 1 < len(args):
+                i += 1
+                try:
+                    nchars = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: read: {args[i]}: invalid number\n",
+                        exit_code=1,
+                    )
+                no_split = True
+                delimiter = ""  # -N ignores delimiters
+            elif arg.startswith("-N") and len(arg) > 2:
+                try:
+                    nchars = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: read: {arg[2:]}: invalid number\n",
+                        exit_code=1,
+                    )
+                no_split = True
+                delimiter = ""  # -N ignores delimiters
+            elif arg == "-u" and i + 1 < len(args):
+                i += 1
+                try:
+                    fd_num = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: read: {args[i]}: invalid file descriptor\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-u") and len(arg) > 2:
+                try:
+                    fd_num = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: read: {arg[2:]}: invalid file descriptor\n",
+                        exit_code=1,
+                    )
             elif arg == "-p" and i + 1 < len(args):
-                # Prompt option - we ignore it since we can't prompt
                 i += 1
             elif arg == "-t" and i + 1 < len(args):
-                # Timeout option - we ignore it
                 i += 1
             elif arg.startswith("-"):
-                # Unknown option - ignore for compatibility
                 pass
             else:
                 var_names.append(arg)
             i += 1
 
-        # Default variable is REPLY
+        # Track whether we're using default REPLY
+        use_reply = not var_names and not array_name
         if not var_names:
             var_names = ["REPLY"]
 
-        # Get input from stdin
-        stdin = ctx.stdin or ""
+        # Get input from stdin or custom FD
+        if fd_num is not None and fd_num >= 3:
+            fd_contents = getattr(ctx, 'fd_contents', {})
+            stdin = fd_contents.get(fd_num, "")
+        else:
+            stdin = ctx.stdin or ""
+
+        # Determine if input was properly terminated by delimiter
+        # (affects exit code: 1 if no terminating delimiter found)
+        eof_reached = False
+        if not stdin:
+            eof_reached = True
+        elif no_split:
+            # -N mode: EOF if fewer chars available than requested
+            if nchars is not None and len(stdin) < nchars:
+                eof_reached = True
+        elif delimiter not in stdin:
+            eof_reached = True
 
         # Find the line to read
-        if delimiter == "\n":
-            # Standard line reading
+        if delimiter == "":
+            # -N mode: read raw bytes, no delimiter processing
+            line = stdin
+        elif delimiter == "\n":
             lines = stdin.split("\n")
             line = lines[0] if lines else ""
         else:
-            # Custom delimiter
             parts = stdin.split(delimiter)
             line = parts[0] if parts else ""
 
@@ -86,99 +157,207 @@ class ReadCommand:
         if nchars is not None:
             line = line[:nchars]
 
-        # Process backslash escapes if not in raw mode
-        if not raw_mode:
-            # Handle backslash-newline continuation (remove them)
+        # Process backslash escapes if not in raw mode and not -N mode
+        if not raw_mode and not no_split:
             line = line.replace("\\\n", "")
-            # Handle other escapes
             result = []
-            i = 0
-            while i < len(line):
-                if line[i] == "\\" and i + 1 < len(line):
-                    # Escape the next character
-                    result.append(line[i + 1])
-                    i += 2
+            ci = 0
+            while ci < len(line):
+                if line[ci] == "\\" and ci + 1 < len(line):
+                    result.append(line[ci + 1])
+                    ci += 2
                 else:
-                    result.append(line[i])
-                    i += 1
+                    result.append(line[ci])
+                    ci += 1
             line = "".join(result)
 
-        # Split on IFS
+        # Get IFS
         ifs = ctx.env.get("IFS", " \t\n")
-        if ifs:
-            # Split on IFS characters
-            words = self._split_on_ifs(line, ifs)
-        else:
-            # Empty IFS - no splitting
-            words = [line] if line else []
 
         # Handle -a option (read into array)
         if array_name:
+            # Split on IFS for array assignment
+            if no_split:
+                words = [line] if line else []
+            elif ifs:
+                words = self._split_on_ifs(line, ifs)
+            else:
+                words = [line] if line else []
+
             # Clear existing array elements
             prefix = f"{array_name}_"
             to_remove = [k for k in ctx.env if k.startswith(prefix) and not k.startswith(f"{array_name}__")]
             for k in to_remove:
                 del ctx.env[k]
 
-            # Mark as array
             ctx.env[f"{array_name}__is_array"] = "indexed"
 
-            # Store each word as array element
             for idx, word in enumerate(words):
                 ctx.env[f"{array_name}_{idx}"] = word
 
-            exit_code = 0 if stdin else 1
-            return ExecResult(stdout="", stderr="", exit_code=exit_code)
+            return ExecResult(stdout="", stderr="", exit_code=1 if eof_reached else 0)
 
         # Assign to variables
-        for i, var in enumerate(var_names):
-            if i < len(words):
-                if i == len(var_names) - 1:
-                    # Last variable gets all remaining words
-                    ctx.env[var] = " ".join(words[i:])
-                else:
-                    ctx.env[var] = words[i]
+        if no_split:
+            # -N mode: no IFS splitting at all
+            if len(var_names) == 1:
+                ctx.env[var_names[0]] = line
             else:
-                ctx.env[var] = ""
+                # Even with multiple vars, -N doesn't split
+                ctx.env[var_names[0]] = line
+                for v in var_names[1:]:
+                    ctx.env[v] = ""
+        elif use_reply or len(var_names) == 1:
+            # Single variable or REPLY: no IFS splitting
+            # But strip leading/trailing IFS whitespace
+            stripped = self._strip_ifs_whitespace(line, ifs)
+            ctx.env[var_names[0]] = stripped
+        elif not ifs:
+            # Empty IFS: no splitting
+            ctx.env[var_names[0]] = line
+            for v in var_names[1:]:
+                ctx.env[v] = ""
+        else:
+            # Multiple variables: split on IFS
+            self._assign_split_vars(line, var_names, ifs, ctx)
+
+        return ExecResult(stdout="", stderr="", exit_code=1 if eof_reached else 0)
+
+    def _strip_ifs_whitespace(self, value: str, ifs: str) -> str:
+        """Strip leading and trailing IFS whitespace characters."""
+        if not ifs:
+            return value
+        ifs_ws = set(c for c in ifs if c in " \t\n")
+        if not ifs_ws:
+            return value
+        # Strip leading
+        start = 0
+        while start < len(value) and value[start] in ifs_ws:
+            start += 1
+        # Strip trailing
+        end = len(value)
+        while end > start and value[end - 1] in ifs_ws:
+            end -= 1
+        return value[start:end]
+
+    def _assign_split_vars(self, line: str, var_names: list[str], ifs: str, ctx: CommandContext) -> None:
+        """Split line on IFS and assign to multiple variables.
+
+        The last variable gets the remainder of the line (preserving
+        original separators from the input).
+        """
+        ifs_ws = set(c for c in ifs if c in " \t\n")
+        ifs_nonws = set(c for c in ifs if c not in " \t\n")
+
+        # We need to track positions in the original line so the last
+        # variable gets the remainder from the original string
+        num_vars = len(var_names)
+        words = []
+        pos = 0
+
+        # Skip leading IFS whitespace
+        while pos < len(line) and line[pos] in ifs_ws:
+            pos += 1
 
-        # Return success if we read something, failure if EOF
-        exit_code = 0 if stdin else 1
-        return ExecResult(stdout="", stderr="", exit_code=exit_code)
+        for var_idx in range(num_vars):
+            if pos >= len(line):
+                # No more input - set remaining vars to empty
+                for vi in range(var_idx, num_vars):
+                    ctx.env[var_names[vi]] = ""
+                return
+
+            if var_idx == num_vars - 1:
+                # Last variable: gets the rest of the line, with trailing
+                # IFS whitespace stripped
+                remainder = line[pos:]
+                # Strip trailing IFS whitespace
+                end = len(remainder)
+                while end > 0 and remainder[end - 1] in ifs_ws:
+                    end -= 1
+                ctx.env[var_names[var_idx]] = remainder[:end]
+                return
+
+            # Collect next word
+            word_start = pos
+            while pos < len(line) and line[pos] not in ifs_ws and line[pos] not in ifs_nonws:
+                pos += 1
+
+            word = line[word_start:pos]
+            ctx.env[var_names[var_idx]] = word
+
+            # Skip IFS delimiters between words
+            # Whitespace IFS chars: skip all consecutive
+            # Non-whitespace IFS chars: each one is a delimiter
+            # Whitespace around non-whitespace is part of the delimiter
+            if pos < len(line):
+                # Skip leading whitespace
+                while pos < len(line) and line[pos] in ifs_ws:
+                    pos += 1
+                # If we hit a non-whitespace delimiter, consume it
+                if pos < len(line) and line[pos] in ifs_nonws:
+                    pos += 1
+                    # Skip trailing whitespace after non-ws delimiter
+                    while pos < len(line) and line[pos] in ifs_ws:
+                        pos += 1
+
+        # Shouldn't reach here, but just in case
+        for vi in range(len(words), num_vars):
+            if var_names[vi] not in ctx.env:
+                ctx.env[var_names[vi]] = ""
 
     def _split_on_ifs(self, value: str, ifs: str) -> list[str]:
-        """Split a string on IFS characters."""
+        """Split a string on IFS characters.
+
+        Follows bash IFS splitting rules:
+        - IFS whitespace (space, tab, newline): leading/trailing stripped,
+          consecutive act as single separator
+        - IFS non-whitespace: each occurrence is a separator, consecutive
+          produce empty fields
+        - Mixed: whitespace adjacent to non-whitespace is part of the delimiter
+        """
         if not value:
             return []
 
-        # Identify IFS whitespace vs non-whitespace
-        ifs_whitespace = "".join(c for c in ifs if c in " \t\n")
+        ifs_ws = set(c for c in ifs if c in " \t\n")
+        ifs_nonws = set(c for c in ifs if c not in " \t\n")
 
-        # Simple split for whitespace-only IFS
-        if ifs == ifs_whitespace:
+        # Whitespace-only IFS: simple split (strips leading/trailing, merges consecutive)
+        if not ifs_nonws:
             return value.split()
 
-        # Complex case with non-whitespace delimiters
         result = []
         current = []
-        i = 0
-        while i < len(value):
-            c = value[i]
-            if c in ifs_whitespace:
+        pos = 0
+
+        # Skip leading IFS whitespace
+        while pos < len(value) and value[pos] in ifs_ws:
+            pos += 1
+
+        while pos < len(value):
+            c = value[pos]
+            if c in ifs_nonws:
+                # Non-whitespace delimiter: always produces field boundary
+                result.append("".join(current))
+                current = []
+                pos += 1
+                # Skip trailing IFS whitespace after non-ws delimiter
+                while pos < len(value) and value[pos] in ifs_ws:
+                    pos += 1
+            elif c in ifs_ws:
+                # IFS whitespace
                 if current:
                     result.append("".join(current))
                     current = []
                 # Skip consecutive whitespace
-                while i < len(value) and value[i] in ifs_whitespace:
-                    i += 1
-            elif c in ifs:
-                # Non-whitespace delimiter
-                result.append("".join(current))
-                current = []
-                i += 1
+                while pos < len(value) and value[pos] in ifs_ws:
+                    pos += 1
+                # If next char is non-ws delimiter, it's part of this delimiter run
+                # (don't start a new field yet - the non-ws handler will do it)
             else:
                 current.append(c)
-                i += 1
+                pos += 1
 
+        # Add last field if non-empty
         if current:
             result.append("".join(current))
 

just_bash/commands/readlink/readlink.py

@@ -55,15 +55,9 @@ class ReadlinkCommand:
                 stat = await ctx.fs.lstat(resolved)
 
                 if canonicalize:
-                    # Return the canonical path
-                    if stat.is_symbolic_link:
-                        target = await ctx.fs.readlink(resolved)
-                        if not target.startswith("/"):
-                            import os
-                            target = ctx.fs.resolve_path(os.path.dirname(resolved), target)
-                        stdout_parts.append(target)
-                    else:
-                        stdout_parts.append(resolved)
+                    # Return the canonical path (fully resolved)
+                    canonical = await ctx.fs.realpath(resolved)
+                    stdout_parts.append(canonical)
                 else:
                     # Only works on symlinks
                     if stat.is_symbolic_link:

just_bash/commands/registry.py

@@ -127,6 +127,9 @@ COMMAND_NAMES = [
     "tac",
     "hostname",
     "od",
+    "rmdir",
+    "time",
+    "whoami",
     # Testing utilities
     "argv.py",
     # Builtins
@@ -243,6 +246,9 @@ _command_loaders: list[LazyCommandDef] = [
     LazyCommandDef(name="comm", load=lambda: _load_comm()),
     LazyCommandDef(name="strings", load=lambda: _load_strings()),
     LazyCommandDef(name="od", load=lambda: _load_od()),
+    LazyCommandDef(name="rmdir", load=lambda: _load_rmdir()),
+    LazyCommandDef(name="time", load=lambda: _load_time()),
+    LazyCommandDef(name="whoami", load=lambda: _load_whoami()),
     # Testing utilities
     LazyCommandDef(name="argv.py", load=lambda: _load_argv()),
     # Builtins
@@ -697,6 +703,24 @@ async def _load_od() -> Command:
     return OdCommand()
 
 
+async def _load_rmdir() -> Command:
+    """Load the rmdir command."""
+    from .rmdir.rmdir import RmdirCommand
+    return RmdirCommand()
+
+
+async def _load_time() -> Command:
+    """Load the time command."""
+    from .time.time import TimeCommand
+    return TimeCommand()
+
+
+async def _load_whoami() -> Command:
+    """Load the whoami command."""
+    from .whoami.whoami import WhoamiCommand
+    return WhoamiCommand()
+
+
 async def _load_argv() -> Command:
     """Load the argv.py command."""
     from .argv.argv import ArgvCommand

just_bash/commands/rmdir/__init__.py

@@ -0,0 +1,5 @@
+"""Rmdir command."""
+
+from .rmdir import RmdirCommand
+
+__all__ = ["RmdirCommand"]

just_bash/commands/rmdir/rmdir.py

@@ -0,0 +1,160 @@
+"""Rmdir command implementation.
+
+Usage: rmdir [OPTION]... DIRECTORY...
+
+Remove empty directories.
+
+Options:
+  -p, --parents   remove DIRECTORY and its ancestors
+  -v, --verbose   output a diagnostic for every directory processed
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class RmdirCommand:
+    """The rmdir command."""
+
+    name = "rmdir"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the rmdir command."""
+        parents = False
+        verbose = False
+        directories: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                directories.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--parents":
+                    parents = True
+                elif arg == "--verbose":
+                    verbose = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"rmdir: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == "p":
+                        parents = True
+                    elif c == "v":
+                        verbose = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"rmdir: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                directories.append(arg)
+            i += 1
+
+        if not directories:
+            return ExecResult(
+                stdout="",
+                stderr="rmdir: missing operand\n",
+                exit_code=1,
+            )
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        for directory in directories:
+            result = await self._rmdir_one(
+                ctx, directory, parents, verbose
+            )
+            stdout += result.stdout
+            stderr += result.stderr
+            if result.exit_code != 0:
+                exit_code = result.exit_code
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+    async def _rmdir_one(
+        self,
+        ctx: CommandContext,
+        directory: str,
+        parents: bool,
+        verbose: bool,
+    ) -> ExecResult:
+        """Remove a single directory (and optionally its parents)."""
+        path = ctx.fs.resolve_path(ctx.cwd, directory)
+        stdout = ""
+        stderr = ""
+
+        # Get list of directories to remove
+        dirs_to_remove = [path]
+        if parents:
+            # Add parent directories up to root
+            current = path
+            while True:
+                parent = self._dirname(current)
+                if parent == current or parent == "/":
+                    break
+                dirs_to_remove.append(parent)
+                current = parent
+
+        # Try to remove directories
+        for dir_path in dirs_to_remove:
+            try:
+                # Check if path exists
+                try:
+                    stat = await ctx.fs.stat(dir_path)
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout=stdout,
+                        stderr=stderr + f"rmdir: failed to remove '{dir_path}': No such file or directory\n",
+                        exit_code=1,
+                    )
+
+                if not stat.is_directory:
+                    return ExecResult(
+                        stdout=stdout,
+                        stderr=stderr + f"rmdir: failed to remove '{dir_path}': Not a directory\n",
+                        exit_code=1,
+                    )
+
+                # Check if directory is empty
+                contents = await ctx.fs.readdir(dir_path)
+                if contents:
+                    return ExecResult(
+                        stdout=stdout,
+                        stderr=stderr + f"rmdir: failed to remove '{dir_path}': Directory not empty\n",
+                        exit_code=1,
+                    )
+
+                # Remove the directory
+                await ctx.fs.rm(dir_path)
+
+                if verbose:
+                    stdout += f"rmdir: removing directory, '{dir_path}'\n"
+
+            except OSError as e:
+                return ExecResult(
+                    stdout=stdout,
+                    stderr=stderr + f"rmdir: failed to remove '{dir_path}': {e}\n",
+                    exit_code=1,
+                )
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=0)
+
+    def _dirname(self, path: str) -> str:
+        """Get the directory name of a path."""
+        if path == "/":
+            return "/"
+        path = path.rstrip("/")
+        last_slash = path.rfind("/")
+        if last_slash == -1:
+            return "."
+        if last_slash == 0:
+            return "/"
+        return path[:last_slash]