entrygraph 0.1.46__tar.gz → 0.1.47__tar.gz

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

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

{entrygraph-0.1.46 → entrygraph-0.1.47}/src/entrygraph/detect/entrypoints/csharp.py

@@ -25,6 +25,9 @@ from entrygraph.kinds import EntrypointKind, SymbolKind
 _HTTP_ATTR = re.compile(r"^\[Http(Get|Post|Put|Delete|Patch|Head|Options)\b")
 _ROUTE_ATTR = re.compile(r"^\[Route\b")
 _CONTROLLER_ATTR = re.compile(r"^\[(ApiController|Controller)\b")
+_APICONTROLLER_ATTR = re.compile(r"^\[ApiController\b")
+_AREA_ATTR = re.compile(r"^\[Area\b")
+_NONACTION_ATTR = re.compile(r"^\[NonAction\b")
 
 _MINIMAL_MAP = {
     "MapGet": "GET",
@@ -64,45 +67,93 @@ def _class_route_prefix(t: RawSymbol) -> str:
     return prefix.replace("[controller]", _controller_token(t.qualified_name))
 
 
+def _is_conventional_controller(t: RawSymbol) -> bool:
+    """A classic MVC controller reached by convention (`{controller}/{action}`),
+    not attribute routing. `[ApiController]` mandates attribute routing, and a
+    class-level `[Route]` opts the whole controller into attribute routing, so
+    neither can be convention-routed."""
+    return not any(_APICONTROLLER_ATTR.match(d) or _ROUTE_ATTR.match(d) for d in t.decorators)
+
+
+def _is_action_method(m: RawSymbol, ctor_name: str) -> bool:
+    """A public instance method that MVC exposes as a convention-routed action.
+
+    Excludes constructors, static/override members (framework overrides like
+    `OnActionExecuting`), `[NonAction]`, and anything already carrying an
+    `[Http*]`/`[Route]` attribute (handled by the attribute-routing branches)."""
+    if "public" not in m.modifiers or "static" in m.modifiers or "override" in m.modifiers:
+        return False
+    if m.name == ctor_name:
+        return False
+    return not any(
+        _NONACTION_ATTR.match(d) or _HTTP_ATTR.match(d) or _ROUTE_ATTR.match(d)
+        for d in m.decorators
+    )
+
+
+def _conventional_route(t: RawSymbol, action: str) -> str:
+    """`[Area("Admin")]` + FooController + Bar -> /Admin/Foo/Bar."""
+    area_dec = next((d for d in t.decorators if _AREA_ATTR.match(d)), None)
+    area = (first_string_arg(area_dec) if area_dec else None) or ""
+    parts = [area, _controller_token(t.qualified_name), action]
+    return "/" + "/".join(p.strip("/") for p in parts if p and p.strip("/"))
+
+
 def _aspnet_controller_routes(x: FileExtraction) -> list[EntrypointHint]:
     controller_syms = [t for t in _type_symbols(x) if _is_controller(t)]
     controllers = {t.qualified_name for t in controller_syms}
     if not controllers:
         return []
     prefixes = {t.qualified_name: _class_route_prefix(t) for t in controller_syms}
+    # controllers reached by convention -> their symbol, for building /controller/action
+    conventional = {t.qualified_name: t for t in controller_syms if _is_conventional_controller(t)}
     hints: list[EntrypointHint] = []
     for method in _methods(x):
-        if method.parent_qualified_name not in controllers:
+        parent = method.parent_qualified_name or ""
+        if parent not in controllers:
             continue
-        prefix = prefixes.get(method.parent_qualified_name or "", "")
-        for decorator in method.decorators:
-            m = _HTTP_ATTR.match(decorator)
-            if m:
-                hints.append(
-                    EntrypointHint(
-                        rule_id="csharp.aspnet.controller-route",
-                        kind=EntrypointKind.HTTP_ROUTE,
-                        handler_qualified_name=method.qualified_name,
-                        route=compose_route(prefix, first_string_arg(decorator)),
-                        http_methods=[m.group(1).upper()],
-                        framework="aspnetcore",
-                    )
+        prefix = prefixes.get(parent, "")
+        verb_match = next((m for d in method.decorators if (m := _HTTP_ATTR.match(d))), None)
+        if verb_match is not None:
+            hints.append(
+                EntrypointHint(
+                    rule_id="csharp.aspnet.controller-route",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=method.qualified_name,
+                    route=compose_route(prefix, first_string_arg(verb_match.string)),
+                    http_methods=[verb_match.group(1).upper()],
+                    framework="aspnetcore",
                 )
-                break
-        else:
-            # No Http* verb attribute; a bare [Route("...")] still exposes it.
-            route_dec = next((d for d in method.decorators if _ROUTE_ATTR.match(d)), None)
-            if route_dec is not None:
-                hints.append(
-                    EntrypointHint(
-                        rule_id="csharp.aspnet.controller-route",
-                        kind=EntrypointKind.HTTP_ROUTE,
-                        handler_qualified_name=method.qualified_name,
-                        route=compose_route(prefix, first_string_arg(route_dec)),
-                        http_methods=["*"],
-                        framework="aspnetcore",
-                    )
+            )
+            continue
+        # No Http* verb attribute; a bare [Route("...")] still exposes it.
+        route_dec = next((d for d in method.decorators if _ROUTE_ATTR.match(d)), None)
+        if route_dec is not None:
+            hints.append(
+                EntrypointHint(
+                    rule_id="csharp.aspnet.controller-route",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=method.qualified_name,
+                    route=compose_route(prefix, first_string_arg(route_dec)),
+                    http_methods=["*"],
+                    framework="aspnetcore",
                 )
+            )
+            continue
+        # No attribute at all: a convention-routed MVC action (/controller/action),
+        # reachable via GET. Only for non-attribute controllers (#37).
+        controller = conventional.get(parent)
+        if controller is not None and _is_action_method(method, controller.name):
+            hints.append(
+                EntrypointHint(
+                    rule_id="csharp.aspnet.mvc-conventional",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=method.qualified_name,
+                    route=_conventional_route(controller, method.name),
+                    http_methods=["GET"],
+                    framework="aspnetcore",
+                )
+            )
     return hints
 
 

entrygraph-0.1.47/tests/test_entrypoints_csharp.py

@@ -0,0 +1,75 @@
+"""C# 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.csharp import CSharpExtractor
+from entrygraph.parsing.parsers import parse
+
+
+def _controller_rule():
+    return {r.id: r for r in rules_for("csharp", {"aspnetcore"})}["csharp.aspnet.controller-route"]
+
+
+def _extract(src: bytes, path="Controllers/C.cs", module="App.Controllers"):
+    ctx = FileContext(
+        path=path, language="csharp", module_path=module, source=src, is_package=False
+    )
+    return CSharpExtractor().extract(parse("csharp", src), ctx)
+
+
+def test_conventional_mvc_actions_detected():
+    # Non-attribute controller: public actions route to /{controller}/{action} via
+    # GET; constructors, [NonAction], override, and [HttpPost] methods are excluded
+    # (the POST one is emitted by the attribute branch instead) (#37).
+    src = (
+        b"namespace App.Controllers;\n"
+        b"public class HomeController : Controller\n{\n"
+        b"    public HomeController() {}\n"
+        b"    public IActionResult Index() { return View(); }\n"
+        b"    public async Task<IActionResult> About() { return View(); }\n"
+        b"    [NonAction] public void Helper() {}\n"
+        b"    public override void OnActionExecuting() {}\n"
+        b"}\n"
+    )
+    got = {(tuple(h.http_methods), h.route) for h in _controller_rule().match(_extract(src))}
+    assert got == {(("GET",), "/Home/Index"), (("GET",), "/Home/About")}
+
+
+def test_conventional_route_includes_area_prefix():
+    src = (
+        b"namespace App.Areas.Admin.Controllers;\n"
+        b'[Area("Admin")]\n'
+        b"public class DashboardController : Controller\n{\n"
+        b"    public IActionResult Stats() { return View(); }\n"
+        b"}\n"
+    )
+    got = {h.route for h in _controller_rule().match(_extract(src))}
+    assert got == {"/Admin/Dashboard/Stats"}
+
+
+def test_api_controllers_are_not_convention_routed():
+    # [ApiController] and a class-level [Route] both mandate attribute routing, so a
+    # bare public method must NOT get a convention route.
+    src = (
+        b"namespace App.Controllers;\n"
+        b"[ApiController]\n"
+        b'[Route("api/[controller]")]\n'
+        b"public class ThingsController : ControllerBase\n{\n"
+        b"    public IActionResult NoAttr() { return Ok(); }\n"
+        b"}\n"
+    )
+    assert _controller_rule().match(_extract(src)) == []
+
+
+def test_attribute_routes_still_win_over_convention():
+    src = (
+        b"namespace App.Controllers;\n"
+        b"public class HomeController : Controller\n{\n"
+        b'    [HttpGet("ping")] public IActionResult Ping() { return Ok(); }\n'
+        b"}\n"
+    )
+    got = {(tuple(h.http_methods), h.route) for h in _controller_rule().match(_extract(src))}
+    assert got == {(("GET",), "/ping")}  # attribute route, not /Home/Ping