smelt-cli 0.1.0__py3-none-any.whl

smelt/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("smelt-cli")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"

smelt/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from smelt.cli import main
+
+sys.exit(main())

smelt/analysis/__init__.py

@@ -0,0 +1,27 @@
+from smelt.analysis.context import AnalysisContext, ChangeSet, FileChange, Index
+from smelt.analysis.files import FileIndex, SourceFile, TestFile
+from smelt.analysis.imports import ImportDetail, ImportIndex, is_stdlib
+from smelt.analysis.parsing import AnalysisError
+from smelt.analysis.roles import RoleIndex
+from smelt.analysis.syntax import ClassInfo, ModuleSyntax, SyntaxIndex
+from smelt.analysis.types import PyrightTypes, TypeIndex
+
+__all__ = [
+    "AnalysisContext",
+    "AnalysisError",
+    "ChangeSet",
+    "ClassInfo",
+    "FileChange",
+    "FileIndex",
+    "ImportDetail",
+    "ImportIndex",
+    "Index",
+    "ModuleSyntax",
+    "PyrightTypes",
+    "RoleIndex",
+    "SourceFile",
+    "SyntaxIndex",
+    "TestFile",
+    "TypeIndex",
+    "is_stdlib",
+]

smelt/analysis/context.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from smelt.analysis.files import FileIndex
+from smelt.analysis.imports import ImportIndex
+from smelt.analysis.parsing import AstCache
+from smelt.analysis.roles import RoleIndex
+from smelt.analysis.syntax import SyntaxIndex
+from smelt.analysis.types import PyrightTypes, TypeIndex
+from smelt.model import ArchitectureModel
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from smelt.config.models import SmeltConfig
+
+
+class Index(StrEnum):
+    FILES = "files"
+    IMPORTS = "imports"
+    SYNTAX = "syntax"
+    ROLES = "roles"
+    TYPES = "types"
+    CHANGES = "changes"
+
+
+@dataclass(frozen=True, slots=True)
+class FileChange:
+    path: str
+    added: int
+    deleted: int
+
+
+@dataclass(frozen=True)
+class ChangeSet:
+    """Files changed against a git base; paths are relative to the project root."""
+
+    files: dict[str, FileChange] = field(default_factory=dict)
+
+    def __contains__(self, path: object) -> bool:
+        return path in self.files
+
+    @property
+    def paths(self) -> frozenset[str]:
+        return frozenset(self.files)
+
+
+class AnalysisContext:
+    def __init__(
+        self,
+        root: Path,
+        config: SmeltConfig,
+        *,
+        changes: ChangeSet | None = None,
+        types: TypeIndex | None = None,
+    ) -> None:
+        self.root = root
+        self.config = config
+        self.changes = changes
+        self._types = types
+
+    @cached_property
+    def types(self) -> TypeIndex | None:
+        """The configured type backend, or None when there is none to be had."""
+        if self._types is not None:
+            return self._types
+        if self.config.analysis.types == "pyright":
+            return PyrightTypes.discover(self.root, self.config)
+        return None
+
+    @cached_property
+    def files(self) -> FileIndex:
+        return FileIndex.discover(self.root, self.config)
+
+    @cached_property
+    def asts(self) -> AstCache:
+        return AstCache(self.files)
+
+    @cached_property
+    def model(self) -> ArchitectureModel:
+        return ArchitectureModel.build(
+            self.config, self.files.sources, self.files.packages
+        )
+
+    @cached_property
+    def imports(self) -> ImportIndex:
+        return ImportIndex.build(self.files, self.asts)
+
+    @cached_property
+    def syntax(self) -> SyntaxIndex:
+        return SyntaxIndex(self.files, self.asts)
+
+    @cached_property
+    def roles(self) -> RoleIndex:
+        return RoleIndex(self.config, self.syntax, self.types)
+
+    def ensure(self, indexes: frozenset[Index]) -> None:
+        """Build the requested indexes up front so failures surface before rules run."""
+        for index in sorted(indexes):
+            if index is Index.TYPES or index is Index.CHANGES:
+                continue
+            getattr(self, index.value)

