modwire 2.1.0__tar.gz → 2.3.0__tar.gz

modwire-2.3.0/.github/workflows/large-repo-fixtures.yml

@@ -0,0 +1,88 @@
+name: Large Repository Fixtures
+
+on:
+  workflow_dispatch:
+    inputs:
+      fixture:
+        description: "Fixture id to run, or all."
+        required: true
+        default: "all"
+        type: choice
+        options:
+          - all
+          - django
+          - ansible
+          - salt
+          - vscode
+          - angular
+          - typescript
+          - wordpress
+          - drupal
+          - moodle
+      mode:
+        description: "Fixture execution mode."
+        required: true
+        default: "enclosure"
+        type: choice
+        options:
+          - enclosure
+          - modwire
+          - both
+      command-timeout:
+        description: "Seconds allowed for each enclosure command."
+        required: true
+        default: "60"
+  schedule:
+    - cron: "17 3 * * 0"
+
+jobs:
+  large-fixture:
+    name: ${{ matrix.fixture }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    if: github.event_name != 'workflow_dispatch' || inputs.fixture == 'all' || inputs.fixture == matrix.fixture
+    strategy:
+      fail-fast: false
+      matrix:
+        fixture:
+          - django
+          - ansible
+          - salt
+          - vscode
+          - angular
+          - typescript
+          - wordpress
+          - drupal
+          - moodle
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Set up PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.3"
+
+      - name: Install enclosure and local modwire
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install "enclosure @ git+https://github.com/9orky/enclosure.git"
+          python -m pip install -e .
+
+      - name: Run large fixture
+        run: >
+          python tests/large_projects/run_large_project_fixtures.py
+          --fixture "${{ matrix.fixture }}"
+          --mode "${{ github.event_name == 'workflow_dispatch' && inputs.mode || 'enclosure' }}"
+          --command-timeout "${{ github.event_name == 'workflow_dispatch' && inputs['command-timeout'] || '60' }}"

{modwire-2.1.0 → modwire-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 2.1.0
+Version: 2.3.0
 Summary: Extract source-code dependencies and build dependency graphs.
 Author: Tomasz Szpak
 License-Expression: MIT
@@ -136,6 +136,7 @@ from modwire import extract_code
 from modwire.architecture import (
     ArchitectureBoundaryRule,
     ArchitectureConfig,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -176,6 +177,41 @@ violations = ArchitecturePolicyEvaluator().evaluate(code_map.graph, config)
 print(render_violations(tuple(violations)))
 ```
 
+For repositories with more than one module ladder, configure flow realms and run
+the same analyzers across each module tag:
+
+```python
+config = ArchitectureConfig(
+    language="python",
+    architecture_root="src",
+    rules=ArchitectureRules(
+        tags=(
+            ArchitectureTagRule(name="backend_module", match="features/*"),
+            ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+            ArchitectureTagRule(name="domain", match="features/*/domain"),
+            ArchitectureTagRule(name="application", match="features/*/application"),
+        ),
+        flow=ArchitectureFlowRules(
+            realms=(
+                ArchitectureFlowRealm(
+                    name="backend",
+                    module_tag="backend_module",
+                    layers=("domain", "application"),
+                ),
+                ArchitectureFlowRealm(
+                    name="gui",
+                    module_tag="gui_page",
+                ),
+            ),
+            analyzers=("backward-flow", "no-cycles"),
+        ),
+    ),
+)
+```
+
+`backward-flow` evaluates realms with layers and skips layerless realms; scoped
+analyzers such as `no-cycles` evaluate every configured realm.
+
 Architecture insight helpers summarize ownership and graph pressure:
 
 ```python

{modwire-2.1.0 → modwire-2.3.0}/README.md

@@ -103,6 +103,7 @@ from modwire import extract_code
 from modwire.architecture import (
     ArchitectureBoundaryRule,
     ArchitectureConfig,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -143,6 +144,41 @@ violations = ArchitecturePolicyEvaluator().evaluate(code_map.graph, config)
 print(render_violations(tuple(violations)))
 ```
 
+For repositories with more than one module ladder, configure flow realms and run
+the same analyzers across each module tag:
+
+```python
+config = ArchitectureConfig(
+    language="python",
+    architecture_root="src",
+    rules=ArchitectureRules(
+        tags=(
+            ArchitectureTagRule(name="backend_module", match="features/*"),
+            ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+            ArchitectureTagRule(name="domain", match="features/*/domain"),
+            ArchitectureTagRule(name="application", match="features/*/application"),
+        ),
+        flow=ArchitectureFlowRules(
+            realms=(
+                ArchitectureFlowRealm(
+                    name="backend",
+                    module_tag="backend_module",
+                    layers=("domain", "application"),
+                ),
+                ArchitectureFlowRealm(
+                    name="gui",
+                    module_tag="gui_page",
+                ),
+            ),
+            analyzers=("backward-flow", "no-cycles"),
+        ),
+    ),
+)
+```
+
+`backward-flow` evaluates realms with layers and skips layerless realms; scoped
+analyzers such as `no-cycles` evaluate every configured realm.
+
 Architecture insight helpers summarize ownership and graph pressure:
 
 ```python

{modwire-2.1.0 → modwire-2.3.0}/pyproject.toml

@@ -72,8 +72,9 @@ include-package-data = true
 where = ["src"]
 
 [tool.setuptools.package-data]
-modwire = [
-    "extractors/scripts/*",
+"modwire.extractors.scripts" = [
+    "*.js",
+    "*.php",
 ]
 
 [tool.setuptools_scm]

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.3.0'
+__version_tuple__ = version_tuple = (2, 3, 0)
 
-__commit_id__ = commit_id = 'g54f33f5a3'
+__commit_id__ = commit_id = 'gdb0b34253'

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/architecture/__init__.py

@@ -4,6 +4,7 @@ from .config import (
     ArchitectureConfig,
     ArchitectureConfigError,
     ArchitectureConfigIssue,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitectureRules,
     ArchitectureTagRule,
@@ -32,6 +33,7 @@ __all__ = [
     "ArchitectureConfig",
     "ArchitectureConfigError",
     "ArchitectureConfigIssue",
+    "ArchitectureFlowRealm",
     "ArchitectureFlowRules",
     "ArchitectureMap",
     "ArchitecturePolicyEvaluator",

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/architecture/analyzers.py

@@ -40,9 +40,9 @@ def analyzer_title(name: str) -> str:
     return _ANALYZERS[name].title
 
 
-def run_analyzer(name: str, graph, tags, config):
+def run_analyzer(name: str, graph, tags, config, realm=None):
     analyzer = _ANALYZERS[name]
-    return analyzer.run(analyzer.name, graph, tags, config)
+    return analyzer.run(analyzer.name, graph, tags, config, realm)
 
 
 def _roots(graph):
@@ -65,12 +65,18 @@ def _dedupe(violations):
     return unique
 
 
-def _flow(name, path, index, message):
-    return FlowViolation(name, tuple(path), index, f"analyzer:{name}", message)
+def _flow(name, path, index, message, realm=None):
+    realm_name = "" if realm is None else getattr(realm, "name", "") or getattr(
+        realm,
+        "module_tag",
+        "",
+    )
+    rule_name = f"analyzer:{realm_name}:{name}" if realm_name else f"analyzer:{name}"
+    return FlowViolation(name, tuple(path), index, rule_name, message)
 
 
-def _backward_flow(name, graph, tags, config):
-    layers = config.rules.flow.layers
+def _backward_flow(name, graph, tags, config, realm):
+    layers = realm.layers if realm is not None else config.rules.flow.layers
 
     def layer(node):
         return next((i for i, layer_name in enumerate(layers) if layer_name in tags.get(node, set())), None)
@@ -85,7 +91,7 @@ def _backward_flow(name, graph, tags, config):
         for edge in graph.outgoing(node):
             next_layer = layer(edge.to_id)
             if current_layer is not None and next_layer is not None and next_layer < current_layer:
-                violations.append(_flow(name, [*path, edge.to_id], len(path), "layer order violated"))
+                violations.append(_flow(name, [*path, edge.to_id], len(path), "layer order violated", realm))
                 continue
             walk(edge.to_id, current_layer if next_layer is None else next_layer, [*path, edge.to_id])
 
@@ -94,8 +100,8 @@ def _backward_flow(name, graph, tags, config):
     return _dedupe(violations)
 
 
-def _no_reentry(name, graph, tags, config):
-    module_tag = config.rules.flow.module_tag
+def _no_reentry(name, graph, tags, config, realm):
+    module_tag = realm.module_tag if realm is not None else config.rules.flow.module_tag
     violations = []
     seen = set()
 
@@ -107,7 +113,7 @@ def _no_reentry(name, graph, tags, config):
             inside = module_tag in tags.get(edge.to_id, set())
             next_state = 1 if state == 0 and inside else 2 if state == 1 and not inside else state
             if state == 2 and inside:
-                violations.append(_flow(name, [*path, edge.to_id], len(path), "module layer re-entered after exit"))
+                violations.append(_flow(name, [*path, edge.to_id], len(path), "module layer re-entered after exit", realm))
                 continue
             walk(edge.to_id, next_state, [*path, edge.to_id])
 
@@ -116,8 +122,9 @@ def _no_reentry(name, graph, tags, config):
     return _dedupe(violations)
 
 
-def _no_cycles(name, graph, tags, config):
-    scoped = {node for node, node_tags in tags.items() if config.rules.flow.module_tag in node_tags}
+def _no_cycles(name, graph, tags, config, realm):
+    module_tag = realm.module_tag if realm is not None else config.rules.flow.module_tag
+    scoped = {node for node, node_tags in tags.items() if module_tag in node_tags}
     seen, stack, index, emitted, violations = set(), [], {}, set(), []
 
     def canonical(cycle):
@@ -137,7 +144,7 @@ def _no_cycles(name, graph, tags, config):
                 key = canonical(cycle)
                 if key not in emitted:
                     emitted.add(key)
-                    violations.append(_flow(name, cycle, len(cycle) - 1, "module cycle detected"))
+                    violations.append(_flow(name, cycle, len(cycle) - 1, "module cycle detected", realm))
             elif edge.to_id not in seen:
                 dfs(edge.to_id)
         stack.pop()

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/architecture/config.py

@@ -31,11 +31,20 @@ class ArchitectureBoundaryRule(BaseModel):
     allow_same_match: bool = False
 
 
+class ArchitectureFlowRealm(BaseModel):
+    model_config = ConfigDict(frozen=True, from_attributes=True)
+
+    name: str = ""
+    module_tag: str = ""
+    layers: tuple[str, ...] = ()
+
+
 class ArchitectureFlowRules(BaseModel):
     model_config = ConfigDict(frozen=True, from_attributes=True)
 
     layers: tuple[str, ...] = ()
     module_tag: str = ""
+    realms: tuple[ArchitectureFlowRealm, ...] = ()
     analyzers: tuple[str, ...] = ()
 
     @field_validator("analyzers")
@@ -50,6 +59,28 @@ class ArchitectureFlowRules(BaseModel):
 
     @model_validator(mode="after")
     def analyzers_have_required_config(self) -> ArchitectureFlowRules:
+        if self.realms:
+            if "backward-flow" in self.analyzers and not any(
+                realm.layers for realm in self.realms
+            ):
+                raise ValueError(
+                    "backward-flow requires at least one rules.flow.realms entry "
+                    "with layers"
+                )
+            scoped_analyzers = {"no-reentry", "no-cycles"}.intersection(
+                self.analyzers
+            )
+            missing_module_tag = tuple(
+                index for index, realm in enumerate(self.realms) if not realm.module_tag
+            )
+            if scoped_analyzers and missing_module_tag:
+                names = ", ".join(sorted(scoped_analyzers))
+                indexes = ", ".join(str(index) for index in missing_module_tag)
+                raise ValueError(
+                    f"{names} require rules.flow.realms module_tag values "
+                    f"(missing at indexes: {indexes})"
+                )
+            return self
         if "backward-flow" in self.analyzers and not self.layers:
             raise ValueError("backward-flow requires rules.flow.layers")
         scoped_analyzers = {"no-reentry", "no-cycles"}.intersection(self.analyzers)
@@ -114,13 +145,26 @@ def validate_policy_config(config) -> ArchitectureConfig:
         ) from error
 
 
+def flow_realms(flow: ArchitectureFlowRules) -> tuple[ArchitectureFlowRealm, ...]:
+    if flow.realms:
+        return flow.realms
+    return (
+        ArchitectureFlowRealm(
+            module_tag=flow.module_tag,
+            layers=flow.layers,
+        ),
+    )
+
+
 __all__ = [
     "ArchitectureBoundaryRule",
     "ArchitectureConfig",
     "ArchitectureConfigError",
     "ArchitectureConfigIssue",
+    "ArchitectureFlowRealm",
     "ArchitectureFlowRules",
     "ArchitectureRules",
     "ArchitectureTagRule",
+    "flow_realms",
     "validate_policy_config",
 ]

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/architecture/matching.py

@@ -43,14 +43,31 @@ class TagMatcher:
         self.tags = tuple(getattr(config.rules, "tags", ()))
 
     def match(self, node_id: str, name: str, *, scope: bool = True) -> TagMatch | None:
-        tag = self._tag(name)
-        pattern = tag.match if tag is not None else name
+        matches = self.matches(node_id, name, scope=scope)
+        if matches:
+            return matches[0]
+        if self._has_tag(name):
+            return None
+        pattern = name
         return self.match_pattern(
             node_id,
             pattern,
             name=name,
             scope=scope,
-            exclude=() if tag is None else tag.excluded_patterns,
+        )
+
+    def matches(
+        self,
+        node_id: str,
+        name: str,
+        *,
+        scope: bool = True,
+    ) -> tuple[TagMatch, ...]:
+        return tuple(
+            match
+            for tag in self.tags
+            if tag.name == name
+            if (match := self._match_tag(node_id, tag, scope=scope)) is not None
         )
 
     def match_pattern(
@@ -80,9 +97,19 @@ class TagMatcher:
                 )
         return None
 
-    def first_match(self, node_id: str, names: tuple[str, ...]) -> TagMatch | None:
+    def first_match(
+        self,
+        node_id: str,
+        names: tuple[str, ...],
+        *,
+        scope: bool = True,
+    ) -> TagMatch | None:
         return next(
-            (match for name in names if (match := self.match(node_id, name)) is not None),
+            (
+                tag_match
+                for name in names
+                if (tag_match := self.match(node_id, name, scope=scope)) is not None
+            ),
             None,
         )
 
@@ -90,7 +117,7 @@ class TagMatcher:
         return tuple(
             match
             for tag in self.tags
-            if (match := self.match(node_id, tag.name)) is not None
+            if (match := self._match_tag(node_id, tag)) is not None
         )
 
     def map_code_map(self, code_map) -> TagMap:
@@ -111,8 +138,17 @@ class TagMatcher:
             return path[len(architecture_root) + 1 :]
         return path
 
-    def _tag(self, name: str):
-        return next((tag for tag in self.tags if tag.name == name), None)
+    def _match_tag(self, node_id: str, tag, *, scope: bool = True) -> TagMatch | None:
+        return self.match_pattern(
+            node_id,
+            tag.match,
+            name=tag.name,
+            scope=scope,
+            exclude=tag.excluded_patterns,
+        )
+
+    def _has_tag(self, name: str) -> bool:
+        return any(tag.name == name for tag in self.tags)
 
 
 def _normalized_patterns(language, pattern, config):

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/architecture/policy.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from modwire.graph import DependencyGraph
 
 from .analyzers import run_analyzer
-from .config import validate_policy_config
+from .config import flow_realms, validate_policy_config
 from .matching import TagMatcher
 from .violations import EdgeRuleViolation, FlowViolation
 
@@ -14,7 +14,13 @@ class ArchitecturePolicyEvaluator:
         tags = _tags(graph.node_ids(), config)
         violations: list[EdgeRuleViolation | FlowViolation] = _edge_violations(graph, config)
         for analyzer_name in config.rules.flow.analyzers:
-            violations.extend(run_analyzer(analyzer_name, graph, tags, config))
+            for realm in flow_realms(config.rules.flow):
+                if analyzer_name == "backward-flow" and not realm.layers:
+                    continue
+                analyzer_realm = realm if config.rules.flow.realms else None
+                violations.extend(
+                    run_analyzer(analyzer_name, graph, tags, config, analyzer_realm)
+                )
         return violations
 
 

{modwire-2.1.0 → modwire-2.3.0}/src/modwire/extraction/manifest.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from .._version import __version__
 from ..extractors import load_extractor
 from ..extractors.base import _collect_extraction_targets
+from ..extractors.resources import extractor_script_path
 from .models import SourceManifest, SourceManifestEntry
 from .roots import (
     DEFAULT_SOURCE_ROOTS,
@@ -57,14 +58,14 @@ def discover_sources(
                 mtime_ns=stat.st_mtime_ns,
             )
         )
-    extractor_path = (
-        Path(__file__).parents[1] / "extractors" / "scripts" / extractor.extractor_file
-    ).resolve()
     runtime_path = shutil.which(extractor.command) or ""
     runtime_mtime_ns = 0
     if runtime_path != "":
         runtime_mtime_ns = Path(runtime_path).stat().st_mtime_ns
 
+    with extractor_script_path(extractor.extractor_file) as extractor_path:
+        extractor_mtime_ns = extractor_path.stat().st_mtime_ns
+
     return SourceManifest(
         language=language,
         workspace_root=(
@@ -83,7 +84,7 @@ def discover_sources(
         runtime_mtime_ns=runtime_mtime_ns,
         extractor_file=extractor.extractor_file,
         extractor_path=extractor_path,
-        extractor_mtime_ns=extractor_path.stat().st_mtime_ns,
+        extractor_mtime_ns=extractor_mtime_ns,
         modwire_version=__version__,
         files_found=files_found,
         files_checked=len(entries),