python-dependency-linter 0.3.0__tar.gz → 0.5.0__tar.gz

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.4.0] - 2026-03-30
+
+### Bug Fixes
+
+- Use fnmatch for include/exclude pattern matching (#15)
+
+### Features
+
+- Remove --project-root, auto-detect from config file location (#14)
+## [0.3.0] - 2026-03-30
+
+### Bug Fixes
+
+- Use exit code 2 for config file not found (#11)
+
+### Documentation
+
+- Add CONTRIBUTING.md and CLAUDE.md
+- Add PR title convention to template and CONTRIBUTING.md
+- Add release process to CONTRIBUTING.md and /release skill
+
+### Features
+
+- Resolve relative imports to absolute module names (#10)
+- Add include/exclude file filtering options (#12)
+
+### Miscellaneous
+
+- Add /commit skill for Claude Code
+- Add uv.lock for reproducible builds
 ## [0.2.0] - 2026-03-30
 
 ### Documentation

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-dependency-linter
-Version: 0.3.0
+Version: 0.5.0
 Summary: A dependency linter for Python projects
 License-Expression: MIT
 License-File: LICENSE
@@ -127,25 +127,30 @@ rules:
 
 Isolate domain from infrastructure. Ports (interfaces) live in domain, adapters depend on domain but not vice versa.
 
+Using named captures (`{context}`), you can enforce that each bounded context only depends on its own domain — not other contexts' domains:
+
 ```yaml
 rules:
   - name: domain-no-infra
-    modules: contexts.*.domain
+    modules: contexts.{context}.domain
     allow:
       standard_library: [dataclasses, typing, abc]
       third_party: []
-      local: [contexts.*.domain]
+      local: [contexts.{context}.domain, shared.domain]
 
   - name: adapters-depend-on-domain
-    modules: contexts.*.adapters
+    modules: contexts.{context}.adapters
     allow:
       standard_library: ["*"]
       third_party: ["*"]
       local:
-        - contexts.*.adapters
-        - contexts.*.domain
+        - contexts.{context}.adapters
+        - contexts.{context}.domain
+        - shared
 ```
 
+With `{context}`, `contexts.boards.domain` can only import from `contexts.boards.domain` and `shared.domain` — not from `contexts.auth.domain`. See [Named Capture](#named-capture) for details.
+
 ## Configuration
 
 ### Include / Exclude
@@ -247,6 +252,35 @@ modules: contexts.*.domain  # matches contexts.boards.domain, contexts.auth.doma
 modules: contexts.**.domain  # matches contexts.boards.domain, contexts.boards.sub.domain, ...
 ```
 
+### Named Capture
+
+`{name}` captures a single level (like `*`) and allows back-referencing the captured value in `allow` and `deny`:
+
+```yaml
+rules:
+  - name: domain-isolation
+    modules: contexts.{context}.domain
+    allow:
+      local: [contexts.{context}.domain, shared.domain]
+```
+
+When this rule matches `contexts.boards.domain`, `{context}` captures `"boards"`. The `allow` pattern `contexts.{context}.domain` resolves to `contexts.boards.domain`, so only the same context's domain is allowed.
+
+You can use multiple captures in a single rule:
+
+```yaml
+rules:
+  - name: bounded-context-layers
+    modules: contexts.{context}.{layer}
+    allow:
+      local:
+        - contexts.{context}.{layer}
+        - contexts.{context}.domain
+        - shared
+```
+
+Named captures coexist with `*` and `**` wildcards. `{name}` always matches exactly one level.
+
 ### Submodule Matching
 
 When a pattern is used in `allow` or `deny`, it also matches submodules of the matched module. For example:
@@ -309,14 +343,11 @@ third_party = ["boto3"]
 ## CLI
 
 ```bash
-# Check with default config (.python-dependency-linter.yaml)
+# Check with auto-discovered config (searches upward from cwd)
 pdl check
 
-# Specify config file
+# Specify config file (project root = config file's parent directory)
 pdl check --config path/to/config.yaml
-
-# Specify project root
-pdl check --project-root path/to/project
 ```
 
 Exit codes:
@@ -325,10 +356,10 @@ Exit codes:
 - `1` — Violations found
 - `2` — Config file not found
 
-If no `--config` is given, the tool looks for `.python-dependency-linter.yaml` in the current directory. If the config file does not exist, the tool prints an error and exits with code `2`:
+If no `--config` is given, the tool searches upward from the current directory for `.python-dependency-linter.yaml` or `pyproject.toml` (with `[tool.python-dependency-linter]`). The config file's parent directory is used as the project root. If no config file is found, the tool prints an error and exits with code `2`:
 
 ```
-Error: Config file not found: .python-dependency-linter.yaml
+Error: Config file not found. Create .python-dependency-linter.yaml or configure [tool.python-dependency-linter] in pyproject.toml.
 ```
 
 ## Pre-commit
@@ -342,14 +373,14 @@ Add to `.pre-commit-config.yaml`:
     - id: python-dependency-linter
 ```
 
-To pass custom options (e.g., a different config file or project root):
+To pass custom options (e.g., a different config file):
 
 ```yaml
 - repo: https://github.com/heumsi/python-dependency-linter
   rev: v0.1.0
   hooks:
     - id: python-dependency-linter
-      args: [--config, custom-config.yaml, --project-root, src]
+      args: [--config, custom-config.yaml]
 ```
 
 ## License

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/README.md

@@ -102,25 +102,30 @@ rules:
 
 Isolate domain from infrastructure. Ports (interfaces) live in domain, adapters depend on domain but not vice versa.
 
+Using named captures (`{context}`), you can enforce that each bounded context only depends on its own domain — not other contexts' domains:
+
 ```yaml
 rules:
   - name: domain-no-infra
-    modules: contexts.*.domain
+    modules: contexts.{context}.domain
     allow:
       standard_library: [dataclasses, typing, abc]
       third_party: []
-      local: [contexts.*.domain]
+      local: [contexts.{context}.domain, shared.domain]
 
   - name: adapters-depend-on-domain
-    modules: contexts.*.adapters
+    modules: contexts.{context}.adapters
     allow:
       standard_library: ["*"]
       third_party: ["*"]
       local:
-        - contexts.*.adapters
-        - contexts.*.domain
+        - contexts.{context}.adapters
+        - contexts.{context}.domain
+        - shared
 ```
 
+With `{context}`, `contexts.boards.domain` can only import from `contexts.boards.domain` and `shared.domain` — not from `contexts.auth.domain`. See [Named Capture](#named-capture) for details.
+
 ## Configuration
 
 ### Include / Exclude
@@ -222,6 +227,35 @@ modules: contexts.*.domain  # matches contexts.boards.domain, contexts.auth.doma
 modules: contexts.**.domain  # matches contexts.boards.domain, contexts.boards.sub.domain, ...
 ```
 
+### Named Capture
+
+`{name}` captures a single level (like `*`) and allows back-referencing the captured value in `allow` and `deny`:
+
+```yaml
+rules:
+  - name: domain-isolation
+    modules: contexts.{context}.domain
+    allow:
+      local: [contexts.{context}.domain, shared.domain]
+```
+
+When this rule matches `contexts.boards.domain`, `{context}` captures `"boards"`. The `allow` pattern `contexts.{context}.domain` resolves to `contexts.boards.domain`, so only the same context's domain is allowed.
+
+You can use multiple captures in a single rule:
+
+```yaml
+rules:
+  - name: bounded-context-layers
+    modules: contexts.{context}.{layer}
+    allow:
+      local:
+        - contexts.{context}.{layer}
+        - contexts.{context}.domain
+        - shared
+```
+
+Named captures coexist with `*` and `**` wildcards. `{name}` always matches exactly one level.
+
 ### Submodule Matching
 
 When a pattern is used in `allow` or `deny`, it also matches submodules of the matched module. For example:
@@ -284,14 +318,11 @@ third_party = ["boto3"]
 ## CLI
 
 ```bash
-# Check with default config (.python-dependency-linter.yaml)
+# Check with auto-discovered config (searches upward from cwd)
 pdl check
 
-# Specify config file
+# Specify config file (project root = config file's parent directory)
 pdl check --config path/to/config.yaml
-
-# Specify project root
-pdl check --project-root path/to/project
 ```
 
 Exit codes:
@@ -300,10 +331,10 @@ Exit codes:
 - `1` — Violations found
 - `2` — Config file not found
 
-If no `--config` is given, the tool looks for `.python-dependency-linter.yaml` in the current directory. If the config file does not exist, the tool prints an error and exits with code `2`:
+If no `--config` is given, the tool searches upward from the current directory for `.python-dependency-linter.yaml` or `pyproject.toml` (with `[tool.python-dependency-linter]`). The config file's parent directory is used as the project root. If no config file is found, the tool prints an error and exits with code `2`:
 
 ```
-Error: Config file not found: .python-dependency-linter.yaml
+Error: Config file not found. Create .python-dependency-linter.yaml or configure [tool.python-dependency-linter] in pyproject.toml.
 ```
 
 ## Pre-commit
@@ -317,14 +348,14 @@ Add to `.pre-commit-config.yaml`:
     - id: python-dependency-linter
 ```
 
-To pass custom options (e.g., a different config file or project root):
+To pass custom options (e.g., a different config file):
 
 ```yaml
 - repo: https://github.com/heumsi/python-dependency-linter
   rev: v0.1.0
   hooks:
     - id: python-dependency-linter
-      args: [--config, custom-config.yaml, --project-root, src]
+      args: [--config, custom-config.yaml]
 ```
 
 ## License

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/python_dependency_linter/checker.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 
 from python_dependency_linter.config import AllowDeny, Rule
@@ -7,6 +8,36 @@ from python_dependency_linter.matcher import matches_pattern
 from python_dependency_linter.parser import ImportInfo
 from python_dependency_linter.resolver import ImportCategory
 
+_CAPTURE_RE = re.compile(r"\{(\w+)\}")
+
+
+def resolve_captures(pattern: str, captures: dict[str, str]) -> str:
+    def _replace(m: re.Match) -> str:
+        name = m.group(1)
+        return captures.get(name, m.group(0))
+
+    return _CAPTURE_RE.sub(_replace, pattern)
+
+
+def _resolve_list(
+    patterns: list[str] | None, captures: dict[str, str]
+) -> list[str] | None:
+    if patterns is None:
+        return None
+    return [resolve_captures(p, captures) for p in patterns]
+
+
+def _resolve_allow_deny(
+    allow_deny: AllowDeny | None, captures: dict[str, str]
+) -> AllowDeny | None:
+    if allow_deny is None:
+        return None
+    return AllowDeny(
+        standard_library=_resolve_list(allow_deny.standard_library, captures),
+        third_party=_resolve_list(allow_deny.third_party, captures),
+        local=_resolve_list(allow_deny.local, captures),
+    )
+
 
 @dataclass
 class Violation:
@@ -60,10 +91,19 @@ def check_import(
     category: ImportCategory,
     merged_rule: Rule | None,
     source_module: str,
+    captures: dict[str, str] | None = None,
 ) -> Violation | None:
     if merged_rule is None:
         return None
 
+    if captures:
+        merged_rule = Rule(
+            name=merged_rule.name,
+            modules=merged_rule.modules,
+            allow=_resolve_allow_deny(merged_rule.allow, captures),
+            deny=_resolve_allow_deny(merged_rule.deny, captures),
+        )
+
     module = import_info.module
 
     # Check deny first (deny takes priority over allow)

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/python_dependency_linter/cli.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import fnmatch
 from pathlib import Path
 
 import click
 
 from python_dependency_linter.checker import check_import
-from python_dependency_linter.config import load_config
+from python_dependency_linter.config import find_config, load_config
 from python_dependency_linter.matcher import find_matching_rules, merge_rules
 from python_dependency_linter.parser import parse_imports
 from python_dependency_linter.reporter import format_violations
@@ -46,7 +47,7 @@ def _normalize_pattern(pattern: str, project_root: Path) -> str:
 
 
 def _matches_any(path: Path, patterns: list[str]) -> bool:
-    return any(path.match(p) for p in patterns)
+    return any(fnmatch.fnmatch(str(path), p) for p in patterns)
 
 
 def _find_python_files(
@@ -84,19 +85,29 @@ def main():
 @click.option(
     "--config",
     "config_path",
-    default=".python-dependency-linter.yaml",
+    default=None,
     help="Path to config file.",
 )
-@click.option("--project-root", default=".", help="Project root directory.")
-def check(config_path: str, project_root: str):
-    root = Path(project_root).resolve()
-    config_file = Path(config_path)
-
-    try:
-        config = load_config(config_file)
-    except FileNotFoundError as e:
-        click.echo(f"Error: {e}", err=True)
-        raise SystemExit(2)
+def check(config_path: str | None):
+    if config_path is not None:
+        config_file = Path(config_path)
+        if not config_file.exists():
+            click.echo(f"Error: Config file not found: {config_file}", err=True)
+            raise SystemExit(2)
+        root = config_file.resolve().parent
+    else:
+        config_file = find_config()
+        if config_file is None:
+            click.echo(
+                "Error: Config file not found. "
+                "Create .python-dependency-linter.yaml or configure "
+                "[tool.python-dependency-linter] in pyproject.toml.",
+                err=True,
+            )
+            raise SystemExit(2)
+        root = config_file.resolve().parent
+
+    config = load_config(config_file)
 
     all_violations = []
     python_files = _find_python_files(root, config.include, config.exclude)
@@ -104,17 +115,21 @@ def check(config_path: str, project_root: str):
     for file_path in python_files:
         module = _file_to_module(file_path, root)
         package = _package_module(file_path, root)
-        matching_rules = find_matching_rules(package, config.rules)
-        if not matching_rules:
+        matching = find_matching_rules(package, config.rules)
+        if not matching:
             continue
 
+        matching_rules = [r for r, _ in matching]
+        captures: dict[str, str] = {}
+        for _, c in matching:
+            captures.update(c)
         merged_rule = merge_rules(matching_rules)
         imports = parse_imports(file_path, root)
 
         file_violations = []
         for imp in imports:
             category = resolve_import(imp.module, root)
-            violation = check_import(imp, category, merged_rule, module)
+            violation = check_import(imp, category, merged_rule, module, captures)
             if violation is not None:
                 file_violations.append(violation)
 

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/python_dependency_linter/config.py

@@ -62,14 +62,18 @@ def _load_yaml(path: Path) -> Config:
     )
 
 
-def _load_pyproject_toml(path: Path) -> Config:
+def _load_toml(path: Path) -> dict:
     try:
         import tomllib
     except ImportError:
         import tomli as tomllib  # type: ignore[no-redef]
 
     with open(path, "rb") as f:
-        data = tomllib.load(f)
+        return tomllib.load(f)
+
+
+def _load_pyproject_toml(path: Path) -> Config:
+    data = _load_toml(path)
     tool_config = data["tool"]["python-dependency-linter"]
     return Config(
         rules=_parse_rules(tool_config["rules"]),
@@ -78,6 +82,31 @@ def _load_pyproject_toml(path: Path) -> Config:
     )
 
 
+def _has_pdl_section(path: Path) -> bool:
+    """Check if a pyproject.toml contains [tool.python-dependency-linter]."""
+    data = _load_toml(path)
+    return "python-dependency-linter" in data.get("tool", {})
+
+
+_CONFIG_FILENAMES = [".python-dependency-linter.yaml", "pyproject.toml"]
+
+
+def find_config() -> Path | None:
+    """Search upward from cwd for a config file. Returns None if not found."""
+    current = Path.cwd().resolve()
+    while True:
+        for name in _CONFIG_FILENAMES:
+            candidate = current / name
+            if candidate.is_file():
+                if name == "pyproject.toml" and not _has_pdl_section(candidate):
+                    continue
+                return candidate
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
 def load_config(path: Path) -> Config:
     if not path.exists():
         raise FileNotFoundError(f"Config file not found: {path}")

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/python_dependency_linter/matcher.py

@@ -1,38 +1,73 @@
 from __future__ import annotations
 
+import re
+
 from python_dependency_linter.config import AllowDeny, Rule
 
+_CAPTURE_RE = re.compile(r"^\{(\w+)\}$")
+
 
 def matches_pattern(pattern: str, module: str) -> bool:
+    return match_pattern_with_captures(pattern, module) is not None
+
+
+def match_pattern_with_captures(pattern: str, module: str) -> dict[str, str] | None:
     pattern_parts = pattern.split(".")
     module_parts = module.split(".")
-    return _match(pattern_parts, module_parts)
+    captures: dict[str, str] = {}
+    if _match_with_captures(pattern_parts, module_parts, captures):
+        return captures
+    return None
 
 
-def _match(pattern_parts: list[str], module_parts: list[str]) -> bool:
+def _match_with_captures(
+    pattern_parts: list[str],
+    module_parts: list[str],
+    captures: dict[str, str],
+) -> bool:
     if not pattern_parts and not module_parts:
         return True
     if not pattern_parts:
         return False
 
     if pattern_parts[0] == "**":
-        # "**" matches one or more parts
         for i in range(1, len(module_parts) + 1):
-            if _match(pattern_parts[1:], module_parts[i:]):
+            snapshot = dict(captures)
+            if _match_with_captures(pattern_parts[1:], module_parts[i:], captures):
                 return True
+            captures.clear()
+            captures.update(snapshot)
         return False
 
     if not module_parts:
         return False
 
+    m = _CAPTURE_RE.match(pattern_parts[0])
+    if m:
+        name = m.group(1)
+        value = module_parts[0]
+        if name in captures:
+            if captures[name] != value:
+                return False
+        else:
+            captures[name] = value
+        return _match_with_captures(pattern_parts[1:], module_parts[1:], captures)
+
     if pattern_parts[0] == "*" or pattern_parts[0] == module_parts[0]:
-        return _match(pattern_parts[1:], module_parts[1:])
+        return _match_with_captures(pattern_parts[1:], module_parts[1:], captures)
 
     return False
 
 
-def find_matching_rules(module: str, rules: list[Rule]) -> list[Rule]:
-    return [r for r in rules if matches_pattern(r.modules, module)]
+def find_matching_rules(
+    module: str, rules: list[Rule]
+) -> list[tuple[Rule, dict[str, str]]]:
+    result = []
+    for r in rules:
+        captures = match_pattern_with_captures(r.modules, module)
+        if captures is not None:
+            result.append((r, captures))
+    return result
 
 
 def _merge_allow_deny(

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/tests/test_checker.py

@@ -1,4 +1,4 @@
-from python_dependency_linter.checker import Violation, check_import
+from python_dependency_linter.checker import Violation, check_import, resolve_captures
 from python_dependency_linter.config import AllowDeny, Rule
 from python_dependency_linter.parser import ImportInfo
 from python_dependency_linter.resolver import ImportCategory
@@ -150,3 +150,76 @@ def test_no_allow_for_category_means_allow_all():
         source_module="contexts.boards.domain",
     )
     assert result is None
+
+
+def test_resolve_captures_single():
+    result = resolve_captures("src.contexts.{context}.domain", {"context": "analytics"})
+    assert result == "src.contexts.analytics.domain"
+
+
+def test_resolve_captures_multiple():
+    result = resolve_captures(
+        "src.{ctx}.adapters.{dir}", {"ctx": "auth", "dir": "inbound"}
+    )
+    assert result == "src.auth.adapters.inbound"
+
+
+def test_resolve_captures_no_placeholders():
+    result = resolve_captures("src.shared.domain", {"context": "analytics"})
+    assert result == "src.shared.domain"
+
+
+def test_resolve_captures_unresolved_placeholder():
+    result = resolve_captures("src.{unknown}.domain", {"context": "analytics"})
+    assert result == "src.{unknown}.domain"
+
+
+def test_cross_context_isolation_allowed():
+    """Same context's domain import should be allowed."""
+    rule = Rule(
+        name="domain-layer",
+        modules="contexts.{context}.domain",
+        allow=AllowDeny(local=["contexts.{context}.domain", "shared.domain"]),
+    )
+    result = check_import(
+        import_info=ImportInfo(module="contexts.boards.domain.models", lineno=1),
+        category=ImportCategory.LOCAL,
+        merged_rule=rule,
+        source_module="contexts.boards.domain",
+        captures={"context": "boards"},
+    )
+    assert result is None
+
+
+def test_cross_context_isolation_violation():
+    """Different context's domain import should be denied."""
+    rule = Rule(
+        name="domain-layer",
+        modules="contexts.{context}.domain",
+        allow=AllowDeny(local=["contexts.{context}.domain", "shared.domain"]),
+    )
+    result = check_import(
+        import_info=ImportInfo(module="contexts.auth.domain.models", lineno=5),
+        category=ImportCategory.LOCAL,
+        merged_rule=rule,
+        source_module="contexts.boards.domain",
+        captures={"context": "boards"},
+    )
+    assert isinstance(result, Violation)
+    assert result.imported_module == "contexts.auth.domain.models"
+
+
+def test_check_import_no_captures_backward_compat():
+    """Existing behavior works when no captures provided."""
+    rule = Rule(
+        name="domain-isolation",
+        modules="contexts.*.domain",
+        allow=AllowDeny(third_party=["pydantic"]),
+    )
+    result = check_import(
+        import_info=ImportInfo(module="pydantic", lineno=1),
+        category=ImportCategory.THIRD_PARTY,
+        merged_rule=rule,
+        source_module="contexts.boards.domain",
+    )
+    assert result is None

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/tests/test_cli.py

@@ -7,7 +7,7 @@ from python_dependency_linter.cli import main
 FIXTURES = Path(__file__).parent / "fixtures"
 
 
-def test_cli_check_with_violations(tmp_path):
+def test_cli_check_with_violations(tmp_path, monkeypatch):
     config_content = """\
 rules:
   - name: domain-isolation
@@ -27,16 +27,15 @@ rules:
     dst = tmp_path / "contexts"
     shutil.copytree(src, dst)
 
+    monkeypatch.chdir(tmp_path)
     runner = CliRunner()
-    result = runner.invoke(
-        main, ["check", "--config", str(config_file), "--project-root", str(tmp_path)]
-    )
+    result = runner.invoke(main, ["check"])
     assert result.exit_code == 1
     assert "[domain-isolation]" in result.output
     assert "Found" in result.output
 
 
-def test_cli_check_no_violations(tmp_path):
+def test_cli_check_no_violations(tmp_path, monkeypatch):
     config_content = """\
 rules:
   - name: allow-all
@@ -55,15 +54,14 @@ rules:
     dst = tmp_path / "contexts"
     shutil.copytree(src, dst)
 
+    monkeypatch.chdir(tmp_path)
     runner = CliRunner()
-    result = runner.invoke(
-        main, ["check", "--config", str(config_file), "--project-root", str(tmp_path)]
-    )
+    result = runner.invoke(main, ["check"])
     assert result.exit_code == 0
     assert "No violations found." in result.output
 
 
-def test_cli_check_with_include(tmp_path):
+def test_cli_check_with_include(tmp_path, monkeypatch):
     """Files outside include paths should be skipped."""
     config_content = """\
 include:
@@ -74,7 +72,7 @@ rules:
     deny:
       third_party: [pydantic]
 """
-    config_file = tmp_path / "config.yaml"
+    config_file = tmp_path / ".python-dependency-linter.yaml"
     config_file.write_text(config_content)
 
     # Create files inside and outside include path
@@ -88,16 +86,52 @@ rules:
     (other / "__init__.py").write_text("")
     (other / "app.py").write_text("import pydantic\n")
 
+    monkeypatch.chdir(tmp_path)
     runner = CliRunner()
-    result = runner.invoke(
-        main, ["check", "--config", str(config_file), "--project-root", str(tmp_path)]
-    )
+    result = runner.invoke(main, ["check"])
     assert result.exit_code == 1
     assert "src/app.py" in result.output
     assert "other/app.py" not in result.output
 
 
-def test_cli_check_with_exclude(tmp_path):
+def test_cli_check_with_include_nested(tmp_path, monkeypatch):
+    """Include should match files in deeply nested subdirectories."""
+    config_content = """\
+include:
+  - src
+rules:
+  - name: domain-isolation
+    modules: "**"
+    deny:
+      third_party: [pydantic]
+"""
+    config_file = tmp_path / ".python-dependency-linter.yaml"
+    config_file.write_text(config_content)
+
+    # Create deeply nested files inside include path
+    nested = tmp_path / "src" / "contexts" / "analytics" / "domain"
+    nested.mkdir(parents=True)
+    (tmp_path / "src" / "__init__.py").write_text("")
+    (tmp_path / "src" / "contexts" / "__init__.py").write_text("")
+    (tmp_path / "src" / "contexts" / "analytics" / "__init__.py").write_text("")
+    (nested / "__init__.py").write_text("")
+    (nested / "models.py").write_text("import pydantic\n")
+
+    # Create files outside include path
+    other = tmp_path / "other"
+    other.mkdir()
+    (other / "__init__.py").write_text("")
+    (other / "app.py").write_text("import pydantic\n")
+
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(main, ["check"])
+    assert result.exit_code == 1
+    assert "src/contexts/analytics/domain/models.py" in result.output
+    assert "other/app.py" not in result.output
+
+
+def test_cli_check_with_exclude(tmp_path, monkeypatch):
     """Files matching exclude patterns should be skipped."""
     config_content = """\
 exclude:
@@ -108,7 +142,7 @@ rules:
     deny:
       third_party: [pydantic]
 """
-    config_file = tmp_path / "config.yaml"
+    config_file = tmp_path / ".python-dependency-linter.yaml"
     config_file.write_text(config_content)
 
     src = tmp_path / "src"
@@ -121,16 +155,15 @@ rules:
     (generated / "__init__.py").write_text("")
     (generated / "models.py").write_text("import pydantic\n")
 
+    monkeypatch.chdir(tmp_path)
     runner = CliRunner()
-    result = runner.invoke(
-        main, ["check", "--config", str(config_file), "--project-root", str(tmp_path)]
-    )
+    result = runner.invoke(main, ["check"])
     assert result.exit_code == 1
     assert "src/app.py" in result.output
     assert "generated/" not in result.output
 
 
-def test_cli_check_with_include_and_exclude(tmp_path):
+def test_cli_check_with_include_and_exclude(tmp_path, monkeypatch):
     """Exclude should filter within included paths."""
     config_content = """\
 include:
@@ -143,7 +176,7 @@ rules:
     deny:
       third_party: [pydantic]
 """
-    config_file = tmp_path / "config.yaml"
+    config_file = tmp_path / ".python-dependency-linter.yaml"
     config_file.write_text(config_content)
 
     app = tmp_path / "src"
@@ -156,16 +189,51 @@ rules:
     (generated / "__init__.py").write_text("")
     (generated / "models.py").write_text("import pydantic\n")
 
+    monkeypatch.chdir(tmp_path)
     runner = CliRunner()
-    result = runner.invoke(
-        main, ["check", "--config", str(config_file), "--project-root", str(tmp_path)]
-    )
+    result = runner.invoke(main, ["check"])
     assert result.exit_code == 1
     assert "src/app.py" in result.output
     assert "generated/" not in result.output
 
 
-def test_cli_check_config_not_found():
+def test_cli_check_config_not_found(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(main, ["check"])
+    assert result.exit_code == 2
+
+
+def test_cli_check_explicit_config_not_found():
     runner = CliRunner()
     result = runner.invoke(main, ["check", "--config", "nonexistent.yaml"])
     assert result.exit_code == 2
+    assert "not found" in result.output.lower()
+
+
+def test_cli_check_with_explicit_config(tmp_path, monkeypatch):
+    """--config should use the config file's parent as project root."""
+    project_dir = tmp_path / "project"
+    project_dir.mkdir()
+
+    config_content = """\
+rules:
+  - name: domain-isolation
+    modules: "**"
+    deny:
+      third_party: [pydantic]
+"""
+    config_file = project_dir / "custom-config.yaml"
+    config_file.write_text(config_content)
+
+    src = project_dir / "src"
+    src.mkdir()
+    (src / "__init__.py").write_text("")
+    (src / "app.py").write_text("import pydantic\n")
+
+    # Run from a different directory, but point --config to project_dir
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(main, ["check", "--config", str(config_file)])
+    assert result.exit_code == 1
+    assert "src/app.py" in result.output

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/tests/test_config.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from python_dependency_linter.config import load_config
+from python_dependency_linter.config import find_config, load_config
 
 FIXTURES = Path(__file__).parent / "fixtures"
 
@@ -81,3 +81,46 @@ def test_load_config_file_not_found():
 
     with pytest.raises(FileNotFoundError):
         load_config(Path("nonexistent.yaml"))
+
+
+def test_find_config_yaml_in_cwd(tmp_path, monkeypatch):
+    (tmp_path / ".python-dependency-linter.yaml").write_text("rules: []\n")
+    monkeypatch.chdir(tmp_path)
+    assert find_config() == tmp_path / ".python-dependency-linter.yaml"
+
+
+def test_find_config_yaml_in_parent(tmp_path, monkeypatch):
+    (tmp_path / ".python-dependency-linter.yaml").write_text("rules: []\n")
+    child = tmp_path / "sub"
+    child.mkdir()
+    monkeypatch.chdir(child)
+    assert find_config() == tmp_path / ".python-dependency-linter.yaml"
+
+
+def test_find_config_pyproject_toml(tmp_path, monkeypatch):
+    toml_content = "[tool.python-dependency-linter]\nrules = []\n"
+    (tmp_path / "pyproject.toml").write_text(toml_content)
+    monkeypatch.chdir(tmp_path)
+    assert find_config() == tmp_path / "pyproject.toml"
+
+
+def test_find_config_yaml_preferred_over_toml(tmp_path, monkeypatch):
+    """When both exist in the same directory, YAML wins."""
+    (tmp_path / ".python-dependency-linter.yaml").write_text("rules: []\n")
+    toml_content = "[tool.python-dependency-linter]\nrules = []\n"
+    (tmp_path / "pyproject.toml").write_text(toml_content)
+    monkeypatch.chdir(tmp_path)
+    assert find_config() == tmp_path / ".python-dependency-linter.yaml"
+
+
+def test_find_config_not_found(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    result = find_config()
+    assert result is None
+
+
+def test_find_config_skips_pyproject_without_section(tmp_path, monkeypatch):
+    """pyproject.toml without [tool.python-dependency-linter] should be skipped."""
+    (tmp_path / "pyproject.toml").write_text("[tool.other]\nfoo = 1\n")
+    monkeypatch.chdir(tmp_path)
+    assert find_config() is None

{python_dependency_linter-0.3.0 → python_dependency_linter-0.5.0}/tests/test_matcher.py

@@ -1,6 +1,7 @@
 from python_dependency_linter.config import AllowDeny, Rule
 from python_dependency_linter.matcher import (
     find_matching_rules,
+    match_pattern_with_captures,
     matches_pattern,
     merge_rules,
 )
@@ -73,8 +74,8 @@ def test_find_matching_rules():
     ]
     matched = find_matching_rules("contexts.boards.domain", rules)
     assert len(matched) == 2
-    assert matched[0].name == "r1"
-    assert matched[1].name == "r2"
+    assert matched[0][0].name == "r1"
+    assert matched[1][0].name == "r2"
 
 
 def test_merge_rules_merges_allow():
@@ -117,3 +118,99 @@ def test_merge_rules_merges_deny():
     merged = merge_rules([rule1, rule2])
 
     assert sorted(merged.deny.third_party) == ["boto3", "requests"]
+
+
+def test_capture_single():
+    result = match_pattern_with_captures(
+        "src.contexts.{context}.domain", "src.contexts.analytics.domain"
+    )
+    assert result == {"context": "analytics"}
+
+
+def test_capture_multiple():
+    result = match_pattern_with_captures(
+        "src.contexts.{ctx}.adapters.{dir}", "src.contexts.auth.adapters.inbound"
+    )
+    assert result == {"ctx": "auth", "dir": "inbound"}
+
+
+def test_capture_duplicate_name_consistent():
+    result = match_pattern_with_captures("src.{a}.middle.{a}", "src.foo.middle.foo")
+    assert result == {"a": "foo"}
+
+
+def test_capture_duplicate_name_inconsistent():
+    result = match_pattern_with_captures("src.{a}.middle.{a}", "src.foo.middle.bar")
+    assert result is None
+
+
+def test_capture_no_match():
+    result = match_pattern_with_captures(
+        "src.contexts.{context}.domain", "src.utils.helpers"
+    )
+    assert result is None
+
+
+def test_capture_no_captures_with_star():
+    result = match_pattern_with_captures("src.*.domain", "src.analytics.domain")
+    assert result == {}
+
+
+def test_capture_coexist_with_star():
+    result = match_pattern_with_captures(
+        "src.{ctx}.*.domain", "src.auth.adapters.domain"
+    )
+    assert result == {"ctx": "auth"}
+
+
+def test_capture_coexist_with_double_star():
+    result = match_pattern_with_captures(
+        "src.{ctx}.**.domain", "src.auth.deep.nested.domain"
+    )
+    assert result == {"ctx": "auth"}
+
+
+def test_capture_exact_no_wildcards():
+    result = match_pattern_with_captures(
+        "src.contexts.analytics.domain", "src.contexts.analytics.domain"
+    )
+    assert result == {}
+
+
+def test_capture_exact_no_wildcards_no_match():
+    result = match_pattern_with_captures(
+        "src.contexts.analytics.domain", "src.contexts.auth.domain"
+    )
+    assert result is None
+
+
+def test_find_matching_rules_with_captures():
+    rules = [
+        Rule(
+            name="domain-layer",
+            modules="contexts.{context}.domain",
+            allow=AllowDeny(local=["contexts.{context}.domain"]),
+        ),
+        Rule(
+            name="adapters",
+            modules="contexts.*.adapters",
+            deny=AllowDeny(third_party=["boto3"]),
+        ),
+    ]
+    matched = find_matching_rules("contexts.boards.domain", rules)
+    assert len(matched) == 1
+    rule, captures = matched[0]
+    assert rule.name == "domain-layer"
+    assert captures == {"context": "boards"}
+
+
+def test_capture_after_double_star():
+    result = match_pattern_with_captures(
+        "src.**.{layer}.models", "src.deep.nested.domain.models"
+    )
+    assert result == {"layer": "domain"}
+
+
+def test_capture_after_double_star_backtrack():
+    result = match_pattern_with_captures("**.{x}.end", "a.b.c.end")
+    assert result == {"x": "c"}