flatdir 0.0.6__tar.gz

flatdir-0.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Romain Vuillemot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flatdir-0.0.6/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: flatdir
+Version: 0.0.6
+Summary: A Python library to create a flat JSON index of files and directories.
+Author: Your Name
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/romsson/flatdir
+Project-URL: Repository, https://github.com/romsson/flatdir
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install flatdir
+```
+
+## Usage
+
+```bash
+python -m flatdir .
+```

flatdir-0.0.6/README.md

@@ -0,0 +1,106 @@
+# flatdir
+
+A Python library to create a flat JSON index of files and directories
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install flatdir
+```
+
+## Usage
+
+```bash
+python -m flatdir .
+```
+
+Returns a JSON file with metadata for each entry in the current directory and its subdirectories.
+
+```json
+(base) rvuillem@Romains-MacBook-Pro flatdir % python -m flatdir .
+[
+    {
+        "name": ".DS_Store",
+        "type": "file",
+        "mtime": "Mon, 23 Feb 2026 13:12:54 GMT",
+        "size": 6148
+    },
+...
+]
+```
+
+`--limit N` to limit the number of entries processed:
+
+```bash
+python -m flatdir . --limit 10
+```
+
+`--depth N` to limit the depth of the directory tree:
+
+```bash
+python -m flatdir . --depth 2
+```
+
+`--output FILE` to write the result to a file:
+
+```bash
+python -m flatdir . --output flat.json
+```
+
+`--fields FILE` to add custom fields via a plugin file:
+
+```bash
+python -m flatdir . --fields my_fields.py
+```
+
+The plugin file is a Python file where each public function becomes a JSON field.
+Each function receives the entry `Path` and the `root` directory path.
+Return `None` to omit the field from the output:
+
+```python
+# my_fields.py
+from pathlib import Path
+
+def ext(path: Path, root: Path) -> str:
+    return path.suffix
+
+def line_count(path: Path, root: Path) -> int | None:
+    if path.is_dir():
+        return None
+    return len(path.read_text().splitlines())
+```
+
+Output (both files and directories are listed):
+
+```json
+[
+    {
+        "name": "docs",
+        "type": "directory",
+        "mtime": "Mon, 23 Feb 2026 13:12:54 GMT"
+    },
+    {
+        "name": "README.md",
+        "type": "file",
+        "mtime": "Mon, 23 Feb 2026 13:12:54 GMT",
+        "size": 835,
+        "ext": ".md",
+        "line_count": 54
+    }
+]
+```
+
+The default fields (`name`, `type`, `mtime`, `size`) are themselves plugins defined
+in `src/flatdir/plugins/defaults.py`. Additional examples are in `src/flatdir/plugins/`.
+
+All options can be combined:
+
+```bash
+python -m flatdir . --depth 0 --limit 10 --fields my_fields.py --output result.json
+```

flatdir-0.0.6/docs/index.md

