termish 0.2.2__tar.gz → 0.2.3__tar.gz

{termish-0.2.2/termish.egg-info → termish-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termish
-Version: 0.2.2
+Version: 0.2.3
 Summary: Virtual terminal with shell-like commands over a pluggable filesystem.
 Author: ashenfad
 License-Expression: MIT

{termish-0.2.2 → termish-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "termish"
-version = "0.2.2"
+version = "0.2.3"
 description = "Virtual terminal with shell-like commands over a pluggable filesystem."
 readme = "README.md"
 license = "MIT"

{termish-0.2.2 → termish-0.2.3}/termish/fs/conformance.py

@@ -72,7 +72,8 @@ def check_filesystem(fs: Any) -> None:
         fs: An empty filesystem instance to exercise. All sixteen protocol
             methods are called, including the ranged form of `read`, append
             mode on `write`, and the `FileInfo.path` convention on
-            `list_detailed`.
+            `list_detailed`. The optional `read_many` is checked when the
+            filesystem has it.
 
     Raises:
         AssertionError: On the first deviation, with a message naming the
@@ -95,6 +96,8 @@ def check_filesystem(fs: Any) -> None:
         _check_ranged_read(fs, base)
         _check_stat(fs, base)
         _check_listing(fs, base)
+        if callable(getattr(fs, "read_many", None)):
+            _check_read_many(fs, base)
         _check_glob(fs, base)
         _check_rename_and_remove(fs, base)
         _check_chdir(fs, root, base)
@@ -291,6 +294,38 @@ def _check_listing(fs: Any, base: str) -> None:
     _expect("list_detailed", "size of a 2-byte file", nested.size, 2)
 
 
+def _check_read_many(fs: Any, base: str) -> None:
+    batch = posixpath.join(base, "batch")
+    fs.makedirs(posixpath.join(batch, "sub"))
+    one = posixpath.join(batch, "one.txt")
+    two = posixpath.join(batch, "sub/two.txt")
+    fs.write(one, b"1")
+    fs.write(two, b"22")
+
+    _expect(
+        "read_many",
+        "files map to their bytes; a directory and a missing path are left out",
+        fs.read_many(
+            [one, posixpath.join(batch, "sub"), two, posixpath.join(batch, "nope")]
+        ),
+        {one: b"1", two: b"22"},
+    )
+
+    # Keys are the paths as given, not a canonical spelling of them: a
+    # caller looks its own paths up in the answer, so a relative path that
+    # came back absolute (or the reverse) would read as a missing file.
+    rel = posixpath.relpath(batch, fs.getcwd())
+    rel_one = posixpath.join(rel, "one.txt")
+    dot_two = "./" + posixpath.join(rel, "sub/two.txt")
+    _expect(
+        "read_many",
+        "relative paths are keyed exactly as given",
+        fs.read_many([rel_one, dot_two, one]),
+        {rel_one: b"1", dot_two: b"22", one: b"1"},
+    )
+    _expect("read_many", "no paths, no files", fs.read_many([]), {})
+
+
 def _check_glob(fs: Any, base: str) -> None:
     globbing = posixpath.join(base, "globbing")
     fs.makedirs(globbing)

{termish-0.2.2 → termish-0.2.3}/termish/fs/memory.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import errno as _errno
 import fnmatch
 import posixpath
+from collections.abc import Iterable
 from datetime import datetime, timezone
 
 from .protocol import FileInfo, FileMetadata
@@ -40,11 +41,27 @@ class MemoryFS:
             path = self._cwd.rstrip("/") + "/" + path
         return posixpath.normpath(path)
 
+    def _refuse_a_file_on_the_way(self, path: str) -> None:
+        """Raise NotADirectoryError (ENOTDIR) if a component of *path* is
+        a file: a path below one can't be created without leaving the file
+        a directory as well."""
+        current = ""
+        for part in path.strip("/").split("/"):
+            current += "/" + part
+            if current in self._files:
+                raise NotADirectoryError(_errno.ENOTDIR, "Not a directory", current)
+
     def _ensure_parent(self, path: str) -> None:
-        """Raise if the parent directory of *path* does not exist."""
+        """Raise unless the parent directory of *path* exists.
+
+        NotADirectoryError (ENOTDIR) when a file is in the way, and
+        FileNotFoundError (ENOENT) when a directory on the way is missing.
+        """
         parent = posixpath.dirname(path)
-        if parent != path and parent not in self._dirs:
-            raise FileNotFoundError(_errno.ENOENT, "No such directory", parent)
+        if parent == path or parent in self._dirs:
+            return
+        self._refuse_a_file_on_the_way(parent)
+        raise FileNotFoundError(_errno.ENOENT, "No such directory", parent)
 
     def _touch_ts(self, path: str) -> None:
         """Update modified_at; set created_at if new."""
@@ -88,10 +105,28 @@ class MemoryFS:
             return content[offset:]
         return content[offset : offset + size]
 
+    def read_many(self, paths: Iterable[str]) -> dict[str, bytes]:
+        """Read several whole files: each path, as given, to its bytes.
+
+        A path that is not a file -- missing, or a directory -- is left out.
+        """
+        found: dict[str, bytes] = {}
+        for path in paths:
+            resolved = self._resolve(path)
+            if resolved in self._files:
+                found[path] = self._files[resolved]
+        return found
+
     def write(self, path: str, content: bytes, mode: str = "w") -> None:
+        """Write *content* to the file at *path*, creating any missing
+        directories on the way; a file on the way raises
+        NotADirectoryError, and a directory at *path* IsADirectoryError."""
         path = self._resolve(path)
+        if path in self._dirs:
+            raise IsADirectoryError(_errno.EISDIR, "Is a directory", path)
         parent = posixpath.dirname(path)
         if parent != path and parent not in self._dirs:
+            self._refuse_a_file_on_the_way(parent)
             self.makedirs(parent, exist_ok=True)
         if mode == "a" and path in self._files:
             self._files[path] = self._files[path] + content
@@ -152,6 +187,9 @@ class MemoryFS:
         path = self._resolve(path)
         if not exist_ok and path in self._dirs:
             raise FileExistsError(f"Directory exists: '{path}'")
+        if path in self._files:
+            raise FileExistsError(f"Path exists as file: '{path}'")
+        self._refuse_a_file_on_the_way(path)
         parts = path.strip("/").split("/")
         current = ""
         for part in parts:
@@ -187,9 +225,16 @@ class MemoryFS:
         self._timestamps.pop(path, None)
 
     def rename(self, src: str, dst: str) -> None:
+        """Move *src* to *dst*, as rename(2) does: a file never replaces a
+        directory nor a directory a file, a directory replaces only an
+        empty one, and never moves into itself."""
         src = self._resolve(src)
         dst = self._resolve(dst)
+        if src == dst and self.exists(src):
+            return
         if src in self._files:
+            if dst in self._dirs:
+                raise IsADirectoryError(_errno.EISDIR, "Is a directory", dst)
             self._ensure_parent(dst)
             self._files[dst] = self._files.pop(src)
             ts = self._timestamps.pop(src, None)
@@ -197,6 +242,13 @@ class MemoryFS:
                 self._timestamps[dst] = ts
         elif src in self._dirs:
             src_prefix = src.rstrip("/") + "/"
+            if dst in self._files:
+                raise NotADirectoryError(_errno.ENOTDIR, "Not a directory", dst)
+            if dst.startswith(src_prefix):
+                raise OSError(_errno.EINVAL, "Cannot move a directory into itself", dst)
+            if dst in self._dirs and self.list(dst):
+                raise OSError(_errno.ENOTEMPTY, "Directory not empty", dst)
+            self._ensure_parent(dst)
             self._dirs.discard(src)
             self._dirs.add(dst)
             # Move timestamp

{termish-0.2.2 → termish-0.2.3}/termish/fs/protocol.py

@@ -54,6 +54,17 @@ class FileSystem(Protocol):
 
     Any object implementing these methods can be passed to termish's
     interpreter. No inheritance required — uses structural (duck) typing.
+
+    One method is optional, and is not part of the protocol, so a
+    filesystem without it still passes ``isinstance``:
+
+    ``read_many(paths: Iterable[str]) -> dict[str, bytes]``
+        Read several whole files at once: each path, as given, to its
+        bytes. A path that is not a file -- missing, or a directory -- is
+        left out rather than raised on. ``grep`` reads the files it
+        searches through it when it is there, so a filesystem that fetches
+        remotely answers a batch in one round trip rather than one per
+        file. `termish.fs.check_filesystem` checks it when it is there.
     """
 
     def getcwd(self) -> str:

termish-0.2.3/termish/interpreter/commands/_dispatch.py

@@ -0,0 +1,65 @@
+"""Running a command from an argv, as ``xargs`` and ``find -exec`` do."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+from termish.context import CommandContext, PipeStream
+from termish.errors import TerminalError
+from termish.fs import FileSystem
+
+
+class Dispatched(NamedTuple):
+    """What a command that succeeded produced."""
+
+    #: Its stdout, byte for byte.
+    output: bytes
+    #: What it said on stderr while succeeding (a warning), or "".
+    stderr: str
+
+
+def dispatch_argv(argv: list[str], fs: FileSystem, env: dict[str, str]) -> Dispatched:
+    """Run ``argv`` (``[name, *args]``) with empty stdin.
+
+    The argv is dispatched as it is, never re-parsed by the shell, through
+    the same table the interpreter uses, injected commands included.
+    Raises ``TerminalError`` when the command is missing (127), fails, or
+    raises.
+    """
+    # Deferred: core imports the command modules that import this one.
+    from termish.interpreter.core import _resolve_command
+
+    name, *args = argv
+    func = _resolve_command(name)
+    if func is None:
+        raise TerminalError(f"{name}: command not found", exit_code=127)
+
+    stdout = PipeStream()
+    try:
+        result = func(
+            CommandContext(args=args, stdin=PipeStream(), stdout=stdout, fs=fs, env=env)
+        )
+    except TerminalError:
+        raise
+    except Exception as e:
+        raise TerminalError(f"{name}: execution error: {e}")
+    if result is not None and result.exit_code != 0:
+        raise TerminalError(
+            f"{name}: {result.stderr}"
+            if result.stderr
+            else f"{name}: exited with code {result.exit_code}",
+            exit_code=result.exit_code,
+            stderr=result.stderr,
+        )
+    return Dispatched(stdout.getvalue(), result.stderr if result is not None else "")
+
+
+def stderr_of(e: TerminalError) -> str:
+    """What a failure shows on stderr ("" if it failed silently)."""
+    return e.message if e.stderr is None else e.stderr
+
+
+def join_stderr(parts: list[str]) -> str:
+    """Several commands' stderr as one, each as written: a newline is
+    added only where one is missing, so blank lines survive."""
+    return "".join(p if p.endswith("\n") else p + "\n" for p in parts if p)

{termish-0.2.2 → termish-0.2.3}/termish/interpreter/commands/_regex.py

@@ -30,7 +30,9 @@ def bre_to_python(pattern: str) -> str:
     - ``^`` anchors only at those same starting points and ``$`` only at
       the end of the pattern, of a group or of an alternative; anywhere
       else each is a literal character.
-    - ``\<`` and ``\>`` (GNU word boundaries) become ``\b``.
+    - ``\<`` and ``\>`` (GNU's start and end of a word) become
+      ``\b(?=\w)`` and ``\b(?<=\w)``: a bare ``\b`` would match either
+      edge.
     - Every other escape — ``\1``-``\9``, ``\.``, ``\*``, ``\w`` — is
       kept as it is, since it means the same to ``re``.
 
@@ -59,8 +61,11 @@ def bre_to_python(pattern: str) -> str:
             if nxt in _SWAPPED:
                 out.append(nxt)
                 at_start = nxt in "(|"
-            elif nxt in "<>":
-                out.append(r"\b")
+            elif nxt == "<":
+                out.append(r"\b(?=\w)")  # the start of a word
+                at_start = False
+            elif nxt == ">":
+                out.append(r"\b(?<=\w)")  # the end of a word
                 at_start = False
             else:
                 out.append("\\" + nxt)

{termish-0.2.2 → termish-0.2.3}/termish/interpreter/commands/filesystem.py

@@ -346,6 +346,9 @@ def mv(ctx: CommandContext) -> CommandResult | None:
         raise TerminalError("mv: too many arguments")
 
     src, dst = parsed.paths
+    if fs.isdir(dst):
+        # an existing directory receives src under its own name
+        dst = posixpath.join(dst, posixpath.basename(src.rstrip("/")))
     if parsed.no_clobber and fs.exists(dst):
         return  # silently skip
 

{termish-0.2.2 → termish-0.2.3}/termish/interpreter/commands/meta.py

@@ -5,9 +5,11 @@ Meta commands that invoke other commands.
 import contextvars
 from typing import TYPE_CHECKING
 
-from termish.context import CommandContext, CommandResult, PipeStream
+from termish.context import CommandContext, CommandResult
 from termish.errors import TerminalError
 
+from ._dispatch import dispatch_argv, join_stderr, stderr_of
+
 _MAX_XARGS_DEPTH = 16
 _xargs_depth: contextvars.ContextVar[int] = contextvars.ContextVar(
     "xargs_depth", default=0
@@ -102,52 +104,51 @@ def xargs(ctx: CommandContext) -> CommandResult | None:
     if not items:
         return
 
+    # What the commands say on stderr while succeeding becomes xargs's own
+    # stderr: shown, as it is when the command runs directly, and never
+    # fed down the pipe with the output.
+    warnings: list[str] = []
+
     def execute_cmd(cmd_args: list[str]) -> None:
         """Execute command with given args and write output to stdout."""
         if verbose:
             stdout.write(f"{cmd_name} {' '.join(cmd_args)}\n")
 
-        cmd_stdin = PipeStream()
-        cmd_stdout = PipeStream()
         token = _xargs_depth.set(depth + 1)
         try:
-            sub_ctx = CommandContext(
-                args=cmd_args,
-                stdin=cmd_stdin,
-                stdout=cmd_stdout,
-                fs=fs,
-                env=ctx.env,
-            )
-            result = cmd_func(sub_ctx)
-            if result and result.exit_code != 0:
-                raise TerminalError(
-                    f"{cmd_name}: {result.stderr}"
-                    if result.stderr
-                    else f"{cmd_name}: exited with code {result.exit_code}",
-                    exit_code=result.exit_code,
-                    stderr=result.stderr,
-                )
-        except TerminalError:
-            raise
-        except Exception as e:
-            raise TerminalError(f"{cmd_name}: execution error: {e}")
+            output, warning = dispatch_argv([cmd_name, *cmd_args], fs, ctx.env)
         finally:
             _xargs_depth.reset(token)
+        if warning:
+            warnings.append(warning)
         # The sub-command's output is moved, not read: pass its bytes
         # through so a binary-producing command survives xargs.
         stdout.flush()
-        stdout.buffer.write(cmd_stdout.getvalue())
-
-    if replace:
-        # -I mode: run command once per item, substituting placeholder
-        for item in items:
-            cmd_args = [arg.replace(replace, item) for arg in cmd_base_args]
-            execute_cmd(cmd_args)
-    elif max_args:
-        # -n mode: batch items
-        for i in range(0, len(items), max_args):
-            batch = items[i : i + max_args]
-            execute_cmd(cmd_base_args + batch)
-    else:
-        # Default: all items as arguments to single command
-        execute_cmd(cmd_base_args + items)
+        stdout.buffer.write(output)
+
+    try:
+        if replace:
+            # -I mode: run command once per item, substituting placeholder
+            for item in items:
+                cmd_args = [arg.replace(replace, item) for arg in cmd_base_args]
+                execute_cmd(cmd_args)
+        elif max_args:
+            # -n mode: batch items
+            for i in range(0, len(items), max_args):
+                batch = items[i : i + max_args]
+                execute_cmd(cmd_base_args + batch)
+        else:
+            # Default: all items as arguments to single command
+            execute_cmd(cmd_base_args + items)
+    except TerminalError as e:
+        if not warnings:
+            raise
+        # the warnings of the runs before it are shown too
+        raise TerminalError(
+            e.message,
+            exit_code=e.exit_code,
+            stderr=join_stderr([*warnings, stderr_of(e)]),
+        )
+    if warnings:
+        return CommandResult(stderr=join_stderr(warnings))
+    return None