entrygraph 0.1.43__tar.gz → 0.1.45__tar.gz

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

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

{entrygraph-0.1.43 → entrygraph-0.1.45}/src/entrygraph/detect/entrypoints/golang.py

@@ -22,6 +22,12 @@ _GIN_METHODS = (
 _NETHTTP_REGISTER = frozenset({"HandleFunc", "Handle"})
 
 
+def _is_go_test(path: str) -> bool:
+    """Go test files (`*_test.go`) register routes only to exercise handlers; those
+    are test-harness calls, not the production route surface (#33)."""
+    return path.endswith("_test.go")
+
+
 def _go_main(x: FileExtraction) -> list[EntrypointHint]:
     hints = []
     for symbol in x.symbols:
@@ -43,6 +49,8 @@ def _go_main(x: FileExtraction) -> list[EntrypointHint]:
 
 
 def _nethttp_routes(x: FileExtraction) -> list[EntrypointHint]:
+    if _is_go_test(x.path):
+        return []
     hints = []
     for ref in x.references:
         if (
@@ -101,6 +109,8 @@ def _group_prefixes(x: FileExtraction) -> dict[str, str]:
 
 
 def _gin_routes(x: FileExtraction) -> list[EntrypointHint]:
+    if _is_go_test(x.path):
+        return []
     prefixes = _group_prefixes(x)
     hints = []
     for ref in x.references:
@@ -172,6 +182,8 @@ def _chi_routes(x: FileExtraction) -> list[EntrypointHint]:
     falls inside a Route call's span gets that prefix (nested Routes stack). Mount
     (`r.Mount("/api", subRouter())`) points at a router built in another function,
     which is out of static reach, so its prefix isn't composed."""
+    if _is_go_test(x.path):
+        return []
     scopes: list[tuple[int, int, str]] = []
     for ref in x.references:
         if (
@@ -229,6 +241,8 @@ def _gorilla_routes(x: FileExtraction) -> list[EntrypointHint]:
     per line. Previously only bare HandleFunc was matched — the `.Path().Methods()`
     form and any `.Methods()` verb were dropped (loki: ~0% of gorilla routes).
     """
+    if _is_go_test(x.path):
+        return []
     routes: dict[int, str] = {}
     methods: dict[int, list[str]] = {}
     handlers: dict[int, str | None] = {}
@@ -297,7 +311,7 @@ def _grpc_services(x: FileExtraction) -> list[EntrypointHint]:
     `route` — the Entrypoint row has no name column, and it keeps distinct services
     from collapsing in dedup (they all share `handler_qualified_name=None`).
     """
-    if x.path.endswith("_test.go"):
+    if _is_go_test(x.path):
         return []  # test harnesses spin up real services; not production surface (#33)
     hints = []
     seen: set[str] = set()

{entrygraph-0.1.43 → entrygraph-0.1.45}/src/entrygraph/detect/entrypoints/php.py

@@ -14,6 +14,7 @@ import re
 
 from entrygraph.detect.entrypoints.base import (
     EntrypointRule,
+    compose_route,
     first_string_arg,
     register,
 )
@@ -23,6 +24,12 @@ 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*\(")
+# Symfony route paths can be positional (`#[Route('/x')]`) or the `path:` named arg
+# (`#[Route(path: '/x')]`); methods live in `methods: ['GET', 'POST']` (or a bare
+# string). `first_string_arg` covers the positional case.
+_SYMFONY_PATH_KW = re.compile(r"""path\s*:\s*['"]([^'"]+)['"]""")
+_SYMFONY_METHODS = re.compile(r"""methods\s*:\s*(?:\[([^\]]*)\]|['"]([^'"]+)['"])""")
+_QUOTED_RE = re.compile(r"""['"]([^'"]+)['"]""")
 _WORDPRESS_HOOKS = frozenset({"add_action", "add_filter"})
 # register_rest_route($namespace, $route, ...). Anchor to the first two positional
 # args: arg 1 is the namespace (a literal like 'wp/v2' or a variable such as
@@ -160,20 +167,50 @@ def _laravel_routes(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+def _symfony_path(decorator: str) -> str | None:
+    """The route path from a `#[Route(...)]` attribute: the `path:` named arg if
+    present, else the first positional string."""
+    m = _SYMFONY_PATH_KW.search(decorator)
+    return m.group(1) if m else first_string_arg(decorator)
+
+
+def _symfony_methods(decorator: str) -> list[str]:
+    """HTTP verbs from `methods: ['GET', 'POST']` / `methods: 'GET'`; empty if the
+    attribute omits `methods` (Symfony then allows all verbs)."""
+    m = _SYMFONY_METHODS.search(decorator)
+    if not m:
+        return []
+    body = m.group(1) if m.group(1) is not None else m.group(2)
+    verbs = [q.upper() for q in _QUOTED_RE.findall(body)]
+    if not verbs and body.strip():  # unquoted single value
+        verbs = [body.strip().upper()]
+    return verbs
+
+
 def _symfony_routes(x: FileExtraction) -> list[EntrypointHint]:
+    # class qname -> class-level #[Route(...)] path prefix (composed onto each
+    # method route, mirroring @Controller in NestJS and @RequestMapping in Spring).
+    prefixes: dict[str, str] = {}
+    for symbol in x.symbols:
+        if symbol.kind is SymbolKind.CLASS:
+            for decorator in symbol.decorators:
+                if _SYMFONY_ROUTE.search(decorator):
+                    prefixes[symbol.qualified_name] = _symfony_path(decorator) or ""
+                    break
     hints = []
     for symbol in x.symbols:
         if symbol.kind not in (SymbolKind.METHOD, SymbolKind.FUNCTION):
             continue
         for decorator in symbol.decorators:
             if _SYMFONY_ROUTE.search(decorator):
+                prefix = prefixes.get(symbol.parent_qualified_name or "", "")
                 hints.append(
                     EntrypointHint(
                         rule_id="php.symfony.route",
                         kind=EntrypointKind.HTTP_ROUTE,
                         handler_qualified_name=symbol.qualified_name,
-                        route=first_string_arg(decorator) or "",
-                        http_methods=["*"],
+                        route=compose_route(prefix, _symfony_path(decorator)),
+                        http_methods=_symfony_methods(decorator) or ["*"],
                         framework="symfony",
                     )
                 )

{entrygraph-0.1.43 → entrygraph-0.1.45}/src/entrygraph/detect/entrypoints/ruby.py

@@ -21,6 +21,15 @@ _SINATRA_VERBS = frozenset({"get", "post", "put", "delete", "patch"})
 _RAILS_VERBS = frozenset({"get", "post", "put", "patch", "delete", "resources", "resource", "root"})
 
 
+def _is_ruby_test(path: str) -> bool:
+    """RSpec / Test::Unit files. Rack::Test reuses the bare `get '/x'` verb DSL
+    inside specs, indistinguishable from a Sinatra/Grape route declaration, so those
+    files must not contribute to the route surface (#33)."""
+    return (
+        path.endswith(("_spec.rb", "_test.rb")) or "/spec/" in f"/{path}" or "/test/" in f"/{path}"
+    )
+
+
 def _is_rails_routes_file(path: str) -> bool:
     """The main `config/routes.rb` plus split route files loaded via `draw(:x)`
     (`config/routes/api.rb`, `config/routes/admin.rb`, ...). Missing the split
@@ -29,6 +38,8 @@ def _is_rails_routes_file(path: str) -> bool:
 
 
 def _sinatra_routes(x: FileExtraction) -> list[EntrypointHint]:
+    if _is_ruby_test(x.path):
+        return []
     hints = []
     for ref in x.references:
         if (
@@ -106,6 +117,8 @@ def _rake_tasks(x: FileExtraction) -> list[EntrypointHint]:
 
 def _grape_routes(x: FileExtraction) -> list[EntrypointHint]:
     """Grape API classes: class-body `get '/x'` / `post '/y'` declarations."""
+    if _is_ruby_test(x.path):
+        return []
     hints = []
     for ref in x.references:
         if (

{entrygraph-0.1.43 → entrygraph-0.1.45}/tests/test_entrypoints_go.py

@@ -206,3 +206,22 @@ def test_fiber_group_prefix_end_to_end():
     x = GoExtractor().extract(parse("go", src), ctx)
     got = {(h.http_methods[0], h.route) for h in _fiber_rule().match(x)}
     assert got == {("GET", "/api"), ("POST", "/api/auth/login")}
+
+
+def test_go_route_rules_skip_test_files():
+    # *_test.go registers routes only to exercise handlers (chi corpus: 152/204
+    # routes came from _test.go). All Go HTTP-route rules must skip them (#33).
+    refs = [_call("Get", "r", '("/users", h)')]
+    assert _chi_rule().match(_go_ext(refs, path="middleware/compress_test.go")) == []
+    assert _gin_rule().match(_go_ext(refs, path="api/routes_test.go")) == []
+    assert _fiber_rule().match(_go_ext(refs, path="api/routes_test.go")) == []
+    # sanity: the same refs in a non-test file still produce a route
+    assert _chi_rule().match(_go_ext(refs, path="middleware/compress.go"))
+
+
+def test_go_nethttp_and_grpc_skip_test_files():
+    nethttp = {r.id: r for r in rules_for("go", {"net/http"})}["go.nethttp.route"]
+    refs = [_call("HandleFunc", "http", '("/x", h)')]
+    assert nethttp.match(_go_ext(refs, path="server_test.go")) == []
+    grpc = [_call("RegisterPusherServer", "pb", "(s, impl)")]
+    assert _grpc_rule().match(_go_ext(grpc, path="server_test.go")) == []

entrygraph-0.1.45/tests/test_entrypoints_php.py

@@ -0,0 +1,66 @@
+"""PHP 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.detect.entrypoints.php import _symfony_methods, _symfony_path
+from entrygraph.extract.base import FileContext
+from entrygraph.extract.php import PhpExtractor
+from entrygraph.parsing.parsers import parse
+
+
+def _symfony_rule():
+    return {r.id: r for r in rules_for("php", {"symfony"})}["php.symfony.route"]
+
+
+def _extract(src: bytes, path="src/Controller/UserController.php"):
+    ctx = FileContext(
+        path=path,
+        language="php",
+        module_path="App.Controller.UserController",
+        source=src,
+        is_package=False,
+    )
+    return PhpExtractor().extract(parse("php", src), ctx)
+
+
+def test_symfony_class_route_prefix_composed():
+    # Class-level #[Route('/profile')] must prefix each method route, and
+    # methods: [...] must be honored (symfony-demo: 11/12 routes were wrong) (#36).
+    src = (
+        b"<?php\nnamespace App\\Controller;\n"
+        b"#[Route('/profile'), IsGranted(User::ROLE_USER)]\n"
+        b"final class UserController extends AbstractController\n{\n"
+        b"    #[Route('/edit', name: 'user_edit', methods: ['GET', 'POST'])]\n"
+        b"    public function edit() {}\n"
+        b"    #[Route(path: '/pw', name: 'pw')]\n"
+        b"    public function pw() {}\n"
+        b"}\n"
+    )
+    got = {(tuple(h.http_methods), h.route) for h in _symfony_rule().match(_extract(src))}
+    assert got == {
+        (("GET", "POST"), "/profile/edit"),
+        (("*",), "/profile/pw"),  # path: named arg, no methods -> all verbs
+    }
+
+
+def test_symfony_route_without_class_prefix():
+    # A controller with no class-level #[Route] leaves method routes unprefixed.
+    src = (
+        b"<?php\nnamespace App\\Controller;\n"
+        b"final class SecurityController extends AbstractController\n{\n"
+        b"    #[Route('/login', name: 'login')]\n"
+        b"    public function login() {}\n"
+        b"}\n"
+    )
+    got = {(tuple(h.http_methods), h.route) for h in _symfony_rule().match(_extract(src))}
+    assert got == {(("*",), "/login")}
+
+
+def test_symfony_path_and_methods_parsing():
+    assert _symfony_path("#[Route('/edit', name: 'x')]") == "/edit"
+    assert _symfony_path("#[Route(path: '/pw', name: 'x')]") == "/pw"
+    assert _symfony_methods("#[Route('/x', methods: ['GET', 'POST'])]") == ["GET", "POST"]
+    assert _symfony_methods("#[Route('/x', methods: 'DELETE')]") == ["DELETE"]
+    assert _symfony_methods("#[Route('/x', name: 'x')]") == []

entrygraph-0.1.45/tests/test_entrypoints_ruby.py

@@ -0,0 +1,63 @@
+"""Ruby 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.ir import FileExtraction, RawReference, Span
+
+
+def _ruby_ext(references, path):
+    return FileExtraction(
+        path=path,
+        language="ruby",
+        module_path=path.replace("/", ".").removesuffix(".rb"),
+        parse_ok=True,
+        error_count=0,
+        symbols=[],
+        references=list(references),
+    )
+
+
+def _verb(verb, route):
+    return RawReference(
+        kind="call",
+        callee_text=verb,
+        callee_name=verb,
+        receiver_text=None,
+        span=Span(1, 0, 1, 40),
+        caller_qualified_name=None,
+        arg_preview=f"('{route}')",
+    )
+
+
+def _sinatra_rule():
+    return {r.id: r for r in rules_for("ruby", {"sinatra"})}["ruby.sinatra.route"]
+
+
+def _grape_rule():
+    return {r.id: r for r in rules_for("ruby", {"grape"})}["ruby.grape.route"]
+
+
+def test_sinatra_route_in_app_file_detected():
+    hints = _sinatra_rule().match(_ruby_ext([_verb("get", "/health")], "app.rb"))
+    assert [h.route for h in hints] == ["/health"]
+
+
+def test_sinatra_ignores_rack_test_calls_in_spec_and_test_files():
+    # Rack::Test uses the same bare `get '/x'` DSL inside specs; those files are not
+    # the route surface (sinatra corpus: 256/274 routes came from test/spec) (#33).
+    for path in (
+        "test/routing_test.rb",
+        "spec/app_spec.rb",
+        "rack-protection/spec/lib/rack/protection/ip_spoofing_spec.rb",
+        "some/nested/test/helper_test.rb",
+    ):
+        assert _sinatra_rule().match(_ruby_ext([_verb("get", "/")], path)) == []
+
+
+def test_grape_ignores_test_files():
+    assert _grape_rule().match(_ruby_ext([_verb("post", "/x")], "spec/api_spec.rb")) == []
+    assert [h.route for h in _grape_rule().match(_ruby_ext([_verb("post", "/x")], "api.rb"))] == [
+        "/x"
+    ]