termish 0.2.1__tar.gz → 0.2.2__tar.gz

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

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

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

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

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

@@ -3,6 +3,7 @@ Filesystem commands for the terminal interpreter.
 """
 
 import posixpath
+from typing import Any
 
 from termish.context import CommandContext, CommandResult
 from termish.errors import TerminalError
@@ -91,108 +92,131 @@ def ls(ctx: CommandContext) -> CommandResult | None:
     if unknown:
         raise TerminalError(f"ls: unknown option: {unknown[0]}")
 
-    for i, path in enumerate(parsed.paths):
-        if len(parsed.paths) > 1:
-            stdout.write(f"{path}:\n")
-
-        try:
-            # -d: list directories themselves, not their contents
-            if parsed.directory and fs.isdir(path):
-                if parsed.l:
-                    meta = fs.stat(path)
-                    if parsed.human_readable:
-                        size = _human_readable_size(meta.size).rjust(6)
-                    else:
-                        size = str(meta.size).rjust(8)
-                    time = (
-                        meta.modified_at[:16].replace("T", " ")
-                        if meta.modified_at
-                        else " " * 16
-                    )
-                    stdout.write(f"drw-r--r-- 1 agent agent {size} {time} {path}\n")
-                else:
-                    stdout.write(f"{path}\n")
-                continue
-
-            # Check if it is a file first
-            if fs.isfile(path):
-                if parsed.l:
-                    # List detailed for file
-                    meta = fs.stat(path)
+    def long_line(path: str, type_char: str) -> str:
+        meta = fs.stat(path)
+        if parsed.human_readable:
+            size = _human_readable_size(meta.size).rjust(6)
+        else:
+            size = str(meta.size).rjust(8)
+        time = meta.modified_at[:16].replace("T", " ") if meta.modified_at else " " * 16
+        return f"{type_char}rw-r--r-- 1 agent agent {size} {time} {path}\n"
+
+    def list_dir(path: str) -> None:
+        needs_detailed = parsed.l or parsed.t or parsed.S or parsed.classify
+        if needs_detailed:
+            items = fs.list_detailed(path, recursive=parsed.R)
+            if not parsed.a:
+                items = [i for i in items if not i.name.startswith(".")]
+            if parsed.S:
+                items = sorted(items, key=lambda x: x.size, reverse=True)
+            elif parsed.t:
+                items = sorted(items, key=lambda x: x.modified_at or "", reverse=True)
+            if parsed.r:
+                items = list(reversed(items))
+
+            if parsed.l:
+                for item in items:
+                    type_char = "d" if item.is_dir else "-"
                     if parsed.human_readable:
-                        size = _human_readable_size(meta.size).rjust(6)
+                        size = _human_readable_size(item.size).rjust(6)
                     else:
-                        size = str(meta.size).rjust(8)
+                        size = str(item.size).rjust(8)
                     time = (
-                        meta.modified_at[:16].replace("T", " ")
-                        if meta.modified_at
+                        item.modified_at[:16].replace("T", " ")
+                        if item.modified_at
                         else " " * 16
                     )
-                    stdout.write(f"-rw-r--r-- 1 agent agent {size} {time} {path}\n")
-                else:
-                    stdout.write(f"{path}\n")
-                continue
-
-            needs_detailed = parsed.l or parsed.t or parsed.S or parsed.classify
-            if needs_detailed:
-                items = fs.list_detailed(path, recursive=parsed.R)
-                if not parsed.a:
-                    items = [i for i in items if not i.name.startswith(".")]
-                if parsed.S:
-                    items = sorted(items, key=lambda x: x.size, reverse=True)
-                elif parsed.t:
-                    items = sorted(
-                        items, key=lambda x: x.modified_at or "", reverse=True
+                    suffix = "/" if parsed.classify and item.is_dir else ""
+                    stdout.write(
+                        f"{type_char}rw-r--r-- 1 agent agent {size} {time} {item.path}{suffix}\n"
                     )
-                if parsed.r:
-                    items = list(reversed(items))
-
-                if parsed.l:
-                    for item in items:
-                        type_char = "d" if item.is_dir else "-"
-                        if parsed.human_readable:
-                            size = _human_readable_size(item.size).rjust(6)
-                        else:
-                            size = str(item.size).rjust(8)
-                        time = (
-                            item.modified_at[:16].replace("T", " ")
-                            if item.modified_at
-                            else " " * 16
-                        )
-                        suffix = "/" if parsed.classify and item.is_dir else ""
-                        stdout.write(
-                            f"{type_char}rw-r--r-- 1 agent agent {size} {time} {item.path}{suffix}\n"
-                        )
-                else:
-                    filtered = [
-                        item.path + ("/" if parsed.classify and item.is_dir else "")
-                        for item in items
-                    ]
-                    if filtered:
-                        stdout.write("\n".join(filtered) + "\n")
             else:
-                items_str = fs.list(path, recursive=parsed.R)
                 filtered = [
-                    p
-                    for p in items_str
-                    if parsed.a or not p.split("/")[-1].startswith(".")
+                    item.path + ("/" if parsed.classify and item.is_dir else "")
+                    for item in items
                 ]
-                if parsed.r:
-                    filtered = list(reversed(filtered))
                 if filtered:
                     stdout.write("\n".join(filtered) + "\n")
+        else:
+            items_str = fs.list(path, recursive=parsed.R)
+            filtered = [
+                p for p in items_str if parsed.a or not p.split("/")[-1].startswith(".")
+            ]
+            if parsed.r:
+                filtered = list(reversed(filtered))
+            if filtered:
+                stdout.write("\n".join(filtered) + "\n")
+
+    # GNU's order: an operand that is missing is reported and the rest
+    # are listed; file operands (and, with -d, directories as entries)
+    # come first, by name and with no header; then each directory, by
+    # name, under a "dir:" header whenever there is more than one
+    # operand, with a blank line before every group after the first.
+    missing: list[str] = []
+    files: list[str] = []
+    dirs: list[str] = []
+    for path in parsed.paths:
+        try:
+            if fs.isdir(path):
+                (files if parsed.directory else dirs).append(path)
+            elif fs.isfile(path) or fs.exists(path):
+                files.append(path)
+            else:
+                missing.append(path)
+        except Exception:
+            missing.append(path)
+
+    def operand_order(paths: list[str]) -> list[str]:
+        """Operands in the order their entries would be: by name, or by
+        size or time (largest and newest first) under -S and -t, and
+        reversed under -r."""
+        if parsed.S or parsed.t:
+
+            def key(p: str) -> Any:
+                try:
+                    meta = fs.stat(p)
+                except Exception:
+                    return 0 if parsed.S else ""
+                return meta.size if parsed.S else (meta.modified_at or "")
+
+            paths = sorted(sorted(paths), key=key, reverse=True)
+        else:
+            paths = sorted(paths)
+        return list(reversed(paths)) if parsed.r else paths
 
-        except FileNotFoundError:
-            raise TerminalError(
-                f"ls: cannot access '{path}': No such file or directory"
-            )
-        except NotADirectoryError:
-            raise TerminalError(f"ls: cannot access '{path}': Not a directory")
-        except Exception as e:
-            raise TerminalError(f"ls: {e}")
+    files = operand_order(files)
+    dirs = operand_order(dirs)
+    errors = [f"ls: cannot access '{p}': No such file or directory" for p in missing]
+    if not files and not dirs:
+        raise TerminalError("\n".join(errors))
+
+    try:
+        for path in files:
+            if parsed.l:
+                stdout.write(long_line(path, "d" if fs.isdir(path) else "-"))
+            else:
+                stdout.write(f"{path}\n")
+        headers = len(parsed.paths) > 1
+        for k, path in enumerate(dirs):
+            if files or k:
+                stdout.write("\n")
+            if headers:
+                stdout.write(f"{path}:\n")
+            list_dir(path)
+    except FileNotFoundError as e:
+        raise TerminalError(
+            f"ls: cannot access '{e.filename or e}': No such file or directory"
+        )
+    except NotADirectoryError as e:
+        raise TerminalError(f"ls: cannot access '{e.filename or e}': Not a directory")
+    except TerminalError:
+        raise
+    except Exception as e:
+        raise TerminalError(f"ls: {e}")
 
-        if i < len(parsed.paths) - 1:
-            stdout.write("\n")
+    if errors:
+        return CommandResult(exit_code=2, stderr="\n".join(errors) + "\n")
+    return None
 
 
 def touch(ctx: CommandContext) -> CommandResult | None:

{termish-0.2.1 → termish-0.2.2}/termish/interpreter/core.py

@@ -21,6 +21,8 @@ from .commands import io as io_cmds
 from .commands import jq as jq_cmd
 from .commands import sed as sed_cmd
 from .commands._util import resolve_path
+from .pathglob import expand as expand_pathname
+from .pathglob import has_magic
 
 #: The redirect target that discards: written to, nothing is kept;
 #: read from, it is empty. Never a file in the filesystem.
@@ -535,9 +537,11 @@ def _expand_args(
             # Fully unquoted: word removal, then globbing
             if masked == "" and arg != "":
                 continue
-            if "*" in masked or "?" in masked:
+            if has_magic(masked):
+                # bash's pathname expansion, segment by segment (see
+                # pathglob); a word that matches nothing stays as typed
                 try:
-                    matches = fs.glob(masked)
+                    matches = expand_pathname(masked, fs)
                     expanded.extend(matches if matches else [masked])
                 except Exception:
                     expanded.append(masked)

termish-0.2.2/termish/interpreter/pathglob.py

@@ -0,0 +1,140 @@
+"""Pathname expansion, as bash does it.
+
+An unquoted word holding ``*``, ``?`` or a ``[...]`` class is matched
+against the filesystem one path segment at a time:
+
+- ``*``, ``?`` and ``[...]`` match within a segment and never cross a
+  ``/``: ``a/*`` names the entries directly under ``a``, directories
+  included, and nothing below them;
+- a name starting with ``.`` is matched only by a segment that itself
+  starts with ``.``, as with bash's ``dotglob`` off;
+- ``**`` matches zero or more directories (bash with ``globstar`` on),
+  and a final ``**`` everything below, files included;
+- a trailing ``/`` matches directories only, and is kept;
+- the matches keep the word's own form: a relative word expands to
+  relative paths and an absolute one to absolute paths, sorted.
+
+A word that matches nothing is left as it is (``nullglob`` off), which
+the caller does by getting an empty list back.
+
+It is done here, through the filesystem protocol's ``list``, ``isdir``
+and ``exists``, rather than by asking the filesystem to glob: every
+filesystem then expands the same way, whether or not its own ``glob``
+treats ``*`` as crossing ``/`` or knows about directories it holds
+only implicitly.
+"""
+
+from __future__ import annotations
+
+import posixpath
+from fnmatch import fnmatchcase
+from typing import Any
+
+
+def has_magic(word: str) -> bool:
+    """Whether ``word`` is a pattern: it holds ``*`` or ``?``, or a
+    ``[`` closed by a later ``]``."""
+    if "*" in word or "?" in word:
+        return True
+    start = word.find("[")
+    return start != -1 and word.find("]", start + 2) != -1
+
+
+def expand(pattern: str, fs: Any) -> list[str]:
+    """The paths ``pattern`` matches, sorted; empty when none do."""
+    absolute = pattern.startswith("/")
+    parts = pattern.split("/")
+    if absolute:
+        parts = parts[1:]
+    trailing = len(parts) > 1 and parts[-1] == ""
+    if trailing:
+        parts = parts[:-1]
+    parts = [p for p in parts if p != ""] if parts else []
+    found: set[str] = set()
+    _walk(fs, "/" if absolute else "", parts, 0, trailing, found)
+    return sorted(found)
+
+
+def _join(base: str, name: str) -> str:
+    if base == "":
+        return name
+    if base.endswith("/"):
+        return base + name
+    return base + "/" + name
+
+
+def _names(fs: Any, base: str) -> list[str]:
+    try:
+        entries = fs.list(base or ".")
+    except Exception:
+        return []
+    return [posixpath.basename(str(e).rstrip("/")) for e in entries]
+
+
+def _isdir(fs: Any, path: str) -> bool:
+    try:
+        return bool(fs.isdir(path or "."))
+    except Exception:
+        return False
+
+
+def _exists(fs: Any, path: str) -> bool:
+    try:
+        return bool(fs.exists(path))
+    except Exception:
+        return False
+
+
+def _everything(fs: Any, base: str, found: set[str]) -> None:
+    """Every entry below ``base`` that does not start with a dot."""
+    for name in _names(fs, base):
+        if name.startswith("."):
+            continue
+        path = _join(base, name)
+        found.add(path)
+        if _isdir(fs, path):
+            _everything(fs, path, found)
+
+
+def _walk(
+    fs: Any, base: str, parts: list[str], i: int, trailing: bool, found: set[str]
+) -> None:
+    if i == len(parts):
+        if trailing:
+            if _isdir(fs, base):
+                found.add(base if base.endswith("/") else base + "/")
+        elif base:
+            found.add(base)
+        return
+    part = parts[i]
+    last = i == len(parts) - 1
+    if part == "**" and last and not trailing:
+        # a final ** names everything below: the base as a directory,
+        # then every entry at every depth, files as well as directories
+        if base:
+            found.add(base if base.endswith("/") else base + "/")
+        _everything(fs, base, found)
+        return
+    if part == "**":
+        # zero directories here, then one more level and ** again
+        _walk(fs, base, parts, i + 1, trailing, found)
+        for name in _names(fs, base):
+            if name.startswith("."):
+                continue
+            path = _join(base, name)
+            if _isdir(fs, path):
+                _walk(fs, path, parts, i, trailing, found)
+        return
+    if not has_magic(part):
+        path = _join(base, part)
+        if (last and _exists(fs, path)) or (not last and _isdir(fs, path)):
+            _walk(fs, path, parts, i + 1, trailing, found)
+        return
+    for name in _names(fs, base):
+        if name.startswith(".") and not part.startswith("."):
+            continue
+        if not fnmatchcase(name, part):
+            continue
+        path = _join(base, name)
+        if last or _isdir(fs, path):
+            _walk(fs, path, parts, i + 1, trailing, found)

{termish-0.2.1 → termish-0.2.2}/termish/parser.py

@@ -237,8 +237,9 @@ def to_script(text: str) -> Script:
     # be treated as part of words.  Without this, "user@host" splits into
     # ["user", "@", "host"], "100%" into ["100", "%"], etc.
     # "$?{}" keeps variable forms ("$?", "$NAME", "${NAME}") intact as
-    # single words for execution-time expansion.
-    lexer.wordchars += ":@,%+!^$?{}"
+    # single words for execution-time expansion. "[]" keeps a glob's
+    # class ("a/[bc]*") one word; `[ -f x ]` still splits on its spaces.
+    lexer.wordchars += ":@,%+!^$?{}[]"
 
     # Treat newlines as tokens, not whitespace, so we can use them as separators
     lexer.whitespace = " \t\r"

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

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

{termish-0.2.1 → termish-0.2.2}/termish.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ termish/fs/memory.py
 termish/fs/protocol.py
 termish/interpreter/__init__.py
 termish/interpreter/core.py
+termish/interpreter/pathglob.py
 termish/interpreter/commands/__init__.py
 termish/interpreter/commands/_argparse.py
 termish/interpreter/commands/_regex.py
@@ -57,6 +58,7 @@ tests/test_jq.py
 tests/test_memory_fs.py
 tests/test_monkeyfs_compat.py
 tests/test_parser.py
+tests/test_pathglob.py
 tests/test_printf.py
 tests/test_quote_masker.py
 tests/test_sed.py

{termish-0.2.1 → termish-0.2.2}/termish.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 dist
+scratch
 termish

{termish-0.2.1 → termish-0.2.2}/tests/test_expansion.py

@@ -141,7 +141,8 @@ class TestVarExpansion:
         fs.write("/a.txt", b"")
         fs.write("/b.txt", b"")
         out = execute("echo $PAT", fs, env={"PAT": "*.txt"})
-        assert sorted(out.split()) == ["/a.txt", "/b.txt"]
+        # a relative pattern expands to relative paths, as in bash
+        assert sorted(out.split()) == ["a.txt", "b.txt"]
 
     def test_env_mutation_visible_to_later_commands(self, fs):
         def setvar(ctx: CommandContext) -> CommandResult | None:

termish-0.2.2/tests/test_pathglob.py

@@ -0,0 +1,152 @@
+"""Pathname expansion and ``ls`` operands, as bash and GNU do them (#28).
+
+``ls app/assets/*`` in a session listed every file in the tree twice:
+``*`` crossed ``/`` and expanded to absolute paths, and ``ls`` gave each
+file operand a ``path:`` header of its own. Every expected value here
+was checked against bash and GNU coreutils.
+"""
+
+import pytest
+
+from termish import MemoryFS, execute
+from termish.errors import TerminalError
+from termish.interpreter.pathglob import has_magic
+
+
+@pytest.fixture
+def fs():
+    fs = MemoryFS()
+    execute(
+        "mkdir -p a/bg a/cards a/.git; touch a/bg/x.png a/bg/y.png a/cards/z.png "
+        "a/top.txt a/.hid",
+        fs,
+    )
+    return fs
+
+
+@pytest.mark.parametrize(
+    "command, expected",
+    [
+        # * stays within a segment, directories included
+        ("echo a/*", "a/bg a/cards a/top.txt"),
+        ("echo /a/*", "/a/bg /a/cards /a/top.txt"),
+        ("echo a/*/*.png", "a/bg/x.png a/bg/y.png a/cards/z.png"),
+        # a trailing / matches directories only, and is kept
+        ("echo a/*/", "a/bg/ a/cards/"),
+        # ** crosses directories, zero or more of them
+        ("echo a/**/*.png", "a/bg/x.png a/bg/y.png a/cards/z.png"),
+        ("echo a/**/top.txt", "a/top.txt"),
+        # a final ** names everything below, files included
+        ("echo a/**", "a/ a/bg a/bg/x.png a/bg/y.png a/cards a/cards/z.png a/top.txt"),
+        ("echo a/**/", "a/ a/bg/ a/cards/"),
+        # dotfiles only for a pattern that starts with a dot
+        ("echo a/.*", "a/.git a/.hid"),
+        ("echo a/.h*", "a/.hid"),
+        # ? and classes, negated classes too, all one word
+        ("echo a/?g", "a/bg"),
+        ("echo a/[bc]*", "a/bg a/cards"),
+        ("echo a/[!b]*", "a/cards a/top.txt"),
+        # relative to the working directory, and kept relative
+        ("cd a; echo *", "bg cards top.txt"),
+        ("cd a; echo bg/*", "bg/x.png bg/y.png"),
+        ("cd a; echo ../a/top*", "../a/top.txt"),
+        # no match: the word stays as typed
+        ("echo nope/*", "nope/*"),
+        ("echo a/*.zip", "a/*.zip"),
+        # quoted: never expanded
+        ("echo 'a/*'", "a/*"),
+        ("echo x[0]", "x[0]"),
+    ],
+)
+def test_expansion_matches_bash(fs, command, expected):
+    assert execute(command, fs).strip() == expected
+
+
+def test_a_bracket_is_part_of_the_word_but_test_still_parses(fs):
+    assert execute("[ -d a ] && echo dir", fs).strip() == "dir"
+    assert execute("[ -f a/top.txt ]; echo $?", fs).strip() == "0"
+
+
+def test_what_counts_as_a_pattern():
+    assert has_magic("*.py") and has_magic("a?") and has_magic("[ab]")
+    assert not has_magic("plain") and not has_magic("[") and not has_magic("x[]")
+
+
+@pytest.mark.parametrize(
+    "command, expected",
+    [
+        # files first, by name, no headers; then each directory under one
+        (
+            "ls a/*",
+            "a/top.txt\n\na/bg:\nx.png\ny.png\n\na/cards:\nz.png\n",
+        ),
+        ("ls a/top.txt a/bg/x.png", "a/bg/x.png\na/top.txt\n"),
+        ("ls a/bg a/cards", "a/bg:\nx.png\ny.png\n\na/cards:\nz.png\n"),
+        # one directory operand: its contents, no header
+        ("ls a/bg", "x.png\ny.png\n"),
+        # -d lists the directories themselves
+        ("ls -d a/*", "a/bg\na/cards\na/top.txt\n"),
+    ],
+)
+def test_ls_operands_match_gnu(fs, command, expected):
+    assert execute(command, fs) == expected
+
+
+def test_ls_reports_a_missing_operand_and_lists_the_rest(fs):
+    out = execute("ls a/top.txt nope; echo st=$?", fs)
+    assert "a/top.txt\n" in out
+    assert "ls: cannot access 'nope': No such file or directory" in out
+    assert out.endswith("st=2\n")
+
+
+def test_ls_with_nothing_to_list_is_an_error(fs):
+    with pytest.raises(TerminalError, match="cannot access 'nope'"):
+        execute("ls nope", fs)
+
+
+PATTERNS = [
+    "a/*",
+    "a/*/",
+    "a/*/*.png",
+    "a/**",
+    "a/**/",
+    "a/**/*.png",
+    "a/**/top.txt",
+    "a/.*",
+    "a/?g",
+    "a/[bc]*",
+    "a/[!b]*",
+    "*",
+    "**",
+    "a/nope*",
+]
+
+
+@pytest.mark.parametrize("pattern", PATTERNS)
+def test_expansion_agrees_with_pythons_glob(tmp_path, monkeypatch, pattern):
+    """Python's glob(recursive=True) follows bash's globstar, dotfiles
+    and trailing-slash rules, so a real directory tree is the reference."""
+    import glob as pyglob
+
+    for d in ("a/bg", "a/cards", "a/.git"):
+        (tmp_path / d).mkdir(parents=True)
+    for f in ("a/bg/x.png", "a/bg/y.png", "a/cards/z.png", "a/top.txt", "a/.hid"):
+        (tmp_path / f).write_text("")
+    monkeypatch.chdir(tmp_path)
+    expected = sorted(pyglob.glob(pattern, recursive=True)) or [pattern]
+
+    fs = MemoryFS()
+    execute(
+        "mkdir -p a/bg a/cards a/.git; touch a/bg/x.png a/bg/y.png a/cards/z.png "
+        "a/top.txt a/.hid",
+        fs,
+    )
+    assert execute(f"printf '%s\\n' {pattern}", fs).split() == expected
+
+
+def test_ls_orders_operands_by_size_and_time_under_s_and_t(fs):
+    fs.write("/small.txt", b"x")
+    fs.write("/big.txt", b"x" * 100)
+    assert execute("ls -S small.txt big.txt", fs) == "big.txt\nsmall.txt\n"
+    assert execute("ls -Sr small.txt big.txt", fs) == "small.txt\nbig.txt\n"
+    assert execute("ls small.txt big.txt", fs) == "big.txt\nsmall.txt\n"  # by name