feat(deps): identify circular brick dependencies (#395)

* feat(deps): identify circular dependencies

* bump Poetry plugin to 1.45.0

* bump CLI to 1.38.0

Author: DavidVujic

components/polylith/commands/deps.py

@@ -44,8 +44,23 @@ def run(root: Path, ns: str, options: dict):
 
     imports = get_imports(root, ns, bricks)
 
+    bricks_deps = {
+        b: deps.calculate_brick_deps(b, bricks, imports)
+        for b in set().union(*bricks.values())
+    }
+
+    circular_bricks = deps.find_bricks_with_circular_dependencies(bricks_deps)
+
     if brick and imports.get(brick):
-        deps.print_brick_deps(brick, bricks, imports, options)
+        brick_deps = bricks_deps[brick]
+        circular_deps = circular_bricks.get(brick)
+
+        deps.print_brick_deps(brick, bricks, brick_deps, options)
+
+        if circular_deps:
+            deps.print_brick_with_circular_deps(brick, circular_deps, bricks)
+
         return
 
     deps.print_deps(bricks, imports, options)
+    deps.print_bricks_with_circular_deps(circular_bricks, bricks)

components/polylith/commands/diff.py

@@ -28,7 +28,7 @@ def flatten_dependent_bricks(
     changed_bricks: Set[str], bases: Set[str], components: Set[str], import_data: dict
 ) -> Set[str]:
     matrix = [
-        deps.report.sorted_used_by(brick, bases, components, import_data)
+        deps.core.sorted_used_by(brick, bases, components, import_data)
         for brick in changed_bricks
     ]
 

components/polylith/deps/__init__.py

@@ -1,4 +1,21 @@
-from polylith.deps.core import get_brick_imports
-from polylith.deps.report import print_brick_deps, print_deps
+from polylith.deps.core import (
+    calculate_brick_deps,
+    find_bricks_with_circular_dependencies,
+    get_brick_imports,
+)
+from polylith.deps.report import (
+    print_brick_deps,
+    print_brick_with_circular_deps,
+    print_bricks_with_circular_deps,
+    print_deps,
+)
 
-__all__ = ["get_brick_imports", "print_brick_deps", "print_deps"]
+__all__ = [
+    "calculate_brick_deps",
+    "find_bricks_with_circular_dependencies",
+    "get_brick_imports",
+    "print_brick_deps",
+    "print_brick_with_circular_deps",
+    "print_bricks_with_circular_deps",
+    "print_deps",
+]

components/polylith/deps/core.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Set
+from typing import List, Set
 
 from polylith import check, workspace
 
@@ -21,3 +21,53 @@ def get_brick_imports(
             root, ns, brick_imports_in_components
         ),
     }
+
+
+def without(key: str, bricks: Set[str]) -> Set[str]:
+    return {b for b in bricks if b != key}
+
+
+def sorted_usings(usings: Set[str], bases: Set[str], components: Set[str]) -> List[str]:
+    usings_bases = sorted({b for b in usings if b in bases})
+    usings_components = sorted({c for c in usings if c in components})
+
+    return usings_components + usings_bases
+
+
+def sorted_used_by(
+    brick: str, bases: Set[str], components: Set[str], import_data: dict
+) -> List[str]:
+    brick_used_by = without(brick, {k for k, v in import_data.items() if brick in v})
+
+    return sorted_usings(brick_used_by, bases, components)
+
+
+def sorted_uses(
+    brick: str, bases: Set[str], components: Set[str], import_data: dict
+) -> List[str]:
+    brick_uses = without(brick, import_data.get(brick, set()))
+
+    return sorted_usings(brick_uses, bases, components)
+
+
+def calculate_brick_deps(brick: str, bricks: dict, import_data: dict) -> dict:
+    bases = bricks["bases"]
+    components = bricks["components"]
+
+    brick_used_by = sorted_used_by(brick, bases, components, import_data)
+    brick_uses = sorted_uses(brick, bases, components, import_data)
+
+    return {"used_by": brick_used_by, "uses": brick_uses}
+
+
+def find_intersection_for_usings(usings: dict) -> Set[str]:
+    uses = set(usings["uses"])
+    used_by = set(usings["used_by"])
+
+    return uses.intersection(used_by)
+
+
+def find_bricks_with_circular_dependencies(bricks_deps: dict) -> dict:
+    res = {k: find_intersection_for_usings(v) for k, v in bricks_deps.items()}
+
+    return {k: v for k, v in sorted(res.items()) if v}

components/polylith/deps/report.py

@@ -102,45 +102,17 @@ def print_deps(bricks: dict, import_data: dict, options: dict):
         output.save(table, options, "deps")
 
 
