fluidattacks_core_filesystem 12.0.0__tar.gz → 14.0.0__tar.gz

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/.gitignore

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

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/PKG-INFO

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

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/fluidattacks_core/filesystem/defaults.py

@@ -23,6 +23,22 @@ class MarkerSet(TypedDict):
     globs: list[str]
 
 
+class WorkspaceSpec(TypedDict):
+    declares: frozenset[str]
+    claims: frozenset[str]
+
+
+BUNDLE_DIR_GLOBS = ["*.xcodeproj", "*.xcworkspace"]
+
+
+WORKSPACE_MARKERS: dict[str, WorkspaceSpec] = {
+    "gradle": {
+        "declares": frozenset({"settings.gradle", "settings.gradle.kts"}),
+        "claims": frozenset({"build.gradle", "build.gradle.kts"}),
+    },
+}
+
+
 CONFIG_MARKERS: dict[Language, MarkerSet] = {
     Language.Java: {
         "names": {

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/fluidattacks_core/filesystem/detection.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from fnmatch import fnmatch
 from typing import TYPE_CHECKING
 
-from .defaults import CONFIG_MARKERS, MANIFEST_MARKERS, MarkerSet
+from .defaults import CONFIG_MARKERS, MANIFEST_MARKERS, WORKSPACE_MARKERS, MarkerSet
 from .language import Language
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Collection, Iterable
 
 __all__ = ["detect_anchor_language", "detect_languages_in_dir", "is_config_marker"]
 
@@ -17,6 +17,14 @@ _FOLDED_MARKER_NAMES = frozenset(
 
 _MARKER_GLOBS = tuple(pat for markers in CONFIG_MARKERS.values() for pat in markers["globs"])
 
+_FOLDED_WORKSPACES = {
+    kind: (
+        frozenset(name.casefold() for name in spec["declares"]),
+        frozenset(name.casefold() for name in spec["claims"]),
+    )
+    for kind, spec in WORKSPACE_MARKERS.items()
+}
+
 _FOLDED_MANIFESTS = {
     language: frozenset(name.casefold() for name in names)
     for language, names in MANIFEST_MARKERS.items()
@@ -112,3 +120,15 @@ def detect_anchor_language(files: Iterable[str]) -> Language | None:
         sorted(anchors, key=lambda language: language.value)
     )
     return ranked[0] if len(ranked) == 1 else Language.Unknown
+
+
+def declared_workspaces(files: Iterable[str]) -> frozenset[str]:
+    folded = {name.casefold() for name in files}
+    return frozenset(
+        kind for kind, (declares, _) in _FOLDED_WORKSPACES.items() if declares & folded
+    )
+
+
+def is_claimed_manifest(name: str, kinds: Collection[str]) -> bool:
+    folded = name.casefold()
+    return any(folded in _FOLDED_WORKSPACES[kind][1] for kind in kinds)

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/fluidattacks_core/filesystem/partitioning.py

@@ -9,8 +9,14 @@ from fnmatch import fnmatch
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from .defaults import EXTENDED_EXCLUDE_DIRS
-from .detection import detect_anchor_language, detect_languages_in_dir, is_config_marker
+from .defaults import BUNDLE_DIR_GLOBS, EXTENDED_EXCLUDE_DIRS
+from .detection import (
+    declared_workspaces,
+    detect_anchor_language,
+    detect_languages_in_dir,
+    is_claimed_manifest,
+    is_config_marker,
+)
 from .parts import Part, PartIdentity, PartTree
 
 if TYPE_CHECKING:
@@ -63,11 +69,63 @@ def _root_filenames(listing: DirListing, root_path: Path) -> tuple[str, ...]:
     return ()
 
 
-def _discover_potential_parts(listing: DirListing) -> tuple[PotentialPart, ...]:
+def _workspace_kinds_by_dir(listing: DirListing) -> Mapping[Path, frozenset[str]]:
+    return {
+        dir_path: kinds
+        for dir_path, filenames in listing
+        if (kinds := declared_workspaces(filenames))
+    }
+
+
+def _claiming_kinds(dir_path: Path, workspaces: Mapping[Path, frozenset[str]]) -> frozenset[str]:
+    kinds: set[str] = set()
+    current = dir_path
+    while current != current.parent:
+        current = current.parent
+        kinds.update(workspaces.get(current, frozenset()))
+    return frozenset(kinds)
+
+
+def _is_bundle_name(name: str) -> bool:
+    return any(fnmatch(name, pattern) for pattern in BUNDLE_DIR_GLOBS)
+
+
+def _within_bundle(dir_path: Path, root_path: Path) -> bool:
+    current = dir_path
+    while current != root_path:
+        if _is_bundle_name(current.name):
+            return True
+        if current == current.parent:
+            return False
+        current = current.parent
+    return False
+
+
+def _anchor_names(
+    dir_path: Path,
+    filenames: Sequence[str],
+    workspaces: Mapping[Path, frozenset[str]],
+    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))
+
+
+def _discover_potential_parts(listing: DirListing, root_path: Path) -> tuple[PotentialPart, ...]:
+    workspaces = _workspace_kinds_by_dir(listing)
     return tuple(
         (dir_path, _find_config_files(dir_path, filenames), language.value)
         for dir_path, filenames in listing
-        if (language := detect_anchor_language(filenames)) is not None
+        if (
+            language := detect_anchor_language(
+                _anchor_names(dir_path, filenames, workspaces, root_path)
+            )
+        )
+        is not None
     )
 
 
@@ -187,7 +245,7 @@ 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)
+    potential_parts = _discover_potential_parts(listing, root_path)
     if not potential_parts:
         return _build_single_root_tree(root_path, listing)
 

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/import-linter.cfg

@@ -1,16 +1,7 @@
 [importlinter]
-  root_package = fluidattacks_core
+  root_package = fluidattacks_core.filesystem
   include_external_packages = True
 
-[importlinter:contract:portion]
-  name = Single Portion
-  type = layers
-  containers =
-    fluidattacks_core
-  exhaustive = true
-  layers =
-    filesystem
-
 [importlinter:contract:dag]
   name = Direct Acyclic Graph
   type = layers

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/pyproject.toml

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

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/tests/test_partitioning.py

@@ -5,6 +5,7 @@ import pytest
 
 from fluidattacks_core.filesystem import build_part_tree
 from fluidattacks_core.filesystem.partitioning import (
+    DirListing,
     PotentialPart,
     _assign_files_to_parts,
     _build_hierarchy,
@@ -28,6 +29,17 @@ _LISTING = (
 )
 
 
+_GRADLE_ROOT = Path("/service")
+
+_GRADLE_MODULES = (
+    "applications/app-service",
+    "domain/model",
+    "domain/usecase",
+    "infrastructure/driven-adapters/rest-consumer",
+    "infrastructure/entry-points/reactive-web",
+)
+
+
 def test_part_names_are_posix_relative_paths() -> None:
     assert _generate_part_name(_ROOT, _ROOT) == "."
     assert _generate_part_name(_ROOT / "web", _ROOT) == "web"
@@ -41,7 +53,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)
+    discovered = _discover_potential_parts(_LISTING, _ROOT)
     assert [(path, language) for path, _, language in discovered] == [
         (_ROOT, "Python"),
         (_ROOT / "web", "JavaScript"),
@@ -49,7 +61,7 @@ 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")),)) == ()
+    assert _discover_potential_parts(((_ROOT / "tools", ("mypy.ini", "tox.ini")),), _ROOT) == ()
 
 
 def test_hierarchy_nests_parts_under_their_nearest_ancestor() -> None:
@@ -189,6 +201,126 @@ def test_part_names_stay_unique_for_nested_directories() -> None:
     assert sorted(names) == [".", "a/svc", "b/svc"]
 
 
+def _gradle_listing(suffix: str) -> DirListing:
+    return (
+        (_GRADLE_ROOT, (f"settings{suffix}", f"build{suffix}", "gradlew")),
+        *(
+            (_GRADLE_ROOT.joinpath(*module.split("/")), (f"build{suffix}",))
+            for module in _GRADLE_MODULES
+        ),
+    )
+
+
+def test_a_settings_file_claims_every_subproject_manifest() -> None:
+    tree = decide_part_tree(_GRADLE_ROOT, _gradle_listing(".gradle"))
+
+    assert sorted(tree.parts) == ["."]
+    assert tree.children_map["."] == ()
+    root = tree.root
+    assert root is not None
+    assert root.detected_language == "Java"
+    assert Path("domain/model/build.gradle") in root.files
+
+
+def test_the_kotlin_gradle_dsl_collapses_the_same_way() -> None:
+    tree = decide_part_tree(_GRADLE_ROOT, _gradle_listing(".gradle.kts"))
+
+    assert sorted(tree.parts) == ["."]
+    root = tree.root
+    assert root is not None
+    assert root.detected_language == "Kotlin"
+
+
+def test_a_settings_file_claims_the_other_gradle_dsl() -> None:
+    listing = (
+        (_GRADLE_ROOT, ("settings.gradle",)),
+        (_GRADLE_ROOT / "mod", ("build.gradle.kts",)),
+    )
+
+    assert sorted(decide_part_tree(_GRADLE_ROOT, listing).parts) == ["."]
+
+
+def test_a_nested_workspace_anchors_but_its_modules_do_not() -> None:
+    listing = (
+        (_GRADLE_ROOT, ("settings.gradle",)),
+        (_GRADLE_ROOT / "sub", ("settings.gradle", "build.gradle")),
+        (_GRADLE_ROOT / "sub" / "mod", ("build.gradle",)),
+    )
+
+    assert sorted(decide_part_tree(_GRADLE_ROOT, listing).parts) == [".", "sub"]
+
+
+def test_a_claimed_directory_with_its_own_settings_still_anchors() -> None:
+    listing = (
+        (_GRADLE_ROOT, ("settings.gradle", "build.gradle")),
+        (_GRADLE_ROOT / "mod", ("build.gradle",)),
+        (_GRADLE_ROOT / "deployment" / "acceptance-test", ("settings.gradle", "build.gradle")),
+    )
+
+    assert sorted(decide_part_tree(_GRADLE_ROOT, listing).parts) == [
+        ".",
+        "deployment/acceptance-test",
+    ]
+
+
+def test_a_workspace_does_not_claim_a_foreign_manifest() -> None:
+    listing = (
+        (_GRADLE_ROOT, ("settings.gradle", "build.gradle")),
+        (_GRADLE_ROOT / "frontend", ("build.gradle", "package.json")),
+    )
+
+    tree = decide_part_tree(_GRADLE_ROOT, listing)
+
+    assert sorted(tree.parts) == [".", "frontend"]
+    frontend = tree.get_part("frontend")
+    assert frontend is not None
+    assert frontend.detected_language == "JavaScript"
+
+
+def test_a_gradle_module_without_a_settings_file_anchors_alone() -> None:
+    listing = (
+        (_GRADLE_ROOT, ("README",)),
+        (_GRADLE_ROOT / "deployment" / "acceptance-test", ("build.gradle",)),
+    )
+
+    tree = decide_part_tree(_GRADLE_ROOT, listing)
+
+    assert sorted(tree.parts) == [".", "deployment/acceptance-test"]
+
+
+def test_an_xcode_bundle_does_not_anchor_beside_its_project() -> None:
+    listing = (
+        (_ROOT, ("pubspec.yaml",)),
+        (_ROOT / "app" / "ios", ("Podfile",)),
+        (_ROOT / "app" / "ios" / "Runner.xcodeproj", ("project.pbxproj",)),
+        (_ROOT / "app" / "ios" / "Runner.xcworkspace", ("project.pbxproj",)),
+    )
+
+    assert sorted(decide_part_tree(_ROOT, listing).parts) == [".", "app/ios"]
+
+
+def test_a_manifest_nested_inside_a_bundle_does_not_anchor() -> None:
+    listing = (
+        (_ROOT, ("Podfile",)),
+        (_ROOT / "Runner.xcodeproj", ("project.pbxproj",)),
+        (_ROOT / "Runner.xcodeproj" / "project.xcworkspace", ("Package.swift",)),
+    )
+
+    assert sorted(decide_part_tree(_ROOT, listing).parts) == ["."]
+
+
+def test_a_root_named_like_a_bundle_still_anchors() -> None:
+    root = Path("/Thing.xcodeproj")
+
+    assert sorted(decide_part_tree(root, ((root, ("project.pbxproj",)),)).parts) == ["."]
+
+
+def test_a_swift_package_outside_a_bundle_still_anchors() -> None:
+    listing = ((_ROOT, ("README",)), (_ROOT / "lib", ("Package.swift",)))
+
+    assert sorted(decide_part_tree(_ROOT, listing).parts) == [".", "lib"]
+
+
 def _write(root: Path, files: list[str]) -> None:
     for name in files:
         path = root / name

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/tests/test_projects.py

@@ -6,6 +6,7 @@ import pytest
 
 from fluidattacks_core.filesystem import (
     Language,
+    build_part_tree,
     detect_root_language,
     find_parent_project,
     find_projects,
@@ -270,3 +271,12 @@ def test_no_marker_name_is_excluded_as_an_artifact() -> None:
         if any(fnmatch(name, pat) for pat in EXCLUDE_FILES)
     ]
     assert excluded == []
+
+
+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()
+
+    assert _by_path(find_projects(tmp_path), root) == {".": "Java", "mod": "Java"}
+    assert find_parent_project(root / "mod" / "build.gradle", root) == (root / "mod", "Java")
+    assert sorted(build_part_tree(tmp_path).parts) == ["."]

{fluidattacks_core_filesystem-12.0.0 → fluidattacks_core_filesystem-14.0.0}/uv.lock

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