entrygraph 0.1.20__tar.gz → 0.1.22__tar.gz

{entrygraph-0.1.20 → entrygraph-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.20
+Version: 0.1.22
 Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
 Project-URL: Repository, https://github.com/brettbergin/entrygraph
 Author-email: Brett Bergin <brettberginbc@yahoo.com>

{entrygraph-0.1.20 → entrygraph-0.1.22}/src/entrygraph/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.20'
-__version_tuple__ = version_tuple = (0, 1, 20)
+__version__ = version = '0.1.22'
+__version_tuple__ = version_tuple = (0, 1, 22)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.20 → entrygraph-0.1.22}/src/entrygraph/extract/csharp.py

@@ -329,6 +329,7 @@ class CSharpExtractor:
             receiver = None
             callee_text = node_text(fn)
         args = node.child_by_field_name("arguments")
+        caller = self._caller(node, ctx)
         out.references.append(
             RawReference(
                 kind="call",
@@ -336,11 +337,35 @@ class CSharpExtractor:
                 callee_name=callee_name,
                 receiver_text=receiver,
                 span=span_of(node),
-                caller_qualified_name=self._caller(node, ctx),
+                caller_qualified_name=caller,
                 arg_count=len(args.named_children) if args is not None else 0,
                 arg_preview=truncate(node_text(args)) if args is not None else None,
             )
         )
+        self._emit_callbacks(args, caller, out)
+
+    def _emit_callbacks(self, args: Node | None, caller: str | None, out: FileExtraction) -> None:
+        """Method-group arguments passed to a call — a function value invoked later,
+        e.g. ``app.MapPost("/run", Handler)`` (minimal APIs). Each C# argument wraps
+        its expression; a bare identifier is a method group. Resolution keeps only
+        those binding to a project method."""
+        if args is None:
+            return
+        for arg in args.named_children:
+            expr = arg.named_children[0] if arg.type == "argument" and arg.named_children else arg
+            if expr is None or expr.type != "identifier":
+                continue
+            name = node_text(expr)
+            out.references.append(
+                RawReference(
+                    kind="callback",
+                    callee_text=name,
+                    callee_name=name,
+                    receiver_text=None,
+                    span=span_of(expr),
+                    caller_qualified_name=caller,
+                )
+            )
 
     def _add_object_creation(self, node: Node, ctx: FileContext, out: FileExtraction) -> None:
         type_node = node.child_by_field_name("type")

{entrygraph-0.1.20 → entrygraph-0.1.22}/src/entrygraph/extract/golang.py

@@ -252,6 +252,7 @@ class GoExtractor:
             else:
                 continue  # call of a call / index expr / etc. — not statically resolvable
             args = node.child_by_field_name("arguments")
+            caller = self._caller(node, ctx)
             out.references.append(
                 RawReference(
                     kind="call",
@@ -259,11 +260,12 @@ class GoExtractor:
                     callee_name=callee_name,
                     receiver_text=receiver,
                     span=span_of(node),
-                    caller_qualified_name=self._caller(node, ctx),
+                    caller_qualified_name=caller,
                     arg_count=len(args.named_children) if args is not None else 0,
                     arg_preview=truncate(node_text(args)) if args is not None else None,
                 )
             )
+            self._emit_callbacks(args, caller, out)
 
         for node in caps.get("composite.type", []):
             text = node_text(node)  # e.g. "cobra.Command"
@@ -278,6 +280,28 @@ class GoExtractor:
                 )
             )
 
+    def _emit_callbacks(self, args: Node | None, caller: str | None, out: FileExtraction) -> None:
+        """Bare-identifier arguments passed to a call — a function value that may be
+        invoked later, e.g. ``http.HandleFunc("/", handler)``. Resolution keeps only
+        those binding to a project function, so passing a plain data value is a
+        harmless no-op edge."""
+        if args is None:
+            return
+        for arg in args.named_children:
+            if arg.type != "identifier":
+                continue
+            name = node_text(arg)
+            out.references.append(
+                RawReference(
+                    kind="callback",
+                    callee_text=name,
+                    callee_name=name,
+                    receiver_text=None,
+                    span=span_of(arg),
+                    caller_qualified_name=caller,
+                )
+            )
+
     # ---------------- walking helpers ----------------
 
     def _receiver_type(self, method: Node) -> str | None:

entrygraph-0.1.22/tests/fixtures/csharp/minimalapi_app/Program.cs

@@ -0,0 +1,15 @@
+class Program
+{
+    static void Main()
+    {
+        var app = Build();
+        app.MapPost("/run", Handler);
+    }
+
+    static void Handler()
+    {
+        System.Diagnostics.Process.Start("sh", "-c");
+    }
+
+    static object Build() { return null; }
+}

entrygraph-0.1.22/tests/fixtures/csharp/minimalapi_app/app.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+</Project>

entrygraph-0.1.22/tests/fixtures/go/nethttp_app/go.mod

@@ -0,0 +1,3 @@
+module example.com/app
+
+go 1.21

entrygraph-0.1.22/tests/fixtures/go/nethttp_app/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"net/http"
+	"os/exec"
+)
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	exec.Command("sh", "-c", r.URL.Query().Get("cmd"))
+}
+
+func main() {
+	http.HandleFunc("/run", handler)
+	http.ListenAndServe(":8080", nil)
+}

entrygraph-0.1.22/tests/test_csharp_callbacks.py