-def without(key: str, bricks: Set[str]) -> Set[str]:
-    return {b for b in bricks if b != key}
-
-
-def sorted_usings(usings: Set[str], bases: Set[str], components: Set[str]) -> List[str]:
-    usings_bases = sorted({b for b in usings if b in bases})
-    usings_components = sorted({c for c in usings if c in components})
-
-    return usings_components + usings_bases
-
-
-def sorted_used_by(
-    brick: str, bases: Set[str], components: Set[str], import_data: dict
-) -> List[str]:
-    brick_used_by = without(brick, {k for k, v in import_data.items() if brick in v})
-
-    return sorted_usings(brick_used_by, bases, components)
-
-
-def sorted_uses(
-    brick: str, bases: Set[str], components: Set[str], import_data: dict
-) -> List[str]:
-    brick_uses = without(brick, {b for b in import_data[brick]})
-
-    return sorted_usings(brick_uses, bases, components)
-
-
 def calculate_tag(brick: str, bases: Set[str]) -> str:
     return "base" if brick in bases else "comp"
 
 
-def print_brick_deps(brick: str, bricks: dict, import_data: dict, options: dict):
+def print_brick_deps(brick: str, bricks: dict, brick_deps: dict, options: dict):
     bases = bricks["bases"]
-    components = bricks["components"]
 
     save = options.get("save", False)
 
-    brick_used_by = sorted_used_by(brick, bases, components, import_data)
-    brick_uses = sorted_uses(brick, bases, components, import_data)
+    brick_used_by = brick_deps["used_by"]
+    brick_uses = brick_deps["uses"]
 
     tag = calculate_tag(brick, bases)
 
@@ -170,3 +142,24 @@ def print_brick_deps(brick: str, bricks: dict, import_data: dict, options: dict)
 
     if save:
         output.save(table, options, f"deps_{brick}")
+
+
+def print_brick_with_circular_deps(brick: str, deps: Set[str], bricks: dict) -> None:
+    bases = bricks["bases"]
+
+    console = Console(theme=theme.poly_theme)
+
+    tag = calculate_tag(brick, bases)
+
+    with_tags = [f"[{calculate_tag(name, bases)}]{name}" for name in sorted(deps)]
+    others = "[data],[/] ".join(with_tags)
+
+    prefix = ":information:"
+    message = f"[{tag}]{brick}[/] [data]is used by[/] {others} [data]and is also uses[/] {others}[data].[/]"
+
+    console.print(f"{prefix} {message}", overflow="ellipsis")
+
+
+def print_bricks_with_circular_deps(circular_bricks: dict, bricks: dict) -> None:
+    for brick, deps in circular_bricks.items():
+        print_brick_with_circular_deps(brick, deps, bricks)

projects/poetry_polylith_plugin/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "poetry-polylith-plugin"
-version = "1.44.0"
+version = "1.45.0"
 description = "A Poetry plugin that adds tooling support for the Polylith Architecture"
 authors = ["David Vujic"]
 homepage = "https://davidvujic.github.io/python-polylith-docs/"

projects/polylith_cli/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "polylith-cli"
-version = "1.37.0"
+version = "1.38.0"
 description = "Python tooling support for the Polylith Architecture"
 authors = ['David Vujic']
 homepage = "https://davidvujic.github.io/python-polylith-docs/"

test/components/polylith/deps/test_deps_core.py

@@ -0,0 +1,35 @@
+from polylith.deps.core import (
+    calculate_brick_deps,
+    find_bricks_with_circular_dependencies,
+)
+
+
+def test_calculate_brick_deps() -> None:
+    bricks = {"bases": {"base"}, "components": {"one", "two", "three", "four"}}
+
+    imports = {
+        "base": {"base", "one"},
+        "one": {"one", "four"},
+        "two": {"two"},
+        "three": {"three", "one"},
+        "four": {"four", "two"},
+    }
+
+    res = calculate_brick_deps("one", bricks, imports)
+
+    assert sorted(res["used_by"]) == ["base", "three"]
+    assert sorted(res["uses"]) == ["four"]
+
+
+def test_find_bricks_with_circular_dependencies() -> None:
+    deps = {
+        "base": {"used_by": [], "uses": ["one", "four"]},
+        "one": {"used_by": ["two", "three"], "uses": ["three"]},
+        "two": {"used_by": "three", "uses": []},
+        "three": {"used_by": ["one"], "uses": ["one", "two"]},
+        "four": {"used_by": ["base"], "uses": ["two"]},
+    }
+
+    res = find_bricks_with_circular_dependencies(deps)
+
+    assert res == {"one": {"three"}, "three": {"one"}}