@@ -0,0 +1,27 @@
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install flatdir
+```
+
+## Usage
+
+```bash
+python -m flatdir .
+```

flatdir-0.0.6/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "flatdir"
+description = "A Python library to create a flat JSON index of files and directories."
+readme = "docs/index.md"
+requires-python = ">=3.10,<4"
+license = "MIT"
+authors = [{ name = "Your Name" }]
+classifiers = [
+  "Natural Language :: English",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+dependencies = []
+dynamic = ["version"]
+
+[tool.setuptools.dynamic]
+version = {attr = "flatdir.__version__"}
+
+[project.urls]
+Homepage = "https://github.com/romsson/flatdir"
+Repository = "https://github.com/romsson/flatdir"
+
+[dependency-groups]
+tests = [
+  "coverage[toml]>=7,<8",
+  "httpx>=0.23,<1",
+  "pytest-mock>=3,<4",
+  "pytest>=8.1.1,<9",
+]
+
+[tool.coverage.run]
+command_line = "-m pytest"
+source_pkgs = ["flatdir", "tests"]
+
+[tool.coverage.paths]
+flatdir = ["src/flatdir"]
+tests = ["tests"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+minversion = "6.0"
+testpaths = ["tests"]

flatdir-0.0.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flatdir-0.0.6/src/flatdir/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.6"

flatdir-0.0.6/src/flatdir/__main__.py

@@ -0,0 +1,89 @@
+"""Command-line entrypoint for flatdir: print directory listing as JSON.
+
+Usage: python -m flatdir [--limit N] [--depth N] [--output FILE] [--fields FILE] [path]
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from .listing import list_entries
+from .plugins_loader import load_fields_file
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+
+    # parse --limit flag if present
+    limit: int | None = None
+    if "--limit" in argv:
+        try:
+            idx = argv.index("--limit")
+            limit = int(argv[idx + 1])
+            argv = argv[:idx] + argv[idx + 2 :]
+        except (IndexError, ValueError):
+            print("error: --limit requires a valid integer argument", file=sys.stderr)
+            return 1
+
+    # parse --depth flag if present
+    depth: int | None = None
+    if "--depth" in argv:
+        try:
+            idx = argv.index("--depth")
+            depth = int(argv[idx + 1])
+            argv = argv[:idx] + argv[idx + 2 :]
+        except (IndexError, ValueError):
+            print("error: --depth requires a valid integer argument", file=sys.stderr)
+            return 1
+
+    # parse --output flag if present
+    output: str | None = None
+    if "--output" in argv:
+        try:
+            idx = argv.index("--output")
+            output = argv[idx + 1]
+            argv = argv[:idx] + argv[idx + 2 :]
+        except (IndexError, ValueError):
+            print("error: --output requires a file path argument", file=sys.stderr)
+            return 1
+
+    # parse --fields flag if present
+    fields = None
+    if "--fields" in argv:
+        try:
+            idx = argv.index("--fields")
+            fields_path = argv[idx + 1]
+            fields = load_fields_file(fields_path)
+            argv = argv[:idx] + argv[idx + 2 :]
+        except IndexError:
+            print("error: --fields requires a file path argument", file=sys.stderr)
+            return 1
+        except (FileNotFoundError, ImportError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+
+    path = Path(argv[0]) if argv else Path(".")
+
+    # error in case of missing path or path is not a directory
+    if not path.exists() or not path.is_dir():
+        print(f"path is not a directory: {path}", file=sys.stderr)
+        return 2
+
+    # generate the actual list of entries to be returned as JSON
+    entries = list_entries(path, limit=limit, depth=depth, fields=fields)
+
+    # write JSON to output file or stdout
+    if output is not None:
+        with open(output, "w", encoding="utf-8") as f:
+            json.dump(entries, f, ensure_ascii=False, indent=4)
+            f.write("\n")
+    else:
+        json.dump(entries, sys.stdout, ensure_ascii=False, indent=4)
+        _ = sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flatdir-0.0.6/src/flatdir/listing.py

@@ -0,0 +1,66 @@
+"""List entries in a directory and return metadata as a list of dict.
+
+Each entry is a dict with keys determined by field plugins (defaults: name, type, mtime, size).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .plugins import defaults as _defaults
+from .plugins_loader import load_fields_file
+
+# built-in default fields, loaded once
+DEFAULT_FIELDS = load_fields_file(_defaults.__file__)
+
+
+def list_entries(
+    root: Path,
+    limit: int | None = None,
+    depth: int | None = None,
+    fields: dict[str, object] | None = None,
+) -> list[dict[str, object]]:
+    entries: list[dict[str, object]] = []
+    root = root.resolve()
+
+    # merge default fields with custom fields (custom can override defaults)
+    all_fields = dict(DEFAULT_FIELDS)
+    if fields:
+        all_fields.update(fields)
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        base = Path(dirpath)
+        # check depth constraint
+        current_depth = len(base.relative_to(root).parts)
+        if depth is not None and depth >= 0 and current_depth > depth:
+            continue
+
+        # list subdirectories at this level
+        for dirname in dirnames:
+            p = (base / dirname).resolve()
+            entry: dict[str, object] = {}
+            for field_name, func in all_fields.items():
+                value = func(p, root)
+                if value is not None:
+                    entry[field_name] = value
+            entries.append(entry)
+
+        # list files at this level
+        for filename in filenames:
+            p = (base / filename).resolve()
+            entry = {}
+            for field_name, func in all_fields.items():
+                value = func(p, root)
+                if value is not None:
+                    entry[field_name] = value
+            entries.append(entry)
+
+    # return a sorted list of entries
+    entries.sort(key=lambda e: str(e.get("name", "")))
+
+    # apply limit if provided
+    if limit is not None and limit >= 0:
+        entries = entries[:limit]
+
+    return entries

flatdir-0.0.6/src/flatdir/plugins/defaults.py

@@ -0,0 +1,38 @@
+"""Default field plugins for flatdir.
+
+These functions produce the built-in fields: name, type, mtime, size.
+Each function receives the file path and the root directory path.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+
+def name(path: Path, root: Path) -> str:
+    """Relative path from the listing root."""
+    try:
+        return str(path.relative_to(root))
+    except ValueError:
+        return str(os.path.relpath(str(path), str(root)))
+
+
+def type(path: Path, root: Path) -> str:
+    """Entry type: 'file' or 'directory'."""
+    return "directory" if path.is_dir() else "file"
+
+
+def mtime(path: Path, root: Path) -> str:
+    """Last modification time in HTTP-date format."""
+    st = path.stat()
+    t = time.gmtime(st.st_mtime)
+    return time.strftime("%a, %d %b %Y %H:%M:%S GMT", t)
+
+
+def size(path: Path, root: Path) -> int | None:
+    """File size in bytes. Returns None for directories (omitted from output)."""
+    if path.is_dir():
+        return None
+    return int(path.stat().st_size)

flatdir-0.0.6/src/flatdir/plugins/filename_length.py

@@ -0,0 +1,8 @@
+"""Example plugin: adds the length of the filename to each entry."""
+
+from pathlib import Path
+
+
+def filename_length(path: Path, root: Path) -> int:
+    """Return the number of characters in the filename (including extension)."""
+    return len(path.name)

flatdir-0.0.6/src/flatdir/plugins_loader.py

@@ -0,0 +1,52 @@
+"""Load custom field functions from a user-provided Python file.
+
+A fields file is a plain Python module where each **public** function
+(i.e. whose name does not start with ``_``) is treated as a field provider.
+
+Each function must accept a single :class:`pathlib.Path` argument (the file
+being listed) and return a JSON-serialisable value. The function name becomes
+the field key in the output.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import sys
+from pathlib import Path
+from typing import Callable
+
+FieldFunc = Callable[[Path], object]
+
+
+def load_fields_file(filepath: str) -> dict[str, FieldFunc]:
+    """Import *filepath* as a module and return its public callables.
+
+    Returns a ``{name: func}`` mapping for every public, non-class callable
+    defined in the file.
+    """
+    path = Path(filepath).resolve()
+    if not path.is_file():
+        raise FileNotFoundError(f"fields file not found: {filepath}")
+
+    # import the file as a temporary module
+    spec = importlib.util.spec_from_file_location("_flatdir_fields", str(path))
+    if spec is None or spec.loader is None:
+        raise ImportError(f"cannot load fields file: {filepath}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["_flatdir_fields"] = module
+    spec.loader.exec_module(module)
+
+    fields: dict[str, FieldFunc] = {}
+    for name, obj in inspect.getmembers(module, callable):
+        # skip private names, classes, and imported builtins
+        if name.startswith("_"):
+            continue
+        if inspect.isclass(obj):
+            continue
+        # only keep functions actually defined in this file
+        if getattr(obj, "__module__", None) != "_flatdir_fields":
+            continue
+        fields[name] = obj
+
+    return fields

flatdir-0.0.6/src/flatdir.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: flatdir
+Version: 0.0.6
+Summary: A Python library to create a flat JSON index of files and directories.
+Author: Your Name
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/romsson/flatdir
+Project-URL: Repository, https://github.com/romsson/flatdir
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+# flatdir
+
+`flatdir` scans a directory tree and generates a flat JSON file with metadata for each entry.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install flatdir
+```
+
+## Usage
+
+```bash
+python -m flatdir .
+```