smelt/analysis/files.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from smelt.config.patterns import path_matches
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+    from pathlib import Path
+
+    from smelt.config.models import SmeltConfig
+
+_SKIP_DIRS = frozenset({"__pycache__", ".git", ".venv", "venv", "node_modules"})
+
+
+@dataclass(frozen=True, slots=True)
+class SourceFile:
+    module: str
+    path: str  # POSIX, relative to the project root
+    absolute: Path
+    is_package: bool  # an ``__init__.py``
+
+
+@dataclass(frozen=True, slots=True)
+class TestFile:
+    path: str
+    absolute: Path
+    test_root: str
+
+    @property
+    def name(self) -> str:
+        return self.path.rsplit("/", 1)[-1]
+
+    @property
+    def is_conftest(self) -> bool:
+        return self.name == "conftest.py"
+
+
+@dataclass(slots=True)
+class PackageDir:
+    module: str
+    path: str
+    source_root: str
+    has_init: bool
+
+
+@dataclass
+class FileIndex:
+    root: Path
+    config: SmeltConfig
+    sources: dict[str, SourceFile] = field(default_factory=dict)
+    packages: dict[str, PackageDir] = field(default_factory=dict)
+    tests: dict[str, TestFile] = field(default_factory=dict)
+    missing_root_packages: list[str] = field(default_factory=list)
+    _text_cache: dict[str, str] = field(default_factory=dict, repr=False)
+
+    @classmethod
+    def discover(cls, root: Path, config: SmeltConfig) -> FileIndex:
+        index = cls(root=root, config=config)
+        index._discover_sources()
+        index._discover_tests()
+        return index
+
+    def is_excluded(self, path: str) -> bool:
+        return any(
+            path_matches(pattern, path) for pattern in self.config.project.exclude
+        )
+
+    def relative(self, path: Path) -> str:
+        try:
+            return path.resolve().relative_to(self.root.resolve()).as_posix()
+        except ValueError:
+            return path.as_posix()
+
+    def _discover_sources(self) -> None:
+        project = self.config.project
+        for package in project.root_packages:
+            found = False
+            for source_root in project.source_roots:
+                directory = self.root / source_root / package
+                if directory.is_dir():
+                    found = True
+                    self._walk_package(directory, package, source_root)
+                    break
+            if not found:
+                self.missing_root_packages.append(package)
+
+    def _walk_package(self, directory: Path, module: str, source_root: str) -> None:
+        rel_dir = self.relative(directory)
+        if self.is_excluded(rel_dir):
+            return
+        init = directory / "__init__.py"
+        self.packages[module] = PackageDir(module, rel_dir, source_root, init.is_file())
+        for entry in sorted(directory.iterdir(), key=lambda p: p.name):
+            if entry.is_dir():
+                if entry.name in _SKIP_DIRS or not entry.name.isidentifier():
+                    continue
+                if _contains_python(entry):
+                    self._walk_package(entry, f"{module}.{entry.name}", source_root)
+            elif entry.suffix == ".py" and entry.is_file():
+                rel = self.relative(entry)
+                if self.is_excluded(rel):
+                    continue
+                if entry.name == "__init__.py":
+                    self.sources[module] = SourceFile(
+                        module, rel, entry, is_package=True
+                    )
+                elif entry.stem.isidentifier():
+                    name = f"{module}.{entry.stem}"
+                    self.sources[name] = SourceFile(name, rel, entry, is_package=False)
+
+    def _discover_tests(self) -> None:
+        source_paths = {source.path for source in self.sources.values()}
+        for test_root in self.config.project.test_roots:
+            directory = self.root / test_root
+            if not directory.is_dir():
+                continue
+            for path in sorted(_python_files(directory)):
+                rel = self.relative(path)
+                if rel in source_paths or self.is_excluded(rel):
+                    continue
+                name = path.name
+                if (
+                    name == "conftest.py"
+                    or name.startswith("test_")
+                    or path.stem.endswith("_test")
+                ):
+                    self.tests[rel] = TestFile(rel, path, test_root.strip("/"))
+
+    @cached_property
+    def by_path(self) -> dict[str, SourceFile]:
+        return {source.path: source for source in self.sources.values()}
+
+    def source_for_path(self, path: str) -> SourceFile | None:
+        return self.by_path.get(path)
+
+    def path_for_module(self, module: str) -> str | None:
+        source = self.sources.get(module)
+        if source is not None:
+            return source.path
+        package = self.packages.get(module)
+        return package.path if package else None
+
+    def read_text(self, path: str) -> str:
+        cached = self._text_cache.get(path)
+        if cached is None:
+            cached = (self.root / path).read_text(encoding="utf-8", errors="replace")
+            self._text_cache[path] = cached
+        return cached
+
+    def lines(self, path: str) -> list[str]:
+        return self.read_text(path).splitlines()
+
+    def line(self, path: str, number: int) -> str:
+        lines = self.lines(path)
+        return lines[number - 1] if 0 < number <= len(lines) else ""
+
+    def sha256(self, path: str) -> str:
+        return hashlib.sha256(self.read_text(path).encode()).hexdigest()
+
+    def size(self, path: str) -> int:
+        return len(self.read_text(path).encode())
+
+    def all_python_paths(self) -> Iterator[str]:
+        yield from (source.path for source in self.sources.values())
+        yield from self.tests
+
+    def source_root_dir(self, module: str) -> str | None:
+        root = module.split(".", maxsplit=1)[0]
+        package = self.packages.get(root)
+        return package.source_root if package else None
+
+    def module_to_path(self, module: str, *, package: bool = False) -> str:
+        """The expected repo-relative path for ``module``, whether or not it exists."""
+        root = (
+            self.source_root_dir(module)
+            or (self.config.project.source_roots or ["."])[0]
+        )
+        parts = [p for p in root.strip("/").split("/") if p and p != "."]
+        parts.extend(module.split("."))
+        return "/".join(parts) + ("/" if package else ".py")
+
+
+def _contains_python(directory: Path) -> bool:
+    return any(True for _ in _python_files(directory))
+
+
+def _python_files(directory: Path) -> Iterable[Path]:
+    for entry in directory.iterdir():
+        if entry.is_dir():
+            if entry.name in _SKIP_DIRS or entry.name.startswith("."):
+                continue
+            yield from _python_files(entry)
+        elif entry.suffix == ".py":
+            yield entry

