entrygraph 0.1.37__tar.gz → 0.1.38__tar.gz

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

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

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

@@ -24,6 +24,67 @@ _LARAVEL_VERBS = frozenset({"get", "post", "put", "delete", "patch", "any", "mat
 _LARAVEL_RESOURCE = frozenset({"resource", "apiResource"})
 _SYMFONY_ROUTE = re.compile(r"#\[\s*Route\s*\(")
 _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
+# $this->namespace), arg 2 is the route literal. Requiring arg 2 to be quoted keeps
+# array keys ('methods'/'GET') from being mistaken for the route when arg 1 is a var.
+_WP_REST_NS_ROUTE = re.compile(r"""\(\s*(?:['"]([^'"]+)['"]|[^,'"]+?)\s*,\s*['"]([^'"]+)['"]""")
+# 'methods' => 'GET' / 'GET,POST'  or  'methods' => WP_REST_Server::READABLE
+_WP_METHODS_KV = re.compile(
+    r"""['"]methods['"]\s*=>\s*(?:['"]([A-Za-z,\s|]+)['"]|WP_REST_Server::(\w+))"""
+)
+_WP_REST_CONST = {
+    "READABLE": "GET",
+    "CREATABLE": "POST",
+    "EDITABLE": "PUT",
+    "DELETABLE": "DELETE",
+    "ALLMETHODS": "*",
+}
+
+
+def _wp_rest_methods(arg_preview: str) -> list[str]:
+    m = _WP_METHODS_KV.search(arg_preview)
+    if not m:
+        return ["*"]  # WP defaults to all methods when 'methods' is omitted
+    if m.group(1):  # a 'GET' / 'GET, POST' string
+        return [v.strip().upper() for v in re.split(r"[,|]", m.group(1)) if v.strip()]
+    return [_WP_REST_CONST.get(m.group(2), "*")]  # a WP_REST_Server:: constant
+
+
+def _wordpress_rest_routes(x: FileExtraction) -> list[EntrypointHint]:
+    """WP REST API: register_rest_route($namespace, $route, ['methods' => ...]).
+
+    Not framework-gated: the function is unambiguously WordPress, and WP is often
+    undetected (plugins ship no core files), which otherwise hid the whole REST
+    surface (wordpress core: 0/112 routes)."""
+    hints = []
+    for ref in x.references:
+        if (
+            ref.kind != "call"
+            or ref.receiver_text is not None
+            or ref.callee_name != "register_rest_route"
+            or not ref.arg_preview
+        ):
+            continue
+        m = _WP_REST_NS_ROUTE.match(ref.arg_preview)
+        if m is None:  # a dynamic route literal we can't read — skip
+            continue
+        namespace, route = m.group(1), m.group(2)  # namespace None if it's a variable
+        parts = [p.strip("/") for p in (namespace, route) if p and p.strip("/")]
+        full = "/" + "/".join(parts)
+        for method in _wp_rest_methods(ref.arg_preview):
+            hints.append(
+                EntrypointHint(
+                    rule_id="php.wordpress.rest",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=None,  # callback resolved as a call edge
+                    route=full,
+                    http_methods=[method],
+                    framework="wordpress",
+                    metadata={"registration": ref.arg_preview},
+                )
+            )
+    return hints
 
 
 def _resource_param(name: str) -> str:
@@ -183,4 +244,11 @@ register(
         "php.wordpress.hook", "php", "wordpress", EntrypointKind.EVENT_HANDLER, _wordpress_hooks
     )
 )
+# framework=None: register_rest_route is unambiguously WP but plugins ship no core
+# files, so WP is often undetected — run it for any PHP file rather than gate it.
+register(
+    EntrypointRule(
+        "php.wordpress.rest", "php", None, EntrypointKind.HTTP_ROUTE, _wordpress_rest_routes
+    )
+)
 register(EntrypointRule("php.core.script", "php", None, EntrypointKind.MAIN, _script))

{entrygraph-0.1.37 → entrygraph-0.1.38}/src/entrygraph/detect/frameworks.py

@@ -484,7 +484,11 @@ FRAMEWORKS: list[FrameworkSpec] = [
         "wordpress",
         "php",
         (
-            FrameworkSignal("file_presence", "wp-config.php", 0.7),
+            # wp-config.php is git-ignored (only wp-config-sample.php ships), so key
+            # off WP core files that are always present in a checkout instead.
+            FrameworkSignal("file_presence", "*wp-blog-header.php", 0.7),
+            FrameworkSignal("file_presence", "*wp-login.php", 0.5),
+            FrameworkSignal("file_presence", "*wp-includes/functions.php", 0.6),
             FrameworkSignal("symbol_name", "wp_*", 0.2),
         ),
     ),

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

@@ -520,3 +520,48 @@ def test_gorilla_chained_routes_and_methods():
     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
+
+
+def _php_ref(callee, arg):
+    return RawReference(
+        kind="call",
+        callee_text=callee,
+        callee_name=callee,
+        receiver_text=None,
+        span=SPAN,
+        caller_qualified_name=None,
+        arg_preview=arg,
+    )
+
+
+def _php_ext(refs, path="wp-includes/rest.php"):
+    return FileExtraction(
+        path=path,
+        language="php",
+        module_path="wp.rest",
+        parse_ok=True,
+        error_count=0,
+        symbols=[],
+        references=list(refs),
+    )
+
+
+def test_wordpress_register_rest_route():
+    from entrygraph.detect.entrypoints import rules_for
+
+    refs = [
+        _php_ref("register_rest_route", "('myplugin/v1', '/authors', array('methods' => 'GET'))"),
+        # variable namespace + WP_REST_Server constant method
+        _php_ref(
+            "register_rest_route",
+            "($this->namespace, '/items', array('methods' => WP_REST_Server::CREATABLE))",
+        ),
+        # both namespace and route dynamic -> not statically resolvable, skipped
+        _php_ref("register_rest_route", "($ns, $route, array('methods' => 'DELETE'))"),
+    ]
+    # framework=None rule runs for any PHP file (WP is often undetected in plugins)
+    rule = {r.id: r for r in rules_for("php", set())}["php.wordpress.rest"]
+    got = {(tuple(h.http_methods), h.route) for h in rule.match(_php_ext(refs))}
+    assert (("GET",), "/myplugin/v1/authors") in got  # namespace + route composed
+    assert (("POST",), "/items") in got  # CREATABLE -> POST; dynamic namespace dropped
+    assert not any(h.route in ("", "/methods") for h in rule.match(_php_ext(refs)))  # no garbage