flatdir-0.0.6/src/flatdir.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+docs/index.md
+src/flatdir/__init__.py
+src/flatdir/__main__.py
+src/flatdir/listing.py
+src/flatdir/plugins_loader.py
+src/flatdir.egg-info/PKG-INFO
+src/flatdir.egg-info/SOURCES.txt
+src/flatdir.egg-info/dependency_links.txt
+src/flatdir.egg-info/top_level.txt
+src/flatdir/plugins/__init__.py
+src/flatdir/plugins/defaults.py
+src/flatdir/plugins/filename_length.py
+tests/test_depth.py
+tests/test_fields.py
+tests/test_json_output.py
+tests/test_limit.py
+tests/test_output.py
+tests/test_version.py

flatdir-0.0.6/src/flatdir.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flatdir-0.0.6/src/flatdir.egg-info/top_level.txt

@@ -0,0 +1 @@
+flatdir

flatdir-0.0.6/tests/test_depth.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from flatdir import listing
+
+
+def test_list_entries_with_depth(tmp_path: Path):
+    """Test that list_entries respects the depth parameter."""
+    # create a nested directory structure
+    # tmp_path/
+    #   file0.txt
+    #   sub1/
+    #     file1.txt
+    #     sub2/
+    #       file2.txt
+    (tmp_path / "file0.txt").write_text("depth 0")
+    sub1 = tmp_path / "sub1"
+    sub1.mkdir()
+    (sub1 / "file1.txt").write_text("depth 1")
+    sub2 = sub1 / "sub2"
+    sub2.mkdir()
+    (sub2 / "file2.txt").write_text("depth 2")
+
+    # Test with depth=0 (root level only: file0.txt + sub1/)
+    depth0 = listing.list_entries(tmp_path, depth=0)
+    assert len(depth0) == 2
+    assert "file0.txt" in [e["name"] for e in depth0]
+    assert "sub1" in [e["name"] for e in depth0]
+
+    # Test with depth=1 (root + one level down)
+    depth1 = listing.list_entries(tmp_path, depth=1)
+    assert len(depth1) == 4  # file0.txt, sub1/, sub1/file1.txt, sub1/sub2/
+    names = {e["name"] for e in depth1}
+    assert "file0.txt" in names
+    assert any("file1.txt" in n for n in names)
+
+    # Test with depth=2 (root + two levels down)
+    depth2 = listing.list_entries(tmp_path, depth=2)
+    assert len(depth2) == 5  # file0.txt, sub1/, sub1/file1.txt, sub1/sub2/, sub1/sub2/file2.txt
+
+    # Test with no depth limit (None)
+    unlimited = listing.list_entries(tmp_path, depth=None)
+    assert len(unlimited) == 5

