fluidattacks_core_filesystem 15.0.0__tar.gz → 16.0.0__tar.gz

fluidattacks_core_filesystem-16.0.0/.envrc

@@ -0,0 +1 @@
+use flake ../../..#fluidattacks-core-filesystem

fluidattacks_core_filesystem-16.0.0/.gitignore

@@ -0,0 +1,16 @@
+dist/
+dist-*/
+*.zip
+/utils/terraform-modules/**/.terraform.lock.hcl
+/.cargo-cache
+target/
+.direnv/
+.venv/
+.vscode/settings.json
+.zed/settings.json
+# each package's shell writes its own, beside the package rather than here
+**/.vscode/settings.json
+*.so
+# the publish check builds into its own tree per architecture
+target-*/
+/develops-ci-analytics-output

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fluidattacks_core_filesystem
-Version: 15.0.0
+Version: 16.0.0
 Summary: Fluid Attacks Core Filesystem Library
 Author-email: Development <development@fluidattacks.com>
 License: MPL-2.0

fluidattacks_core_filesystem-16.0.0/fluidattacks_core/filesystem/cargo.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass
+from fnmatch import fnmatchcase
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING
+
+from .defaults import CARGO_MAX_PATTERNS
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from pathlib import Path
+
+__all__ = [
+    "CARGO_MANIFEST",
+    "CargoWorkspace",
+    "is_cargo_manifest",
+    "is_workspace_member",
+    "parse_cargo_workspace",
+]
+
+CARGO_MANIFEST = "Cargo.toml"
+
+_FOLDED_MANIFEST = CARGO_MANIFEST.casefold()
+
+_Components = tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class CargoWorkspace:
+    members: tuple[_Components, ...]
+    exclude: tuple[_Components, ...]
+
+
+def is_cargo_manifest(name: str) -> bool:
+    return name.casefold() == _FOLDED_MANIFEST
+
+
+def _components(path: str) -> _Components | None:
+    pure = PurePosixPath(path)
+    if pure.is_absolute() or ".." in pure.parts:
+        return None
+    return pure.parts
+
+
+def _patterns(value: object) -> tuple[_Components, ...] | None:
+    if not isinstance(value, list) or len(value) > CARGO_MAX_PATTERNS:
+        return None
+    items = tuple(item for item in value if isinstance(item, str))
+    if len(items) != len(value):
+        return None
+    parsed = (_components(item) for item in items)
+    return tuple(parts for parts in parsed if parts is not None)
+
+
+def parse_cargo_workspace(text: str) -> CargoWorkspace | None:
+    try:
+        document = tomllib.loads(text)
+    except (ValueError, RecursionError):
+        return None
+    table = document.get("workspace")
+    if not isinstance(table, dict):
+        return None
+    members = _patterns(table.get("members", []))
+    exclude = _patterns(table.get("exclude", []))
+    if members is None or exclude is None:
+        return None
+    return CargoWorkspace(members=members, exclude=exclude)
+
+
+def _glob_matches(pattern: _Components, path: _Components) -> bool:
+    reachable = frozenset({0})
+    for head in pattern:
+        if not reachable:
+            return False
+        if head == "**":
+            reachable = frozenset(range(min(reachable), len(path) + 1))
+        else:
+            reachable = frozenset(
+                index + 1
+                for index in reachable
+                if index < len(path) and fnmatchcase(path[index], head)
+            )
+    return len(path) in reachable
+
+
+def _excludes(workspace: CargoWorkspace, relative: _Components) -> bool:
+    manifest = (*relative, CARGO_MANIFEST)
+    return any(manifest[: len(entry)] == entry for entry in workspace.exclude) and not any(
+        manifest[: len(member)] == member for member in workspace.members
+    )
+
+
+def is_workspace_member(
+    directory: Path,
+    workspaces: Mapping[Path, CargoWorkspace],
+    root: Path,
+) -> bool:
+    if directory in workspaces or directory == root:
+        return False
+    for ancestor in directory.parents:
+        workspace = workspaces.get(ancestor)
+        if workspace is not None:
+            relative = directory.relative_to(ancestor).parts
+            if not _excludes(workspace, relative):
+                return any(_glob_matches(member, relative) for member in workspace.members)
+        if ancestor == root:
+            return False
+    return False

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/fluidattacks_core/filesystem/defaults.py