@@ -0,0 +1,46 @@
+"""End-to-end: C# method-group callbacks connect minimal-API handlers to their
+registration site (Phase 4).
+
+Regression: the C# extractor emitted no callback references, so a handler passed
+to `app.MapPost("/run", Handler)` had no inbound edge and was unreachable.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from entrygraph import CodeGraph
+
+MINIMALAPI_APP = Path(__file__).parent / "fixtures" / "csharp" / "minimalapi_app"
+
+
+@pytest.fixture(scope="module")
+def graph(tmp_path_factory) -> CodeGraph:
+    db = tmp_path_factory.mktemp("db") / "graph.db"
+    g = CodeGraph.index(MINIMALAPI_APP, db=db)
+    yield g
+    g.close()
+
+
+def test_callback_edge_created(graph):
+    rows = graph.sql(
+        "SELECT src.qname AS src, e.dst_qname AS dst FROM edges e "
+        "JOIN symbols src ON e.src_symbol_id = src.id WHERE e.kind = 'callback'"
+    )
+    pairs = {(r["src"], r["dst"]) for r in rows}
+    assert ("Program.Program.Main", "Program.Program.Handler") in pairs
+
+
+def test_handler_reachable_only_with_callbacks(graph):
+    kw = {
+        "source": "Program.Program.Main",
+        "sink_category": "command_exec",
+        "include_unresolved": True,
+    }
+    assert graph.paths(**kw) == []
+    withcb = graph.paths(**kw, include_callbacks=True)
+    assert withcb
+    assert "Program.Program.Handler" in [s.qname for s in withcb[0].symbols]
+    assert withcb[0].symbols[-1].qname == "cs:System.Diagnostics.Process.Start"

{entrygraph-0.1.20 → entrygraph-0.1.22}/tests/test_extract_csharp.py

@@ -202,6 +202,27 @@ public class C
     assert calls["SqlCommand"].receiver_text is None
 
 
+def test_method_group_argument_is_a_callback():
+    # app.MapPost("/run", Handler) passes `Handler` as a method group; it must be
+    # a callback so the handler is reachable from the registration site.
+    x = extract(
+        """
+namespace App {
+    class Program {
+        static void Setup(object app) {
+            app.MapPost("/run", Handler);
+        }
+        static void Handler() {}
+    }
+}
+"""
+    )
+    callbacks = {r.callee_name: r for r in x.references if r.kind == "callback"}
+    assert "Handler" in callbacks
+    assert callbacks["Handler"].caller_qualified_name == "App.Program.Setup"
+    assert "/run" not in callbacks  # string literal arg is not a callback
+
+
 # ---------------- unit: partial class (duplicate qnames) ----------------
 
 

{entrygraph-0.1.20 → entrygraph-0.1.22}/tests/test_extract_go.py

@@ -167,6 +167,29 @@ func helper() {}
     assert "ls" in exec_call.arg_preview
 
 
+def test_function_value_argument_is_a_callback():
+    # http.HandleFunc("/", handler) passes `handler` as a value; it must be
+    # emitted as a callback so the handler is reachable from the registration site.
+    x = extract(
+        """
+package server
+
+import "net/http"
+
+func register() {
+	http.HandleFunc("/run", handler)
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {}
+"""
+    )
+    callbacks = {r.callee_name: r for r in x.references if r.kind == "callback"}
+    assert "handler" in callbacks
+    assert callbacks["handler"].caller_qualified_name == "cmd.server.register"
+    # string/other literal args are not callbacks
+    assert "/run" not in callbacks
+
+
 def test_partial_tree_still_extracts():
     x = extract("package p\n\nfunc good() {}\n\nfunc broken( {\n")
     assert not x.parse_ok

entrygraph-0.1.22/tests/test_go_callbacks.py

@@ -0,0 +1,45 @@
+"""End-to-end: Go function-value callbacks connect handlers to their registration
+site (Phase 4).
+
+Regression: the Go extractor emitted no callback references, so a handler passed
+to `http.HandleFunc("/", handler)` had no inbound edge — its body (and any sink it
+reached) was unreachable in the call graph.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from entrygraph import CodeGraph
+
+NETHTTP_APP = Path(__file__).parent / "fixtures" / "go" / "nethttp_app"
+
+
+@pytest.fixture(scope="module")
+def graph(tmp_path_factory) -> CodeGraph:
+    db = tmp_path_factory.mktemp("db") / "graph.db"
+    g = CodeGraph.index(NETHTTP_APP, db=db)
+    yield g
+    g.close()
+
+
+def test_callback_edge_created(graph):
+    rows = graph.sql(
+        "SELECT src.qname AS src, e.dst_qname AS dst FROM edges e "
+        "JOIN symbols src ON e.src_symbol_id = src.id WHERE e.kind = 'callback'"
+    )
+    pairs = {(r["src"], r["dst"]) for r in rows}
+    assert ("_root.main", "_root.handler") in pairs
+
+
+def test_handler_reachable_only_with_callbacks(graph):
+    kw = {"source": "_root.main", "sink_category": "command_exec", "include_unresolved": True}
+    # without callback traversal the handler is severed from main
+    assert graph.paths(**kw) == []
+    # with it, main -> handler -> exec.Command resolves
+    withcb = graph.paths(**kw, include_callbacks=True)
+    assert withcb
+    assert withcb[0].symbols[-1].qname == "go:os/exec.Command"
+    assert "_root.handler" in [s.qname for s in withcb[0].symbols]