flatdir-0.0.6/tests/test_fields.py

@@ -0,0 +1,147 @@
+"""Tests for the --fields plugin system."""
+
+import json
+from pathlib import Path
+
+from flatdir.__main__ import main
+from flatdir.listing import list_entries
+from flatdir.plugins_loader import load_fields_file
+
+
+# -- plugin loader tests --
+
+
+def test_load_fields_file_extracts_public_functions(tmp_path: Path):
+    """Public functions in the fields file become field providers."""
+    fields_file = tmp_path / "my_fields.py"
+    fields_file.write_text(
+        "from pathlib import Path\n"
+        "def ext(path: Path, root: Path) -> str:\n"
+        "    return path.suffix\n"
+        "def _private(path: Path, root: Path) -> str:\n"
+        "    return 'hidden'\n"
+    )
+    fields = load_fields_file(str(fields_file))
+    assert "ext" in fields
+    assert "_private" not in fields
+
+
+def test_load_fields_file_ignores_classes(tmp_path: Path):
+    """Classes should not be picked up as field providers."""
+    fields_file = tmp_path / "my_fields.py"
+    fields_file.write_text(
+        "from pathlib import Path\n"
+        "class Foo:\n"
+        "    pass\n"
+        "def ext(path: Path, root: Path) -> str:\n"
+        "    return path.suffix\n"
+    )
+    fields = load_fields_file(str(fields_file))
+    assert "ext" in fields
+    assert "Foo" not in fields
+
+
+def test_load_fields_file_not_found():
+    """A missing fields file should raise FileNotFoundError."""
+    try:
+        load_fields_file("/nonexistent/fields.py")
+        assert False, "should have raised"
+    except FileNotFoundError:
+        pass
+
+
+# -- listing integration tests --
+
+
+def test_list_entries_with_custom_fields(tmp_path: Path):
+    """Custom fields should appear in each entry."""
+    (tmp_path / "doc.txt").write_text("hello")
+    (tmp_path / "img.png").write_bytes(b"\x89PNG")
+
+    fields = {
+        "ext": lambda p, root: p.suffix,
+        "stem": lambda p, root: p.stem,
+    }
+    entries = list_entries(tmp_path, fields=fields)
+    assert len(entries) == 2
+    for entry in entries:
+        assert "ext" in entry
+        assert "stem" in entry
+
+    txt_entry = next(e for e in entries if e["name"] == "doc.txt")
+    assert txt_entry["ext"] == ".txt"
+    assert txt_entry["stem"] == "doc"
+
+
+def test_list_entries_without_fields_unchanged(tmp_path: Path):
+    """Without fields, entries should have only the built-in keys."""
+    (tmp_path / "a.txt").write_text("a")
+    entries = list_entries(tmp_path)
+    assert set(entries[0].keys()) == {"name", "type", "mtime", "size"}
+
+
+# -- CLI integration tests --
+
+
+def test_cli_fields_flag(tmp_path: Path, capsys):
+    """--fields FILE should add custom fields to the JSON output."""
+    # create a fields plugin
+    fields_file = tmp_path / "my_fields.py"
+    fields_file.write_text(
+        "from pathlib import Path\n"
+        "def ext(path: Path, root: Path) -> str:\n"
+        "    return path.suffix\n"
+    )
+
+    # create a directory to scan
+    scan_dir = tmp_path / "data"
+    scan_dir.mkdir()
+    (scan_dir / "notes.md").write_text("# Notes")
+
+    rc = main(["--fields", str(fields_file), str(scan_dir)])
+    assert rc == 0
+
+    captured = capsys.readouterr()
+    data = json.loads(captured.out)
+    assert len(data) == 1
+    assert data[0]["ext"] == ".md"
+
+
+def test_cli_fields_combined_with_output(tmp_path: Path):
+    """--fields + --output should write enriched JSON to file."""
+    fields_file = tmp_path / "my_fields.py"
+    fields_file.write_text(
+        "from pathlib import Path\n"
+        "def ext(path: Path, root: Path) -> str:\n"
+        "    return path.suffix\n"
+    )
+
+    scan_dir = tmp_path / "data"
+    scan_dir.mkdir()
+    (scan_dir / "a.py").write_text("pass")
+
+    out_file = tmp_path / "result.json"
+    rc = main([
+        "--fields", str(fields_file),
+        "--output", str(out_file),
+        str(scan_dir),
+    ])
+    assert rc == 0
+    data = json.loads(out_file.read_text(encoding="utf-8"))
+    assert data[0]["ext"] == ".py"
+
+
+def test_cli_fields_missing_argument(capsys):
+    """--fields without a file path should return error code 1."""
+    rc = main(["--fields"])
+    assert rc == 1
+    captured = capsys.readouterr()
+    assert "error" in captured.err.lower()
+
+
+def test_cli_fields_nonexistent_file(capsys):
+    """--fields with a nonexistent file should return error code 1."""
+    rc = main(["--fields", "/nonexistent/fields.py", "."])
+    assert rc == 1
+    captured = capsys.readouterr()
+    assert "not found" in captured.err.lower()

