patchi 0.7.5__py3-none-any.whl

patchi/core/brain/route_detector/php.py

@@ -0,0 +1,158 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_PHP_METHODS = {"get", "post", "put", "delete", "patch", "any", "match", "resource", "apiresource"}
+
+
+_log = logging.getLogger("patchi.brain.php")
+
+
+@register_detector("php")
+class PhpRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+        return self._detect_fallback(content, file_path)
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, _build_parser
+
+            parser = _build_parser(Lang.PHP)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("PhpRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, bytes(content, "utf-8"), content, file_path, routes)
+        return routes
+
+    def _walk(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype in ("scoped_call_expression", "function_call_expression"):
+            self._check_call(node, buf, content, file_path, routes)
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            self._walk(child, buf, content, file_path, routes)
+
+    def _check_call(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        func = self._child_by_field(node, "function")
+        if func is None:
+            return
+        ftype = getattr(func, "type", "")
+
+        if ftype == "name":
+            fn_name = self._node_text(func)
+        elif ftype == "scoped_property_access_expression":
+            scope = self._child_by_field(func, "scope")
+            name = self._child_by_field(func, "member")
+            if scope is None or name is None:
+                return
+            scope_text = self._node_text(scope)
+            if scope_text != "Route":
+                return
+            fn_name = self._node_text(name)
+        else:
+            return
+
+        method = fn_name.lower()
+        if method not in _PHP_METHODS:
+            return
+
+        args = self._child_by_field(node, "arguments")
+        path = ""
+        handler = ""
+
+        if args:
+            for child in getattr(args, "named_children", None) or getattr(args, "children", []):
+                if child.type in ("string", "string_literal", "encapsed_string"):
+                    raw = self._node_text(child).strip("'\"")
+                    if not path:
+                        path = raw
+                    elif not handler and "@" in raw:
+                        handler = raw
+                elif child.type == "class_constant_access_expression" and not handler:
+                    handler = self._node_text(child)
+
+        if not path:
+            return
+
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+
+        auth = self._check_auth(node, buf, content)
+
+        routes.append(
+            self._make_route(
+                method.upper(),
+                path,
+                handler,
+                file_path,
+                line,
+                framework="Laravel",
+                auth_required=auth if auth else None,
+            )
+        )
+
+    def _check_auth(self, node: object, buf: bytes, content: str) -> bool:
+        try:
+            text = self._node_text(node)
+            if "->middleware" in text and "'auth'" in text:
+                return True
+        except Exception as e:
+            _log.warning("PhpRouteDetector._check_auth failed: %s", e)
+        return False
+
+    def _child_by_field(self, node: object, field: str) -> object | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _node_text(self, node: object) -> str:
+        try:
+            raw = getattr(node, "text", b"")
+            if isinstance(raw, bytes):
+                return raw.decode("utf-8", errors="replace")
+            return str(raw)
+        except Exception as e:
+            _log.debug("PhpRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        http = "|".join(_PHP_METHODS)
+        pat = re.compile(
+            rf"""Route::({http})\s*\(\s*['"]([^'"]+)['"]""",
+            re.IGNORECASE,
+        )
+        auth_pat = re.compile(r"""->middleware\s*\(\s*['"]auth""")
+        for i, line in enumerate(content.splitlines(), 1):
+            m = pat.search(line)
+            if not m:
+                continue
+            method = m.group(1).upper()
+            path = m.group(2)
+            auth = bool(auth_pat.search(line))
+            handler = ""
+            hm = re.search(r"""['"](\w+@\w+)['"]|(\w+Controller)::class""", line)
+            if hm:
+                handler = hm.group(1) or hm.group(2)
+            routes.append(
+                self._make_route(
+                    method,
+                    path,
+                    handler,
+                    file_path,
+                    i,
+                    framework="Laravel",
+                    auth_required=auth if auth else None,
+                )
+            )
+        return routes

patchi/core/brain/route_detector/python.py

@@ -0,0 +1,193 @@
+import ast
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_FASTAPI_METHODS = {
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "head",
+    "options",
+    "websocket",
+    "api_route",
+}
+_FLASK_METHODS = {"route"}
+_DJANGO_ROUTERS = {"path", "re_path", "url"}
+
+
+@register_detector("python")
+class PythonRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            return []
+
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for dec in node.decorator_list:
+                    route = self._check_fastapi_decorator(dec, node, file_path, content)
+                    if route:
+                        routes.append(route)
+                        continue
+                    flask_routes = self._check_flask_decorator(dec, node, file_path, content)
+                    if flask_routes:
+                        routes.extend(flask_routes)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and self._get_name(node.func) in _DJANGO_ROUTERS:
+                route = self._check_django_call(node, file_path)
+                if route:
+                    routes.append(route)
+
+        return routes
+
+    def _check_fastapi_decorator(
+        self, dec: ast.AST, func: ast.AST, file_path: str, content: str
+    ) -> dict | None:
+        if not isinstance(dec, ast.Call):
+            return None
+        fn = self._get_dotted_name(dec.func)
+        if not fn:
+            return None
+
+        parts = fn.split(".")
+        method = parts[-1].lower() if len(parts) >= 2 else ""
+        if method not in _FASTAPI_METHODS:
+            return None
+
+        path = ""
+        if dec.args:
+            path = self._get_str(dec.args[0])
+        if not path:
+            for kw in dec.keywords or []:
+                if kw.arg == "path":
+                    path = self._get_str(kw.value)
+
+        if not path:
+            return None
+
+        if method == "api_route":
+            methods = "ANY"
+            for kw in dec.keywords or []:
+                if kw.arg == "methods" and isinstance(kw.value, ast.List):
+                    ms = [self._get_str(el).upper() for el in kw.value.elts if self._get_str(el)]
+                    methods = ",".join(ms) if ms else "ANY"
+            method_str = methods
+        else:
+            method_str = method.upper()
+
+        auth = self._check_auth_defaults(func)
+
+        return self._make_route(
+            method_str,
+            path,
+            func.name,
+            file_path,
+            func.lineno,
+            framework="FastAPI",
+            auth_required=auth if auth else None,
+        )
+
+    def _check_flask_decorator(
+        self, dec: ast.AST, func: ast.AST, file_path: str, content: str
+    ) -> list[dict] | None:
+        if not isinstance(dec, ast.Call):
+            return None
+        fn = self._get_dotted_name(dec.func)
+        if not fn:
+            return None
+        parts = fn.split(".")
+        if len(parts) < 2 or parts[-1].lower() not in _FLASK_METHODS:
+            return None
+
+        path = self._get_str(dec.args[0]) if dec.args else ""
+        if not path:
+            return None
+
+        methods = ["GET"]
+        for kw in dec.keywords or []:
+            if kw.arg == "methods" and isinstance(kw.value, ast.List):
+                methods = [self._get_str(el) for el in kw.value.elts if self._get_str(el)]
+
+        auth = self._check_auth_defaults(func)
+
+        return [
+            self._make_route(
+                m.upper(),
+                path,
+                func.name,
+                file_path,
+                func.lineno,
+                framework="Flask",
+                auth_required=auth if auth else None,
+            )
+            for m in methods
+        ]
+
+    def _check_django_call(self, node: ast.Call, file_path: str) -> dict | None:
+        path = self._get_str(node.args[0]) if node.args else ""
+        if not path:
+            return None
+        handler = ""
+        if len(node.args) >= 2:
+            arg = node.args[1]
+            handler = self._get_dotted_name(arg)
+            if not handler and isinstance(arg, ast.Call):
+                handler = self._get_dotted_name(arg.func)
+        return self._make_route(
+            "ANY",
+            path,
+            handler,
+            file_path,
+            node.lineno if hasattr(node, "lineno") else 0,
+            framework="Django",
+        )
+
+    def _get_dotted_name(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            left = self._get_dotted_name(node.value)
+            return f"{left}.{node.attr}" if left else node.attr
+        if isinstance(node, ast.Call):
+            return self._get_dotted_name(node.func)
+        if isinstance(node, ast.Subscript):
+            return self._get_dotted_name(node.value)
+        return ""
+
+    def _get_name(self, node: ast.AST) -> str:
+        return node.id if isinstance(node, ast.Name) else ""
+
+    def _get_str(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return node.value
+        if isinstance(node, ast.Str):
+            return node.s
+        return ""
+
+    def _check_auth_defaults(self, func: ast.AST) -> bool:
+        if not isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return False
+        for dec in func.decorator_list:
+            dn = self._get_dotted_name(dec)
+            if dn and "login_required" in dn:
+                return True
+            if isinstance(dec, ast.Call):
+                cname = self._get_dotted_name(dec.func)
+                if cname and "login_required" in cname:
+                    return True
+        for arg in func.args.args:
+            idx = func.args.args.index(arg)
+            defaults_offset = len(func.args.defaults) - len(func.args.args)
+            if defaults_offset <= idx < len(func.args.defaults):
+                default = func.args.defaults[idx]
+                if isinstance(default, ast.Call):
+                    callee = self._get_dotted_name(default.func)
+                    if callee and "Depends" in callee:
+                        return True
+        return False

patchi/core/brain/route_detector/registry.py

@@ -0,0 +1,25 @@
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+
+_DETECTOR_REGISTRY: dict[str, type[BaseRouteDetector]] = {}
+
+
+def register_detector(language: str):
+    def decorator(cls: type[BaseRouteDetector]):
+        _DETECTOR_REGISTRY[language] = cls
+        return cls
+
+    return decorator
+
+
+def get_detector(language: str) -> BaseRouteDetector | None:
+    cls = _DETECTOR_REGISTRY.get(language)
+    if cls is None:
+        return None
+    return cls()
+
+
+def detect_routes(language: str, content: str, file_path: str) -> list[dict]:
+    detector = get_detector(language)
+    if detector is None:
+        return []
+    return detector.detect(content, file_path)

patchi/core/brain/route_detector/ruby.py

@@ -0,0 +1,134 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_RUBY_HTTP_METHODS = {"get", "post", "put", "patch", "delete", "resources"}
+
+
+_log = logging.getLogger("patchi.brain.ruby")
+
+
+@register_detector("ruby")
+class RubyRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+        return self._detect_fallback(content, file_path)
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, _build_parser
+
+            parser = _build_parser(Lang.RUBY)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("RubyRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, bytes(content, "utf-8"), content, file_path, routes)
+        return routes
+
+    def _walk(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype == "call":
+            self._check_call(node, buf, content, file_path, routes)
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            self._walk(child, buf, content, file_path, routes)
+
+    def _check_call(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        method_node = self._child_by_field(node, "method")
+        if method_node is None:
+            return
+        method_name = self._node_text(method_node).lower()
+        if method_name not in _RUBY_HTTP_METHODS:
+            return
+
+        args = self._child_by_field(node, "arguments")
+        path = ""
+        handler = ""
+        framework = "Ruby on Rails"
+
+        if args:
+            for child in getattr(args, "named_children", None) or getattr(args, "children", []):
+                if child.type in ("string", "simple_symbol"):
+                    raw = self._node_text(child).strip("':\"")
+                    if not path:
+                        path = raw
+                    elif not handler and "@" in raw:
+                        handler = raw
+                elif child.type == "hash" and method_name == "resources":
+                    pass
+
+        if not path:
+            return
+
+        if method_name == "resources":
+            method_str = "GET"
+            route_path = f"/{path}"
+        else:
+            method_str = method_name.upper()
+            route_path = path if path.startswith("/") else f"/{path}"
+
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+        routes.append(
+            self._make_route(method_str, route_path, handler, file_path, line, framework=framework)
+        )
+
+    def _child_by_field(self, node: object, field: str) -> object | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _node_text(self, node: object) -> str:
+        try:
+            raw = getattr(node, "text", b"")
+            if isinstance(raw, bytes):
+                return raw.decode("utf-8", errors="replace")
+            return str(raw)
+        except Exception as e:
+            _log.debug("RubyRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        lines = content.splitlines()
+
+        rails_pat = re.compile(
+            r"""(get|post|put|patch|delete|resources)\s+[":']([^":']+)[":']""", re.IGNORECASE
+        )
+        for i, line in enumerate(lines, 1):
+            m = rails_pat.search(line)
+            if not m:
+                continue
+            verb = m.group(1).upper()
+            path = m.group(2)
+            if verb == "RESOURCES":
+                verb = "GET"
+                route_path = f"/{path}"
+            else:
+                route_path = path if path.startswith("/") else f"/{path}"
+            routes.append(
+                self._make_route(verb, route_path, "", file_path, i, framework="Ruby on Rails")
+            )
+
+        sinatra_pat = re.compile(
+            r"""^\s*(get|post|put|patch|delete)\s+['"]([^'"]+)['"]""", re.IGNORECASE
+        )
+        for i, line in enumerate(lines, 1):
+            m = sinatra_pat.search(line)
+            if m:
+                routes.append(
+                    self._make_route(
+                        m.group(1).upper(), m.group(2), "", file_path, i, framework="Sinatra"
+                    )
+                )
+
+        return routes