smelt/analysis/graphs.py

@@ -0,0 +1,77 @@
+from collections import deque
+from collections.abc import Hashable, Mapping, Set
+
+
+def strongly_connected_components[T: Hashable](
+    adjacency: Mapping[T, Set[T]],
+) -> list[set[T]]:
+    """Tarjan's algorithm, iterative so deep graphs don't hit the recursion limit."""
+    index_of: dict[T, int] = {}
+    lowlink: dict[T, int] = {}
+    on_stack: set[T] = set()
+    stack: list[T] = []
+    components: list[set[T]] = []
+    counter = 0
+    nodes = set(adjacency) | {n for targets in adjacency.values() for n in targets}
+
+    for start in sorted(nodes, key=str):
+        if start in index_of:
+            continue
+        work: list[tuple[T, list[T]]] = [
+            (start, sorted(adjacency.get(start, ()), key=str))
+        ]
+        index_of[start] = lowlink[start] = counter
+        counter += 1
+        stack.append(start)
+        on_stack.add(start)
+        while work:
+            node, children = work[-1]
+            if children:
+                child = children.pop(0)
+                if child not in index_of:
+                    index_of[child] = lowlink[child] = counter
+                    counter += 1
+                    stack.append(child)
+                    on_stack.add(child)
+                    work.append((child, sorted(adjacency.get(child, ()), key=str)))
+                elif child in on_stack:
+                    lowlink[node] = min(lowlink[node], index_of[child])
+                continue
+            work.pop()
+            if work:
+                parent = work[-1][0]
+                lowlink[parent] = min(lowlink[parent], lowlink[node])
+            if lowlink[node] == index_of[node]:
+                component: set[T] = set()
+                while True:
+                    member = stack.pop()
+                    on_stack.discard(member)
+                    component.add(member)
+                    if member == node:
+                        break
+                components.append(component)
+    return components
+
+
+def shortest_cycle[T: Hashable](
+    start: T, adjacency: Mapping[T, Set[T]], within: Set[T]
+) -> list[T] | None:
+    """Shortest path ``start -> ... -> start`` using only nodes in ``within``."""
+    previous: dict[T, T] = {}
+    queue: deque[T] = deque([start])
+    visited: set[T] = set()
+    while queue:
+        node = queue.popleft()
+        for child in sorted(adjacency.get(node, ()), key=str):
+            if child not in within:
+                continue
+            if child == start:
+                path = [node]
+                while path[-1] != start:
+                    path.append(previous[path[-1]])
+                return [*reversed(path), start]
+            if child not in visited:
+                visited.add(child)
+                previous[child] = node
+                queue.append(child)
+    return None