flatdir-0.0.6/tests/test_json_output.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+from flatdir import listing
+
+
+def test_outputs_valid_json(tmp_path: Path):
+    # create a small directory with one file
+    sub = tmp_path / "sub"
+    sub.mkdir()
+    f = sub / "a.txt"
+    _ = f.write_text("this is a test")
+
+    entries = listing.list_entries(tmp_path)
+
+    # ensure our file is present in the listing (cast name to str for typing)
+    assert any(str(entry.get("name", "")).endswith("a.txt") for entry in entries)

flatdir-0.0.6/tests/test_limit.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from flatdir import listing
+
+
+def test_list_entries_with_limit(tmp_path: Path):
+    """Test that list_entries respects the limit parameter."""
+    # create a directory with 5 files
+    for i in range(5):
+        (tmp_path / f"file{i}.txt").write_text(f"content {i}")
+
+    # Test with limit
+    limited = listing.list_entries(tmp_path, limit=2)
+    assert len(limited) == 2
+
+    # Test without limit (None)
+    unlimited = listing.list_entries(tmp_path, limit=None)
+    assert len(unlimited) == 5
+
+    # Test with negative limit (should return all)
+    neg_limited = listing.list_entries(tmp_path, limit=-1)
+    assert len(neg_limited) == 5
+
+    # Test with zero limit (should return empty list)
+    zero_limited = listing.list_entries(tmp_path, limit=0)
+    assert len(zero_limited) == 0

