entrygraph 0.1.35__tar.gz → 0.1.37__tar.gz

{entrygraph-0.1.35 → entrygraph-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.35
+Version: 0.1.37
 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.35 → entrygraph-0.1.37}/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.35'
-__version_tuple__ = version_tuple = (0, 1, 35)
+__version__ = version = '0.1.37'
+__version_tuple__ = version_tuple = (0, 1, 37)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.35 → entrygraph-0.1.37}/src/entrygraph/detect/entrypoints/golang.py

@@ -3,6 +3,8 @@ registration, gin router routes, and cobra CLI commands."""
 
 from __future__ import annotations
 
+import re
+
 from entrygraph.detect.entrypoints.base import (
     EntrypointRule,
     first_string_arg,
@@ -114,30 +116,51 @@ def _gin_style(framework: str):
     return matcher
 
 
+_QUOTED = re.compile(r'"([^"]+)"')
+
+
 def _gorilla_routes(x: FileExtraction) -> list[EntrypointHint]:
-    """gorilla/mux: r.HandleFunc('/x', handler)."""
-    hints = []
+    """gorilla/mux, including the chained builder forms.
+
+    A registration is a method chain on one statement:
+        r.HandleFunc("/x", h).Methods("GET")
+        r.Path("/x").Methods("GET", "POST").HandlerFunc(h)
+    so the route (Path/HandleFunc), verb(s) (Methods) and handler are aggregated
+    per line. Previously only bare HandleFunc was matched — the `.Path().Methods()`
+    form and any `.Methods()` verb were dropped (loki: ~0% of gorilla routes).
+    """
+    routes: dict[int, str] = {}
+    methods: dict[int, list[str]] = {}
+    handlers: dict[int, str | None] = {}
     for ref in x.references:
-        if (
-            ref.kind == "call"
-            and ref.callee_name in ("HandleFunc", "Handle")
-            and ref.receiver_text not in (None, "http")
-            and ref.arg_preview
-        ):
+        if ref.kind != "call" or not ref.arg_preview:
+            continue
+        line = ref.span.start_line
+        # a route is opened by HandleFunc("/x", h) or Path("/x") on the router;
+        # exclude net/http's own http.HandleFunc.
+        defines_route = (
+            ref.callee_name in ("HandleFunc", "Handle") and ref.receiver_text not in (None, "http")
+        ) or (ref.callee_name == "Path" and ref.receiver_text is not None)
+        if defines_route:
             route = first_string_arg("(" + ref.arg_preview.lstrip("("))
             if route is not None and route.startswith("/"):
-                hints.append(
-                    EntrypointHint(
-                        rule_id="go.gorilla-mux.route",
-                        kind=EntrypointKind.HTTP_ROUTE,
-                        handler_qualified_name=ref.caller_qualified_name,
-                        route=route,
-                        http_methods=["*"],
-                        framework="gorilla-mux",
-                        metadata={"registration": ref.arg_preview},
-                    )
-                )
-    return hints
+                routes.setdefault(line, route)
+                handlers.setdefault(line, ref.caller_qualified_name)
+        elif ref.callee_name == "Methods":
+            verbs = [v.upper() for v in _QUOTED.findall(ref.arg_preview)]
+            if verbs:
+                methods.setdefault(line, []).extend(verbs)
+    return [
+        EntrypointHint(
+            rule_id="go.gorilla-mux.route",
+            kind=EntrypointKind.HTTP_ROUTE,
+            handler_qualified_name=handlers.get(line),
+            route=route,
+            http_methods=methods.get(line, ["*"]),
+            framework="gorilla-mux",
+        )
+        for line, route in routes.items()
+    ]
 
 
 def _cobra_commands(x: FileExtraction) -> list[EntrypointHint]:

{entrygraph-0.1.35 → entrygraph-0.1.37}/src/entrygraph/detect/entrypoints/php.py

@@ -21,21 +21,49 @@ from entrygraph.extract.ir import EntrypointHint, FileExtraction
 from entrygraph.kinds import EntrypointKind, SymbolKind
 
 _LARAVEL_VERBS = frozenset({"get", "post", "put", "delete", "patch", "any", "match"})
+_LARAVEL_RESOURCE = frozenset({"resource", "apiResource"})
 _SYMFONY_ROUTE = re.compile(r"#\[\s*Route\s*\(")
 _WORDPRESS_HOOKS = frozenset({"add_action", "add_filter"})
 
 
+def _resource_param(name: str) -> str:
+    """The Laravel resource param: singular of the last (dot-nested) segment —
+    `photos` -> `{photo}`, `blog.comments` -> `{comment}`."""
+    seg = name.strip("/").split(".")[-1]
+    singular = seg[:-1] if seg.endswith("s") and not seg.endswith("ss") else seg
+    return "{" + (singular or "id") + "}"
+
+
+def _resource_routes(name: str, is_api: bool) -> list[tuple[str, str]]:
+    """Expand Route::resource/apiResource into its REST (method, path) routes.
+
+    apiResource omits the HTML create/edit forms that resource adds.
+    """
+    base = "/" + name.strip("/").replace(".", "/")
+    param = _resource_param(name)
+    routes = [
+        ("GET", base),  # index
+        ("POST", base),  # store
+        ("GET", f"{base}/{param}"),  # show
+        ("PUT", f"{base}/{param}"),  # update
+        ("DELETE", f"{base}/{param}"),  # destroy
+    ]
+    if not is_api:
+        routes += [
+            ("GET", f"{base}/create"),  # create form
+            ("GET", f"{base}/{param}/edit"),  # edit form
+        ]
+    return routes
+
+
 def _laravel_routes(x: FileExtraction) -> list[EntrypointHint]:
     if not re.search(r"(^|/)routes/[^/]+\.php$", x.path):
         return []
     hints = []
     for ref in x.references:
-        if (
-            ref.kind == "call"
-            and ref.receiver_text == "Route"
-            and ref.callee_name in _LARAVEL_VERBS
-            and ref.arg_preview
-        ):
+        if ref.kind != "call" or ref.receiver_text != "Route" or not ref.arg_preview:
+            continue
+        if ref.callee_name in _LARAVEL_VERBS:
             route = first_string_arg("(" + ref.arg_preview.lstrip("("))
             hints.append(
                 EntrypointHint(
@@ -50,6 +78,24 @@ def _laravel_routes(x: FileExtraction) -> list[EntrypointHint]:
                     metadata={"registration": ref.arg_preview},
                 )
             )
+        elif ref.callee_name in _LARAVEL_RESOURCE:
+            # Route::resource('photos', Ctrl) / apiResource(...) registers a fixed
+            # set of REST routes at once; expand them so they aren't all missed.
+            name = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            if not name:
+                continue
+            for method, route in _resource_routes(name, ref.callee_name == "apiResource"):
+                hints.append(
+                    EntrypointHint(
+                        rule_id="php.laravel.resource",
+                        kind=EntrypointKind.HTTP_ROUTE,
+                        handler_qualified_name=None,
+                        route=route,
+                        http_methods=[method],
+                        framework="laravel",
+                        metadata={"registration": ref.arg_preview},
+                    )
+                )
     return hints
 
 

{entrygraph-0.1.35 → entrygraph-0.1.37}/tests/test_entrypoint_expansion.py

@@ -440,3 +440,83 @@ def test_rails_routes_read_from_split_route_files():
     assert [h.route for h in main] == ["/health"]
     assert [h.route for h in split] == ["/users"]  # the split file is now read
     assert unrelated == []  # a non-routes file is still ignored
+
+
+def test_laravel_resource_expansion():
+    from entrygraph.detect.entrypoints.php import _resource_routes
+
+    api = _resource_routes("articles", is_api=True)
+    assert set(api) == {
+        ("GET", "/articles"),
+        ("POST", "/articles"),
+        ("GET", "/articles/{article}"),
+        ("PUT", "/articles/{article}"),
+        ("DELETE", "/articles/{article}"),
+    }
+    # resource() adds the HTML create/edit forms that apiResource omits
+    full = dict.fromkeys(r for r in _resource_routes("photos", is_api=False))
+    assert ("GET", "/photos/create") in full
+    assert ("GET", "/photos/{photo}/edit") in full
+    assert len(full) == 7
+    # nested resource: last segment is singularized, dots become path separators
+    nested = _resource_routes("blog.comments", is_api=True)
+    assert ("GET", "/blog/comments/{comment}") in nested
+
+
+def test_laravel_apiresource_rule_emits_rest_routes():
+    from entrygraph.detect.entrypoints import rules_for
+
+    ref = RawReference(
+        kind="call",
+        callee_text="Route::apiResource",
+        callee_name="apiResource",
+        receiver_text="Route",
+        span=SPAN,
+        caller_qualified_name=None,
+        arg_preview="('articles', ArticleController::class)",
+    )
+    x = FileExtraction(
+        path="routes/api.php",
+        language="php",
+        module_path="routes.api",
+        parse_ok=True,
+        error_count=0,
+        symbols=[],
+        references=[ref],
+    )
+    rule = {r.id: r for r in rules_for("php", {"laravel"})}["php.laravel.route"]
+    got = {(h.http_methods[0], h.route) for h in rule.match(x)}
+    assert ("GET", "/articles") in got and ("DELETE", "/articles/{article}") in got
+    assert ("GET", "/articles/create") not in got  # apiResource omits forms
+
+
+def _go_call_ref(callee, receiver, arg, line=1):
+    return RawReference(
+        kind="call",
+        callee_text=f"{receiver}.{callee}",
+        callee_name=callee,
+        receiver_text=receiver,
+        span=Span(line, 0, line, 40),
+        caller_qualified_name="app.setup",
+        arg_preview=arg,
+    )
+
+
+def test_gorilla_chained_routes_and_methods():
+    # gorilla registrations are method chains on one statement; the route (Path/
+    # HandleFunc) and verb(s) (Methods) must be aggregated per line (#37).
+    from entrygraph.detect.entrypoints import rules_for
+
+    refs = [
+        # r.HandleFunc("/users", h).Methods("GET")   (line 1)
+        _go_call_ref("HandleFunc", "r", '("/users", listUsers)', line=1),
+        _go_call_ref("Methods", 'r.HandleFunc("/users", listUsers)', '("GET")', line=1),
+        # r.Path("/reports").Methods("POST", "PUT").Handler(h)   (line 2)
+        _go_call_ref("Path", "r", '("/reports")', line=2),
+        _go_call_ref("Methods", 'r.Path("/reports")', '("POST", "PUT")', line=2),
+        _go_call_ref("Handler", 'r.Path("/reports").Methods("POST", "PUT")', "(h)", line=2),
+    ]
+    rule = {r.id: r for r in rules_for("go", {"gorilla-mux"})}["go.gorilla-mux.route"]
+    got = {(tuple(h.http_methods), h.route) for h in rule.match(_go_ext(refs))}
+    assert (("GET",), "/users") in got  # HandleFunc route + chained method
+    assert (("POST", "PUT"), "/reports") in got  # Path().Methods().Handler() form