@@ -3,11 +3,13 @@ from typing import TypedDict
 from .language import Language
 
 __all__ = [
+    "CARGO_MAX_PATTERNS",
     "CONFIG_MARKERS",
     "EXCLUDE_DIRS",
     "EXCLUDE_FILES",
     "EXTENDED_EXCLUDE_DIRS",
     "MANIFEST_MARKERS",
+    "MANIFEST_MAX_BYTES",
     "SKIP_DIRS",
     "TEST_DATA_DIRS",
     "TEST_FILES",
@@ -31,6 +33,10 @@ class WorkspaceSpec(TypedDict):
 
 BUNDLE_DIR_GLOBS = ["*.xcodeproj", "*.xcworkspace"]
 
+MANIFEST_MAX_BYTES = 50 * 1024
+
+CARGO_MAX_PATTERNS = 1000
+
 
 WORKSPACE_MARKERS: dict[str, WorkspaceSpec] = {
     "gradle": {

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/fluidattacks_core/filesystem/partitioning.py

@@ -10,7 +10,18 @@ from fnmatch import fnmatch, fnmatchcase
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from .defaults import BUNDLE_DIR_GLOBS, EXTENDED_EXCLUDE_DIRS, TEST_SCAFFOLD_GLOBS
+from .cargo import (
+    CargoWorkspace,
+    is_cargo_manifest,
+    is_workspace_member,
+    parse_cargo_workspace,
+)
+from .defaults import (
+    BUNDLE_DIR_GLOBS,
+    EXTENDED_EXCLUDE_DIRS,
+    MANIFEST_MAX_BYTES,
+    TEST_SCAFFOLD_GLOBS,
+)
 from .detection import (
     declared_workspaces,
     detect_anchor_language,
@@ -91,6 +102,45 @@ def _claiming_kinds(dir_path: Path, workspaces: Mapping[Path, frozenset[str]]) -
     return frozenset(kinds)
 
 
+def _cargo_workspaces(cargo_manifests: Mapping[Path, str]) -> Mapping[Path, CargoWorkspace]:
+    return {
+        dir_path: workspace
+        for dir_path, text in cargo_manifests.items()
+        if (workspace := parse_cargo_workspace(text)) is not None
+    }
+
+
+def _foreign_part_between(
+    dir_path: Path,
+    workspaces: Mapping[Path, CargoWorkspace],
+    names_by_dir: Mapping[Path, tuple[str, ...]],
+) -> bool:
+    for ancestor in dir_path.parents:
+        if ancestor in workspaces:
+            return False
+        names = [name for name in names_by_dir.get(ancestor, ()) if not is_cargo_manifest(name)]
+        if detect_anchor_language(names) is not None:
+            return True
+    return False
+
+
+def _cargo_claimed_dirs(
+    listing: DirListing,
+    cargo_manifests: Mapping[Path, str],
+    root_path: Path,
+) -> frozenset[Path]:
+    workspaces = _cargo_workspaces(cargo_manifests)
+    names_by_dir = dict(listing)
+    return frozenset(
+        dir_path
+        for dir_path, filenames in listing
+        if workspaces
+        and any(is_cargo_manifest(name) for name in filenames)
+        and is_workspace_member(dir_path, workspaces, root_path)
+        and not _foreign_part_between(dir_path, workspaces, names_by_dir)
+    )
+
+
 def _is_bundle_name(name: str) -> bool:
     return any(fnmatch(name, pattern) for pattern in BUNDLE_DIR_GLOBS)
 
@@ -123,24 +173,33 @@ def _anchor_names(
     dir_path: Path,
     filenames: Sequence[str],
     workspaces: Mapping[Path, frozenset[str]],
+    cargo_claimed: frozenset[Path],
     root_path: Path,
 ) -> tuple[str, ...]:
     if _within_bundle(dir_path, root_path):
         return ()
     kinds = _claiming_kinds(dir_path, workspaces)
-    if not kinds:
-        return tuple(filenames)
-    return tuple(name for name in filenames if not is_claimed_manifest(name, kinds))
+    claims_cargo = dir_path in cargo_claimed
+    return tuple(
+        name
+        for name in filenames
+        if not is_claimed_manifest(name, kinds) and not (claims_cargo and is_cargo_manifest(name))
+    )
 
 
-def _discover_potential_parts(listing: DirListing, root_path: Path) -> tuple[PotentialPart, ...]:
+def _discover_potential_parts(
+    listing: DirListing,
+    root_path: Path,
+    cargo_manifests: Mapping[Path, str],
+) -> tuple[PotentialPart, ...]:
     workspaces = _workspace_kinds_by_dir(listing)
+    cargo_claimed = _cargo_claimed_dirs(listing, cargo_manifests, root_path)
     return tuple(
         (dir_path, _find_config_files(dir_path, filenames), language.value)
         for dir_path, filenames in listing
         if (
             language := detect_anchor_language(
-                _anchor_names(dir_path, filenames, workspaces, root_path)
+                _anchor_names(dir_path, filenames, workspaces, cargo_claimed, root_path)
             )
         )
         is not None
@@ -262,8 +321,13 @@ def _build_single_root_tree(root_path: Path, listing: DirListing) -> PartTree:
     )
 
 
-def decide_part_tree(root_path: Path, listing: DirListing) -> PartTree:
-    potential_parts = _discover_potential_parts(listing, root_path)
+def decide_part_tree(
+    root_path: Path,
+    listing: DirListing,
+    *,
+    cargo_manifests: Mapping[Path, str] | None = None,
+) -> PartTree:
+    potential_parts = _discover_potential_parts(listing, root_path, cargo_manifests or {})
     if not potential_parts:
         return _build_single_root_tree(root_path, listing)
 
@@ -315,6 +379,26 @@ def _walk_listing(root_path: Path, exclude_dirs: Collection[str]) -> DirListing:
     return tuple(listing)
 
 
+def _read_manifest(path: Path, root_path: Path) -> str | None:
+    try:
+        if not path.resolve().is_relative_to(root_path):
+            return None
+        with os.fdopen(os.open(path, os.O_RDONLY | os.O_NOFOLLOW), "rb") as handle:
+            data = handle.read(MANIFEST_MAX_BYTES + 1)
+        return None if len(data) > MANIFEST_MAX_BYTES else data.decode("utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def _read_cargo_manifests(listing: DirListing, root_path: Path) -> Mapping[Path, str]:
+    return {
+        dir_path: text
+        for dir_path, filenames in listing
+        for name in filenames
+        if is_cargo_manifest(name) and (text := _read_manifest(dir_path / name, root_path))
+    }
+
+
 def build_part_tree(root_path: Path, extra_excludes: Sequence[str] | None = None) -> PartTree:
     resolved = Path(root_path).resolve()
     if not resolved.is_dir():
@@ -327,4 +411,5 @@ def build_part_tree(root_path: Path, extra_excludes: Sequence[str] | None = None
         msg = f"Root path could not be read: {root_path}"
         raise OSError(msg)
 
-    return decide_part_tree(resolved, listing)
+    manifests = _read_cargo_manifests(listing, resolved)
+    return decide_part_tree(resolved, listing, cargo_manifests=manifests)

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/import-linter.cfg

@@ -11,6 +11,6 @@
   layers =
     partitioning : projects
     parts
-    detection
+    detection | cargo
     defaults
     language

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fluidattacks_core_filesystem"
-version = "15.0.0"
+version = "16.0.0"
 description = "Fluid Attacks Core Filesystem Library"
 authors = [{ name = "Development", email = "development@fluidattacks.com" }]
 license = { text = "MPL-2.0" }

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/ruff.toml

@@ -35,6 +35,9 @@ indent-style = "space"
 skip-magic-trailing-comma = false
 line-ending = "lf"
 
+[lint.isort]
+known-first-party = ["fluidattacks_core"]
+
 [lint.mccabe]
 max-complexity = 8
 

fluidattacks_core_filesystem-16.0.0/tests/test_cargo.py

@@ -0,0 +1,122 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from fluidattacks_core.filesystem.cargo import (
+    CargoWorkspace,
+    is_cargo_manifest,
+    is_workspace_member,
+    parse_cargo_workspace,
+)
+from fluidattacks_core.filesystem.defaults import CARGO_MAX_PATTERNS
+
+_ROOT = Path("/component")
+
+
+def _workspace(members: list[str], exclude: list[str] | None = None) -> CargoWorkspace:
+    text = f"[workspace]\nmembers = {json.dumps(members)}\nexclude = {json.dumps(exclude or [])}"
+    workspace = parse_cargo_workspace(text)
+    assert workspace is not None
+    return workspace
+
+
+def _is_member(path: str, members: list[str], exclude: list[str] | None = None) -> bool:
+    return is_workspace_member(_ROOT / path, {_ROOT: _workspace(members, exclude)}, _ROOT)
+
+
+def test_a_workspace_table_parses_into_path_components_once() -> None:
+    text = '[workspace]\nmembers = ["./crates/*/", "../x", "/abs"]\nexclude = ["crates/old"]'
+
+    assert parse_cargo_workspace(text) == CargoWorkspace(
+        members=(("crates", "*"),), exclude=(("crates", "old"),)
+    )
+    assert parse_cargo_workspace("[workspace]") == CargoWorkspace(members=(), exclude=())
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "x = " + "[" * 5000 + "]" * 5000,
+        "x = " + "9" * 5000,
+        "[workspace",
+        "workspace = 1",
+        '[workspace]\nmembers = "crates/*"',
+        "[workspace]\nmembers = [1]",
+        f"[workspace]\nmembers = {json.dumps(['a'] * (CARGO_MAX_PATTERNS + 1))}",
+        f"[workspace]\nexclude = {json.dumps(['a'] * (CARGO_MAX_PATTERNS + 1))}",
+    ],
+)
+def test_a_hostile_or_malformed_manifest_is_no_workspace(text: str) -> None:
+    assert parse_cargo_workspace(text) is None
+
+
+def test_a_workspace_at_the_pattern_cap_still_parses() -> None:
+    workspace = _workspace(["a"] * CARGO_MAX_PATTERNS)
+
+    assert len(workspace.members) == CARGO_MAX_PATTERNS
+
+
+def test_the_manifest_name_folds_case() -> None:
+    assert is_cargo_manifest("cargo.TOML")
+    assert not is_cargo_manifest("Cargo.lock")
+
+
+@pytest.mark.parametrize(
+    ("pattern", "path", "expected"),
+    [
+        ("crates/*", "crates/domain", True),
+        ("crates/*", "crates/domain/sub", False),
+        ("**/inner", "inner", True),
+        ("**/inner", "a/b/inner", True),
+        ("crate-?", "crate-a", True),
+        ("crate-?", "crate-ab", False),
+        ("crate-[ab]", "crate-b", True),
+        ("crate-[!ab]", "crate-b", False),
+        ("Crates/*", "crates/domain", False),
+    ],
+)
+def test_a_member_pattern_matches_whole_components(
+    pattern: str, path: str, *, expected: bool
+) -> None:
+    assert _is_member(path, [pattern]) is expected
+
+
+def test_many_recursive_wildcards_match_in_linear_time() -> None:
+    assert _is_member("a/x", ["**/" * 3000 + "x"])
+    assert not _is_member("/".join(["d"] * 20), ["/".join(["**"] * 12) + "/zz"])
+
+
+def test_an_exclusion_is_a_literal_path_prefix() -> None:
+    assert not _is_member("crates/old", ["crates/*"], ["crates/old"])
+    assert not _is_member("crates/old", ["crates/*"], ["crates/old/Cargo.toml"])
+    assert _is_member("crates/old", ["crates/*"], ["crates/*"])
+    assert _is_member("crates/old", ["crates/*"], ["crates/ol"])
+
+
+def test_only_a_literal_member_overrides_an_exclusion() -> None:
+    assert not _is_member("crates/old", ["crates/*"], ["crates"])
+    assert _is_member("crates/old", ["crates/*", "crates/old"], ["crates"])
+
+
+def test_an_excluded_crate_is_claimed_by_an_outer_workspace() -> None:
+    workspaces = {
+        _ROOT: _workspace(["tools/gen"]),
+        _ROOT / "tools": _workspace(["*"], ["gen"]),
+    }
+
+    assert is_workspace_member(_ROOT / "tools" / "gen", workspaces, _ROOT)
+
+
+def test_a_workspace_root_and_the_root_are_never_members() -> None:
+    workspaces = {_ROOT: _workspace(["**"]), _ROOT / "nested": _workspace(["inner"])}
+
+    assert not is_workspace_member(_ROOT / "nested", workspaces, _ROOT)
+    assert not is_workspace_member(_ROOT, workspaces, _ROOT)
+    assert is_workspace_member(_ROOT / "nested" / "inner", workspaces, _ROOT)
+
+
+def test_no_workspace_above_the_root_is_consulted() -> None:
+    workspaces = {Path("/"): _workspace(["**"])}
+
+    assert not is_workspace_member(_ROOT / "lib", workspaces, _ROOT)

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/tests/test_partitioning.py

@@ -4,7 +4,11 @@ from pathlib import Path
 import pytest
 
 from fluidattacks_core.filesystem import build_part_tree
-from fluidattacks_core.filesystem.defaults import MANIFEST_MARKERS, TEST_SCAFFOLD_GLOBS
+from fluidattacks_core.filesystem.defaults import (
+    MANIFEST_MARKERS,
+    MANIFEST_MAX_BYTES,
+    TEST_SCAFFOLD_GLOBS,
+)
 from fluidattacks_core.filesystem.partitioning import (
     DirListing,
     PotentialPart,
@@ -17,6 +21,7 @@ from fluidattacks_core.filesystem.partitioning import (
     _is_scaffold_name,
     _normalized_dir_name,
     _owning_part,
+    _read_manifest,
     decide_part_tree,
 )
 
@@ -117,7 +122,7 @@ def test_config_files_are_found_by_name_and_glob() -> None:
 
 
 def test_only_directories_holding_a_manifest_become_parts() -> None:
-    discovered = _discover_potential_parts(_LISTING, _ROOT)
+    discovered = _discover_potential_parts(_LISTING, _ROOT, {})
     assert [(path, language) for path, _, language in discovered] == [
         (_ROOT, "Python"),
         (_ROOT / "web", "JavaScript"),
@@ -125,7 +130,8 @@ def test_only_directories_holding_a_manifest_become_parts() -> None:
 
 
 def test_a_lone_hint_does_not_make_a_potential_part() -> None:
-    assert _discover_potential_parts(((_ROOT / "tools", ("mypy.ini", "tox.ini")),), _ROOT) == ()
+    listing = ((_ROOT / "tools", ("mypy.ini", "tox.ini")),)
+    assert _discover_potential_parts(listing, _ROOT, {}) == ()
 
 
 def test_hierarchy_nests_parts_under_their_nearest_ancestor() -> None:
@@ -352,6 +358,137 @@ def test_a_gradle_module_without_a_settings_file_anchors_alone() -> None:
     assert sorted(tree.parts) == [".", "deployment/acceptance-test"]
 
 
+_CARGO_ROOT = Path("/component")
+
+_CARGO_LISTING = (
+    (_CARGO_ROOT, ("Cargo.toml", "Cargo.lock")),
+    (_CARGO_ROOT / "crates" / "domain", ("Cargo.toml",)),
+    (_CARGO_ROOT / "crates" / "domain" / "src", ("lib.rs",)),
+    (_CARGO_ROOT / "crates" / "shell", ("Cargo.toml",)),
+)
+
+
+def _cargo_parts(listing: DirListing, manifests: dict[Path, str]) -> list[str]:
+    return sorted(decide_part_tree(_CARGO_ROOT, listing, cargo_manifests=manifests).parts)
+
+
+def test_a_cargo_workspace_folds_its_members_into_one_part() -> None:
+    manifests = {_CARGO_ROOT: '[workspace]\nmembers = ["crates/*"]'}
+
+    tree = decide_part_tree(_CARGO_ROOT, _CARGO_LISTING, cargo_manifests=manifests)
+
+    assert sorted(tree.parts) == ["."]
+    root = tree.root
+    assert root is not None
+    assert root.detected_language == "rust"
+    assert Path("crates/domain/src/lib.rs") in root.files
+    assert Path("crates/shell/Cargo.toml") in root.files
+
+
+def test_a_root_package_keeps_a_crate_it_does_not_list() -> None:
+    manifest = '[package]\nname = "app"\n[workspace]\nmembers = ["crates/domain"]'
+
+    assert _cargo_parts(_CARGO_LISTING, {_CARGO_ROOT: manifest}) == [".", "crates/shell"]
+
+
+@pytest.mark.parametrize(
+    "manifest",
+    [
+        '[package]\nname = "app"',
+        "[workspace",
+        "workspace = 1",
+        '[workspace]\nmembers = "crates/*"',
+        "[workspace]\nmembers = [1]",
+        '[workspace]\nmembers = ["crates/*"]\nexclude = "crates/shell"',
+    ],
+)
+def test_a_root_without_a_usable_workspace_changes_nothing(manifest: str) -> None:
+    expected = [".", "crates/domain", "crates/shell"]
+
+    assert _cargo_parts(_CARGO_LISTING, {_CARGO_ROOT: manifest}) == expected
+    assert sorted(decide_part_tree(_CARGO_ROOT, _CARGO_LISTING).parts) == expected
+
+
+def test_a_nested_cargo_workspace_anchors_and_claims_its_own_members() -> None:
+    listing = (
+        (_CARGO_ROOT, ("Cargo.toml",)),
+        (_CARGO_ROOT / "crates" / "nested", ("Cargo.toml",)),
+        (_CARGO_ROOT / "crates" / "nested" / "inner", ("Cargo.toml",)),
+    )
+    manifests = {
+        _CARGO_ROOT: '[workspace]\nmembers = ["crates/*"]',
+        _CARGO_ROOT / "crates" / "nested": '[workspace]\nmembers = ["inner"]',
+    }
+
+    assert _cargo_parts(listing, manifests) == [".", "crates/nested"]
+
+
+def test_a_member_under_a_foreign_part_keeps_its_own_part() -> None:
+    desktop = _CARGO_ROOT / "apps" / "desktop"
+    listing = (
+        (_CARGO_ROOT, ("Cargo.toml",)),
+        (desktop, ("package.json",)),
+        (desktop / "src-tauri", ("Cargo.toml",)),
+    )
+    manifest = '[workspace]\nmembers = ["apps/desktop/src-tauri"]'
+    expected = [".", "apps/desktop", "apps/desktop/src-tauri"]
+
+    assert _cargo_parts(listing, {_CARGO_ROOT: manifest}) == expected
+
+
+def test_a_cargo_workspace_does_not_claim_a_foreign_manifest() -> None:
+    listing = (
+        (_CARGO_ROOT, ("Cargo.toml",)),
+        (_CARGO_ROOT / "crates" / "web", ("Cargo.toml", "package.json")),
+    )
+
+    tree = decide_part_tree(
+        _CARGO_ROOT, listing, cargo_manifests={_CARGO_ROOT: '[workspace]\nmembers = ["crates/*"]'}
+    )
+
+    web = tree.get_part("crates/web")
+    assert web is not None
+    assert web.detected_language == "JavaScript"
+
+
+_WORKSPACE = b'[workspace]\nmembers = ["crates/*"]'
+
+
+def _write_workspace(root: Path, manifest: bytes) -> None:
+    (root / "crates" / "lib").mkdir(parents=True)
+    (root / "crates" / "lib" / "Cargo.toml").write_text('[package]\nname = "lib"')
+    (root / "Cargo.toml").write_bytes(manifest)
+
+
+def test_build_part_tree_reads_a_cargo_workspace_from_disk(tmp_path: Path) -> None:
+    _write_workspace(tmp_path, _WORKSPACE)
+
+    assert sorted(build_part_tree(tmp_path).parts) == ["."]
+
+
+@pytest.mark.parametrize(
+    "manifest",
+    [_WORKSPACE + b"\n#" + b"x" * MANIFEST_MAX_BYTES, b"\xff" + _WORKSPACE],
+)
+def test_an_oversized_or_undecodable_cargo_root_folds_nothing(
+    tmp_path: Path, manifest: bytes
+) -> None:
+    _write_workspace(tmp_path, manifest)
+
+    assert sorted(build_part_tree(tmp_path).parts) == [".", "crates/lib"]
+
+
+@pytest.mark.parametrize("inside", [True, False])
+def test_a_symlinked_manifest_is_never_read(tmp_path: Path, *, inside: bool) -> None:
+    root = tmp_path / "repo"
+    root.mkdir()
+    target = (root if inside else tmp_path) / "real.toml"
+    target.write_bytes(_WORKSPACE)
+    (root / "Cargo.toml").symlink_to(target)
+
+    assert _read_manifest(root / "Cargo.toml", root.resolve()) is None
+
+
 def test_an_xcode_bundle_does_not_anchor_beside_its_project() -> None:
     listing = (
         (_ROOT, ("pubspec.yaml",)),

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/tests/test_projects.py

@@ -273,6 +273,15 @@ def test_no_marker_name_is_excluded_as_an_artifact() -> None:
     assert excluded == []
 
 
+def test_find_projects_still_splits_a_cargo_workspace(tmp_path: Path) -> None:
+    (tmp_path / "lib").mkdir()
+    (tmp_path / "lib" / "Cargo.toml").write_text('[package]\nname = "lib"')
+    (tmp_path / "Cargo.toml").write_text('[workspace]\nmembers = ["lib"]')
+
+    assert _by_path(find_projects(tmp_path), tmp_path.resolve()) == {".": "rust", "lib": "rust"}
+    assert sorted(build_part_tree(tmp_path).parts) == ["."]
+
+
 def test_find_projects_still_splits_a_gradle_workspace(tmp_path: Path) -> None:
     _make(tmp_path, ["settings.gradle", "build.gradle", "mod/build.gradle"])
     root = tmp_path.resolve()

{fluidattacks_core_filesystem-15.0.0 → fluidattacks_core_filesystem-16.0.0}/uv.lock

@@ -178,7 +178,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-filesystem"
-version = "15.0.0"
+version = "16.0.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

fluidattacks_core_filesystem-15.0.0/.envrc

@@ -1 +0,0 @@
-use_flake ".#python311.devShell"

fluidattacks_core_filesystem-15.0.0/.gitignore

@@ -1,9 +0,0 @@
-dist/
-dist-*/
-/.cargo-cache
-target/
-.direnv/
-.venv/
-.vscode/settings.json
-.zed/settings.json
-*.so