flatdir-0.0.6/tests/test_output.py

@@ -0,0 +1,85 @@
+"""Tests for the --output flag."""
+
+import json
+from pathlib import Path
+
+from flatdir.__main__ import main
+
+
+def test_output_writes_json_to_file(tmp_path: Path):
+    """--output FILE should write JSON to the given file instead of stdout."""
+    # create a directory with a file
+    (tmp_path / "hello.txt").write_text("hello")
+
+    out_file = tmp_path / "result.json"
+    rc = main(["--output", str(out_file), str(tmp_path)])
+
+    assert rc == 0
+    assert out_file.exists()
+    data = json.loads(out_file.read_text(encoding="utf-8"))
+    assert isinstance(data, list)
+    assert len(data) == 1
+    assert data[0]["name"] == "hello.txt"
+
+
+def test_output_creates_file_with_multiple_entries(tmp_path: Path):
+    """--output should write all entries to the file."""
+    for i in range(3):
+        (tmp_path / f"file{i}.txt").write_text(f"content {i}")
+
+    out_file = tmp_path / "out.json"
+    rc = main(["--output", str(out_file), str(tmp_path)])
+
+    assert rc == 0
+    data = json.loads(out_file.read_text(encoding="utf-8"))
+    assert len(data) == 3
+
+
+def test_output_combined_with_limit(tmp_path: Path):
+    """--output combined with --limit should write only limited entries."""
+    for i in range(5):
+        (tmp_path / f"file{i}.txt").write_text(f"content {i}")
+
+    out_file = tmp_path / "limited.json"
+    rc = main(["--limit", "2", "--output", str(out_file), str(tmp_path)])
+
+    assert rc == 0
+    data = json.loads(out_file.read_text(encoding="utf-8"))
+    assert len(data) == 2
+
+
+def test_output_combined_with_depth(tmp_path: Path):
+    """--output combined with --depth should write only depth-limited entries."""
+    (tmp_path / "root.txt").write_text("root")
+    sub = tmp_path / "sub"
+    sub.mkdir()
+    (sub / "deep.txt").write_text("deep")
+
+    out_file = tmp_path / "shallow.json"
+    rc = main(["--depth", "0", "--output", str(out_file), str(tmp_path)])
+
+    assert rc == 0
+    data = json.loads(out_file.read_text(encoding="utf-8"))
+    assert len(data) == 2  # root.txt + sub/
+    assert any(e["name"] == "root.txt" for e in data)
+
+
+def test_output_missing_argument(capsys):
+    """--output without a file path should print an error and return 1."""
+    rc = main(["--output"])
+
+    assert rc == 1
+    captured = capsys.readouterr()
+    assert "error" in captured.err.lower()
+
+
+def test_no_output_flag_prints_to_stdout(tmp_path: Path, capsys):
+    """Without --output, JSON should be printed to stdout."""
+    (tmp_path / "a.txt").write_text("a")
+    rc = main([str(tmp_path)])
+
+    assert rc == 0
+    captured = capsys.readouterr()
+    data = json.loads(captured.out)
+    assert isinstance(data, list)
+    assert len(data) == 1

flatdir-0.0.6/tests/test_version.py

@@ -0,0 +1,7 @@
+import packaging.version
+
+import flatdir
+
+
+def test_version_is_valid() -> None:
+    _ = packaging.version.parse(flatdir.__version__)