entrygraph 0.1.45__tar.gz → 0.1.46__tar.gz

{entrygraph-0.1.45 → entrygraph-0.1.46}/PKG-INFO

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

{entrygraph-0.1.45 → entrygraph-0.1.46}/src/entrygraph/detect/entrypoints/rust.py

@@ -15,6 +15,7 @@ import re
 
 from entrygraph.detect.entrypoints.base import (
     EntrypointRule,
+    compose_route,
     first_string_arg,
     register,
 )
@@ -58,10 +59,36 @@ def _rust_main(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+_AXUM_NEST_FN = re.compile(r",\s*([A-Za-z_]\w*)\s*\(")  # 2nd arg of nest: funcName(
+
+
+def _axum_nest_prefixes(x: FileExtraction) -> dict[str, str]:
+    """Map a router-builder function to the prefix it's nested under:
+    `.nest("/admin", admin_routes())` -> {admin_routes: "/admin"} (#36).
+
+    axum's other nest form, `.nest("/x", router_var)`, mounts a router built inline
+    in the same function as everything else, so its routes can't be told apart by
+    caller — that variable form stays out of static reach.
+    """
+    prefixes: dict[str, str] = {}
+    for ref in x.references:
+        if ref.kind != "call" or ref.callee_name != "nest" or not ref.arg_preview:
+            continue
+        prefix = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        if prefix is None or not prefix.startswith("/"):
+            continue
+        m = _AXUM_NEST_FN.search(ref.arg_preview)
+        if m:
+            prefixes[m.group(1)] = prefix
+    return prefixes
+
+
 def _axum_routes(x: FileExtraction) -> list[EntrypointHint]:
     """`Router::new().route("/x", post(handler))` — the handler is buried in the
     second argument, so we regex it out of the preview but can't statically bind
-    it (the Express-rule fidelity tradeoff)."""
+    it (the Express-rule fidelity tradeoff). Routes declared inside a function that
+    is `.nest("/prefix", fn())`-mounted are composed with that prefix."""
+    nest_prefixes = _axum_nest_prefixes(x)
     hints = []
     for ref in x.references:
         if ref.kind != "call" or ref.callee_name != "route" or not ref.arg_preview:
@@ -70,12 +97,15 @@ def _axum_routes(x: FileExtraction) -> list[EntrypointHint]:
         if route is None or not route.startswith("/"):
             continue
         method, handler = _axum_method_and_handler(ref.arg_preview)
+        # the enclosing router-builder function, if it's mounted under a nest prefix
+        builder = (ref.caller_qualified_name or "").rsplit(".", 1)[-1]
+        full = compose_route(nest_prefixes.get(builder, ""), route)
         hints.append(
             EntrypointHint(
                 rule_id="rust.axum.route",
                 kind=EntrypointKind.HTTP_ROUTE,
                 handler_qualified_name=None,
-                route=route,
+                route=full,
                 http_methods=[method],
                 framework="axum",
                 metadata={"handler_text": handler, "registration": ref.arg_preview},

entrygraph-0.1.46/tests/test_entrypoints_rust.py

@@ -0,0 +1,53 @@
+"""Rust entrypoint-rule tests (kept per-language so PRs touching different
+languages don't serially conflict on one shared test module)."""
+
+from __future__ import annotations
+
+from entrygraph.detect.entrypoints import rules_for
+from entrygraph.extract.base import FileContext
+from entrygraph.extract.rust import RustExtractor
+from entrygraph.parsing.parsers import parse
+
+
+def _axum_rule():
+    return {r.id: r for r in rules_for("rust", {"axum"})}["rust.axum.route"]
+
+
+def _extract(src: bytes, path="src/main.rs"):
+    ctx = FileContext(path=path, language="rust", module_path="main", source=src, is_package=False)
+    return RustExtractor().extract(parse("rust", src), ctx)
+
+
+def test_axum_nest_prefix_composed_for_function_router():
+    # `.nest("/admin", admin_routes())` prefixes the routes declared inside the
+    # admin_routes builder function; top-level routes stay unprefixed (#36).
+    src = (
+        b"fn admin_routes() -> Router {\n"
+        b"    Router::new()\n"
+        b'        .route("/keys", delete(delete_all_keys))\n'
+        b'        .route("/key/{key}", delete(remove_key))\n'
+        b"}\n"
+        b"async fn main() {\n"
+        b"    let app = Router::new()\n"
+        b'        .route("/keys", get(list_keys))\n'
+        b'        .nest("/admin", admin_routes());\n'
+        b"}\n"
+    )
+    got = {(h.http_methods[0], h.route) for h in _axum_rule().match(_extract(src))}
+    assert got == {
+        ("GET", "/keys"),  # top-level, no prefix
+        ("DELETE", "/admin/keys"),  # composed with the nest prefix
+        ("DELETE", "/admin/key/{key}"),
+    }
+
+
+def test_axum_routes_without_nest_are_unprefixed():
+    src = (
+        b"async fn main() {\n"
+        b"    let app = Router::new()\n"
+        b'        .route("/users", get(list_users))\n'
+        b'        .route("/users/{id}", get(get_user));\n'
+        b"}\n"
+    )
+    got = {(h.http_methods[0], h.route) for h in _axum_rule().match(_extract(src))}
+    assert got == {("GET", "/users"), ("GET", "/users/{id}")}