modwire 2.0.0__tar.gz → 2.2.0__tar.gz

modwire-2.2.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.0.0 → modwire-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 2.0.0
+Version: 2.2.0
 Summary: Extract source-code dependencies and build dependency graphs.
 Author: Tomasz Szpak
 License-Expression: MIT

{modwire-2.0.0 → modwire-2.2.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.0.0 → modwire-2.2.0}/src/modwire/__init__.py

@@ -1,4 +1,10 @@
 from ._version import __version__
+from .callables import (
+    CallableReportEntry,
+    callable_report_entries,
+    render_callable_report,
+    structured_callable_report,
+)
 from .extraction import (
     CodeMap,
     CodeMapSerializationError,
@@ -46,6 +52,7 @@ from .shape import (
 __all__ = [
     "CodeMap",
     "CodeMapSerializationError",
+    "CallableReportEntry",
     "DependencyGraph",
     "Edge",
     "EXTRACTION_SCHEMA_VERSION",
@@ -69,6 +76,7 @@ __all__ = [
     "UnusedExport",
     "__version__",
     "build_dependency_graph",
+    "callable_report_entries",
     "deserialize_code_map",
     "discover_sources",
     "evaluate_shape",
@@ -79,8 +87,10 @@ __all__ = [
     "languages",
     "normalize_source_id",
     "require_runtime",
+    "render_callable_report",
     "runtime_diagnostics",
     "serialize_code_map",
+    "structured_callable_report",
     "supported_languages",
     "validate_shape_config",
 ]

{modwire-2.0.0 → modwire-2.2.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.0.0'
-__version_tuple__ = version_tuple = (2, 0, 0)
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)
 
-__commit_id__ = commit_id = 'gb985fe227'
+__commit_id__ = commit_id = 'gc116aabfa'

modwire-2.2.0/src/modwire/callables.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from .definitions import SourceCall, SourceCallable
+from .extraction import CodeMap
+
+
+PathDisplay = Callable[[str], str]
+
+
+@dataclass(frozen=True)
+class CallableReportEntry:
+    source_callable: SourceCallable
+    calls: tuple[SourceCall, ...]
+    callers: tuple[SourceCall, ...]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "callable": self.source_callable.model_dump(mode="json"),
+            "calls": [source_call.model_dump(mode="json") for source_call in self.calls],
+            "callers": [
+                source_call.model_dump(mode="json") for source_call in self.callers
+            ],
+        }
+
+
+def callable_report_entries(code_map: CodeMap) -> tuple[CallableReportEntry, ...]:
+    return tuple(
+        CallableReportEntry(
+            source_callable=source_callable,
+            calls=tuple(
+                sorted(
+                    code_map.calls_from(source_callable.id),
+                    key=lambda source_call: (
+                        source_call.line,
+                        source_call.target_name,
+                        source_call.expression,
+                    ),
+                )
+            ),
+            callers=tuple(
+                sorted(
+                    code_map.calls_to(source_callable.id),
+                    key=lambda source_call: (
+                        source_call.source_id,
+                        source_call.line,
+                        source_call.source_callable_id,
+                    ),
+                )
+            ),
+        )
+        for source_callable in sorted(
+            (
+                source_callable
+                for source_file in code_map.extraction_result.files.values()
+                for source_callable in source_file.callables
+            ),
+            key=lambda source_callable: (
+                source_callable.source_id,
+                source_callable.line_start,
+                source_callable.qualified_name,
+            ),
+        )
+    )
+
+
+def structured_callable_report(code_map: CodeMap) -> tuple[dict[str, object], ...]:
+    return tuple(entry.to_dict() for entry in callable_report_entries(code_map))
+
+
+def render_callable_report(
+    code_map: CodeMap,
+    *,
+    path_display: PathDisplay = str,
+) -> str:
+    entries = callable_report_entries(code_map)
+    if not entries:
+        return "Callable Report\n\nNo callables found."
+
+    callable_names = {
+        entry.source_callable.id: entry.source_callable.qualified_name
+        for entry in entries
+    }
+    lines = ["Callable Report", ""]
+    current_source_id = ""
+    for entry in entries:
+        source_callable = entry.source_callable
+        if source_callable.source_id != current_source_id:
+            current_source_id = source_callable.source_id
+            lines.extend([f"## {path_display(current_source_id)}", ""])
+        lines.append(
+            "- "
+            f"{source_callable.qualified_name} "
+            f"[{source_callable.kind}] "
+            f"lines {source_callable.line_start}-{source_callable.line_end}"
+        )
+        lines.append("  Calls:")
+        lines.extend(
+            _call_lines(
+                entry.calls,
+                callable_names=callable_names,
+                direction="outgoing",
+                path_display=path_display,
+            )
+        )
+        lines.append("  Called by:")
+        lines.extend(
+            _call_lines(
+                entry.callers,
+                callable_names=callable_names,
+                direction="incoming",
+                path_display=path_display,
+            )
+        )
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def _call_lines(
+    calls: tuple[SourceCall, ...],
+    *,
+    callable_names: dict[str, str],
+    direction: str,
+    path_display: PathDisplay,
+) -> list[str]:
+    if not calls:
+        return ["  - none"]
+
+    rendered = []
+    for source_call in calls:
+        if direction == "incoming":
+            caller_name = callable_names.get(
+                source_call.source_callable_id,
+                source_call.source_callable_id,
+            )
+            rendered.append(
+                f"  - {caller_name} "
+                f"at {path_display(source_call.source_id)}:{source_call.line}"
+            )
+            continue
+
+        target = (
+            callable_names[source_call.target_callable_id]
+            if source_call.target_callable_id in callable_names
+            else source_call.target_name
+        )
+        rendered.append(
+            f"  - {source_call.expression} -> {target} "
+            f"at {path_display(source_call.source_id)}:{source_call.line} "
+            f"({source_call.resolution})"
+        )
+    return rendered
+
+
+__all__ = [
+    "CallableReportEntry",
+    "callable_report_entries",
+    "render_callable_report",
+    "structured_callable_report",
+]

{modwire-2.0.0 → modwire-2.2.0}/src/modwire/definitions.py

@@ -6,6 +6,19 @@ from pydantic import BaseModel, Field
 ImportCrossingType = Literal["module", "symbol"]
 SourceVisibility = Literal["public", "protected", "private"]
 SourceSignatureKind = Literal["call", "construct", "index"]
+SourceValueDeclarationKind = Literal["assignment", "constant", "property", "unknown"]
+SourceValueKind = Literal["callable", "class", "literal", "object", "unknown"]
+SourceParameterKind = Literal["positional", "vararg", "keyword_only", "kwarg"]
+SourceCallableKind = Literal[
+    "function",
+    "method",
+    "classmethod",
+    "staticmethod",
+    "constructor",
+    "callable_value",
+    "anonymous",
+]
+SourceCallResolution = Literal["resolved", "unresolved", "external", "dynamic"]
 SourceExportKind = Literal[
     "module",
     "class",
@@ -64,6 +77,54 @@ class SourceFunction(BaseModel):
     optional_args: int
 
 
+class SourceValue(BaseModel):
+    name: str
+    visibility: SourceVisibility
+    visibility_intent: SourceVisibility
+    line_count: int
+    declaration_kind: SourceValueDeclarationKind
+    value_kind: SourceValueKind
+    declared_args: int = 0
+    optional_args: int = 0
+
+
+class SourceParameter(BaseModel):
+    name: str
+    annotation: str = ""
+    kind: SourceParameterKind
+    has_default: bool = False
+
+
+class SourceCallable(BaseModel):
+    id: str
+    source_id: str
+    name: str
+    qualified_name: str
+    owner_name: str = ""
+    kind: SourceCallableKind
+    visibility: SourceVisibility
+    visibility_intent: SourceVisibility
+    line_start: int
+    line_end: int
+    line_count: int
+    parameters: list[SourceParameter] = Field(default_factory=list)
+    declared_args: int = 0
+    optional_args: int = 0
+    return_annotation: str = ""
+    decorators: list[str] = Field(default_factory=list)
+    docstring: str = ""
+
+
+class SourceCall(BaseModel):
+    source_callable_id: str
+    target_callable_id: str = ""
+    source_id: str
+    line: int
+    expression: str
+    resolution: SourceCallResolution
+    target_name: str
+
+
 class SourceClassMethod(BaseModel):
     name: str
     visibility: SourceVisibility
@@ -131,6 +192,9 @@ class SourceFile(BaseModel):
     types: list[SourceType] = Field(default_factory=list)
     abstract_classes: list[SourceAbstractClass] = Field(default_factory=list)
     functions: list[SourceFunction]
+    values: list[SourceValue] = Field(default_factory=list)
+    callables: list[SourceCallable] = Field(default_factory=list)
+    calls: list[SourceCall] = Field(default_factory=list)
     line_count: int
     code_line_count: int
     public_symbol_count: int

{modwire-2.0.0 → modwire-2.2.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),

{modwire-2.0.0 → modwire-2.2.0}/src/modwire/extraction/models.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ..definitions import SourceFile
+from ..definitions import SourceCall, SourceCallable, SourceFile
 from ..graph import DependencyGraph, Edge
 from .roots import SourceIdMode
 
@@ -58,6 +58,54 @@ class CodeMap:
     def external_edges(self) -> tuple[Edge, ...]:
         return self.graph.external_edges(self.source_ids())
 
+    def callable_ids(self) -> tuple[str, ...]:
+        return tuple(
+            source_callable.id
+            for source_file in self.extraction_result.files.values()
+            for source_callable in source_file.callables
+        )
+
+    def callable(self, callable_id: str) -> SourceCallable:
+        for source_file in self.extraction_result.files.values():
+            for source_callable in source_file.callables:
+                if source_callable.id == callable_id:
+                    return source_callable
+        raise KeyError(callable_id)
+
+    def calls_from(self, callable_id: str) -> tuple[SourceCall, ...]:
+        return tuple(
+            source_call
+            for source_file in self.extraction_result.files.values()
+            for source_call in source_file.calls
+            if source_call.source_callable_id == callable_id
+        )
+
+    def calls_to(self, callable_id: str) -> tuple[SourceCall, ...]:
+        return tuple(
+            source_call
+            for source_file in self.extraction_result.files.values()
+            for source_call in source_file.calls
+            if source_call.target_callable_id == callable_id
+        )
+
+    def callable_graph(self) -> DependencyGraph:
+        graph = DependencyGraph()
+        callable_ids = set(self.callable_ids())
+        for callable_id in sorted(callable_ids):
+            graph.add_node(callable_id, kind="callable")
+        for source_file in self.extraction_result.files.values():
+            for source_call in source_file.calls:
+                if (
+                    source_call.source_callable_id in callable_ids
+                    and source_call.target_callable_id in callable_ids
+                ):
+                    graph.add_edge(
+                        source_call.source_callable_id,
+                        source_call.target_callable_id,
+                        kind="call",
+                    )
+        return graph
+
     def tracked_only(self) -> CodeMap:
         return self.subgraph(self.source_ids())
 

{modwire-2.0.0 → modwire-2.2.0}/src/modwire/extraction/serialization.py

@@ -7,7 +7,8 @@ from ..graph import DependencyGraph, Edge, Node
 from .models import CodeMap, ExtractionResult, ExtractionSummary
 
 
-CODE_MAP_SCHEMA_VERSION = 1
+CODE_MAP_SCHEMA_VERSION = 2
+SUPPORTED_CODE_MAP_SCHEMA_VERSIONS = {1, CODE_MAP_SCHEMA_VERSION}
 
 
 class CodeMapSerializationError(ValueError):
@@ -55,7 +56,7 @@ def deserialize_code_map(
     cache_key: str = "",
 ) -> CodeMap:
     try:
-        if payload["schema_version"] != CODE_MAP_SCHEMA_VERSION:
+        if payload["schema_version"] not in SUPPORTED_CODE_MAP_SCHEMA_VERSIONS:
             raise CodeMapSerializationError(
                 f"Unsupported CodeMap schema version: {payload['schema_version']}"
             )