osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/java/public_api.py

@@ -0,0 +1,206 @@
+"""Public API method detector for Java source files using tree-sitter AST."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+# Methods that are boilerplate / Object overrides -- skip them.
+_SKIP_METHODS = frozenset({"toString", "hashCode", "equals", "clone", "finalize"})
+
+
+def _is_trivial_accessor(name: str, param_count: int, body_lines: int) -> bool:
+    """Return True for simple getters/setters (get*/set*/is* with <=1 param, <=1 body line)."""
+    if param_count > 1:
+        return False
+    if body_lines > 1:
+        return False
+    if name.startswith("get") or name.startswith("set") or name.startswith("is"):
+        return True
+    return False
+
+
+def _body_line_count(method_node) -> int:  # type: ignore[no-untyped-def]
+    """Count the number of non-empty lines inside the method body (excluding braces)."""
+    body = method_node.child_by_field_name("body")
+    if body is None:
+        return 0
+    start_line = body.start_point[0]
+    end_line = body.end_point[0]
+    # Subtract the lines with opening/closing braces themselves.
+    return max(0, end_line - start_line - 1)
+
+
+def _param_types(params_node) -> list[str]:  # type: ignore[no-untyped-def]
+    """Extract simple type names from a formal_parameters node."""
+    types: list[str] = []
+    if params_node is None:
+        return types
+    for child in params_node.children:
+        if child.type == "formal_parameter":
+            type_node = child.child_by_field_name("type")
+            if type_node is not None:
+                types.append(type_node.text.decode("utf-8", errors="replace"))
+    return types
+
+
+def _find_child_by_type(node, type_name: str):  # type: ignore[no-untyped-def]
+    """Find the first child of *node* with the given type (by iterating children)."""
+    for child in node.children:
+        if child.type == type_name:
+            return child
+    return None
+
+
+def _has_modifier(modifiers_node, modifier_text: str) -> bool:  # type: ignore[no-untyped-def]
+    """Check whether *modifiers_node* contains a specific keyword like 'public' or 'static'."""
+    if modifiers_node is None:
+        return False
+    for child in modifiers_node.children:
+        if child.text is not None and child.text.decode("utf-8", errors="replace") == modifier_text:
+            return True
+    return False
+
+
+class PublicApiDetector:
+    """Detects public and protected methods in Java classes and interfaces."""
+
+    name: str = "java.public_api"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        if ctx.tree is None:
+            return result
+
+        root = ctx.tree.root_node
+        for child in root.children:
+            if child.type == "class_declaration":
+                self._process_class(child, ctx, result, is_interface=False)
+            elif child.type == "interface_declaration":
+                self._process_class(child, ctx, result, is_interface=True)
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _process_class(
+        self,
+        class_node,  # type: ignore[no-untyped-def]
+        ctx: DetectorContext,
+        result: DetectorResult,
+        *,
+        is_interface: bool,
+    ) -> None:
+        name_node = class_node.child_by_field_name("name")
+        if name_node is None:
+            return
+        class_name: str = name_node.text.decode("utf-8", errors="replace")
+        class_node_id = f"{ctx.file_path}:{class_name}"
+
+        body_field = "interface_body" if is_interface else "class_body"
+        body = class_node.child_by_field_name("body")
+        if body is None:
+            return
+
+        for member in body.children:
+            if member.type == "method_declaration":
+                self._process_method(member, class_name, class_node_id, ctx, result, is_interface=is_interface)
+
+    def _process_method(
+        self,
+        method_node,  # type: ignore[no-untyped-def]
+        class_name: str,
+        class_node_id: str,
+        ctx: DetectorContext,
+        result: DetectorResult,
+        *,
+        is_interface: bool,
+    ) -> None:
+        # --- Method name ---
+        name_node = method_node.child_by_field_name("name")
+        if name_node is None:
+            return
+        method_name: str = name_node.text.decode("utf-8", errors="replace")
+
+        # Skip Object boilerplate
+        if method_name in _SKIP_METHODS:
+            return
+
+        # --- Modifiers ---
+        # NOTE: In tree-sitter-java, "modifiers" is a child node type, NOT a
+        # named field, so child_by_field_name("modifiers") returns None.
+        # We must locate it by iterating children.
+        modifiers_node = _find_child_by_type(method_node, "modifiers")
+
+        # In a class, only public / protected methods qualify.
+        # Interface methods are implicitly public.
+        if is_interface:
+            visibility = "public"
+        else:
+            if _has_modifier(modifiers_node, "public"):
+                visibility = "public"
+            elif _has_modifier(modifiers_node, "protected"):
+                visibility = "protected"
+            else:
+                # private or package-private -- skip
+                return
+
+        is_static = _has_modifier(modifiers_node, "static")
+        is_abstract = _has_modifier(modifiers_node, "abstract")
+
+        # --- Parameters ---
+        params_node = method_node.child_by_field_name("parameters")
+        ptypes = _param_types(params_node)
+
+        # Skip trivial getters / setters
+        body_lines = _body_line_count(method_node)
+        if _is_trivial_accessor(method_name, len(ptypes), body_lines):
+            return
+
+        # --- Return type ---
+        type_node = method_node.child_by_field_name("type")
+        return_type = type_node.text.decode("utf-8", errors="replace") if type_node is not None else "void"
+
+        # --- Build node ---
+        param_sig = ",".join(ptypes)
+        method_id = f"{ctx.file_path}:{class_name}:{method_name}({param_sig})"
+        line = method_node.start_point[0] + 1
+
+        properties: dict[str, Any] = {
+            "visibility": visibility,
+            "return_type": return_type,
+            "parameters": ptypes,
+            "is_static": is_static,
+            "is_abstract": is_abstract,
+        }
+
+        node = GraphNode(
+            id=method_id,
+            kind=NodeKind.METHOD,
+            label=f"{class_name}.{method_name}",
+            fqn=f"{class_name}.{method_name}({param_sig})",
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=line),
+            properties=properties,
+        )
+        result.nodes.append(node)
+
+        edge = GraphEdge(
+            source=class_node_id,
+            target=method_id,
+            kind=EdgeKind.DEFINES,
+            label=f"{class_name} defines {method_name}",
+        )
+        result.edges.append(edge)

osscodeiq/detectors/java/quarkus.py

@@ -0,0 +1,176 @@
+"""Quarkus framework detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_QUARKUS_TEST_RE = re.compile(r"@QuarkusTest\b")
+_CONFIG_PROPERTY_RE = re.compile(r'@ConfigProperty\s*\(\s*name\s*=\s*"([^"]+)"')
+_CDI_SCOPE_RE = re.compile(
+    r"@(Inject|Singleton|ApplicationScoped|RequestScoped)\b"
+)
+_SCHEDULED_RE = re.compile(r'@Scheduled\s*\(\s*(?:every|cron)\s*=\s*"([^"]+)"')
+_TRANSACTIONAL_RE = re.compile(r"@Transactional\b")
+_STARTUP_RE = re.compile(r"@Startup\b")
+_TRANSACTIONAL = "@Transactional"
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+
+
+class QuarkusDetector:
+    """Detects Quarkus-specific patterns in Java source files."""
+
+    name: str = "quarkus"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast bail: check for any Quarkus-related markers
+        if not any(
+            marker in text
+            for marker in (
+                "@QuarkusTest",
+                "@ConfigProperty",
+                "@Singleton",
+                "@ApplicationScoped",
+                "@RequestScoped",
+                "@Scheduled",
+                _TRANSACTIONAL,
+                "@Startup",
+                "io.quarkus",
+            )
+        ):
+            return result
+
+        lines = text.split("\n")
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        for i, line in enumerate(lines):
+            lineno = i + 1
+
+            # @QuarkusTest annotation
+            m = _QUARKUS_TEST_RE.search(line)
+            if m:
+                node_id = f"quarkus:{ctx.file_path}:quarkus_test:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.CLASS,
+                        label=f"@QuarkusTest {class_name or 'unknown'}",
+                        fqn=class_name,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@QuarkusTest"],
+                        properties={"framework": "quarkus", "test": True},
+                    )
+                )
+
+            # @ConfigProperty
+            m = _CONFIG_PROPERTY_RE.search(line)
+            if m:
+                config_key = m.group(1)
+                node_id = f"quarkus:{ctx.file_path}:config_property:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"@ConfigProperty({config_key})",
+                        fqn=config_key,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@ConfigProperty"],
+                        properties={"framework": "quarkus", "config_key": config_key},
+                    )
+                )
+
+            # CDI scope annotations
+            m = _CDI_SCOPE_RE.search(line)
+            if m:
+                annotation = m.group(1)
+                node_id = f"quarkus:{ctx.file_path}:cdi_{annotation.lower()}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=f"@{annotation} (CDI)",
+                        fqn=f"{class_name}.{annotation}" if class_name else annotation,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[f"@{annotation}"],
+                        properties={"framework": "quarkus", "cdi_scope": annotation},
+                    )
+                )
+
+            # @Scheduled
+            m = _SCHEDULED_RE.search(line)
+            if m:
+                schedule_expr = m.group(1)
+                node_id = f"quarkus:{ctx.file_path}:scheduled:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.EVENT,
+                        label=f"@Scheduled({schedule_expr})",
+                        fqn=f"{class_name}.scheduled" if class_name else "scheduled",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@Scheduled"],
+                        properties={"framework": "quarkus", "schedule": schedule_expr},
+                    )
+                )
+
+            # @Transactional
+            m = _TRANSACTIONAL_RE.search(line)
+            if m:
+                node_id = f"quarkus:{ctx.file_path}:transactional:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=_TRANSACTIONAL,
+                        fqn=f"{class_name}.transactional" if class_name else "transactional",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[_TRANSACTIONAL],
+                        properties={"framework": "quarkus"},
+                    )
+                )
+
+            # @Startup
+            m = _STARTUP_RE.search(line)
+            if m:
+                node_id = f"quarkus:{ctx.file_path}:startup:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=f"@Startup {class_name or 'unknown'}",
+                        fqn=class_name,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@Startup"],
+                        properties={"framework": "quarkus"},
+                    )
+                )
+
+        return result

osscodeiq/detectors/java/rabbitmq.py

@@ -0,0 +1,150 @@
+"""RabbitMQ detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+
+# @RabbitListener
+_RABBIT_LISTENER_RE = re.compile(
+    r'@RabbitListener\s*\(\s*(?:.*?queues?\s*=\s*)?[\{"]?\s*"([^"]+)"'
+)
+
+# @RabbitHandler
+_RABBIT_HANDLER_RE = re.compile(r"@RabbitHandler")
+
+# RabbitTemplate.convertAndSend / send
+_RABBIT_SEND_RE = re.compile(
+    r'(?:rabbitTemplate|RabbitTemplate)\s*\.(?:convertAndSend|send)\s*\(\s*"([^"]+)"'
+)
+
+# Exchange/queue/binding declarations
+_EXCHANGE_RE = re.compile(
+    r'(?:DirectExchange|TopicExchange|FanoutExchange|HeadersExchange)\s*\(\s*"([^"]+)"'
+)
+_QUEUE_DECL_RE = re.compile(r'Queue\s*\(\s*"([^"]+)"')
+_BINDING_RE = re.compile(
+    r'BindingBuilder\s*\.bind\s*\(\s*(\w+)\s*\)\s*\.to\s*\(\s*(\w+)\s*\)'
+)
+
+_ROUTING_KEY_RE = re.compile(r'routingKey\s*=\s*"([^"]+)"')
+
+
+class RabbitmqDetector:
+    """Detects RabbitMQ consumers and producers."""
+
+    name: str = "rabbitmq"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        if not any(kw in text for kw in (
+            "@RabbitListener", "RabbitTemplate", "rabbitTemplate",
+            "DirectExchange", "TopicExchange", "FanoutExchange",
+        )):
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+        seen_queues: set[str] = set()
+
+        def _ensure_queue_node(queue: str) -> str:
+            queue_id = f"rabbitmq:queue:{queue}"
+            if queue not in seen_queues:
+                seen_queues.add(queue)
+                result.nodes.append(GraphNode(
+                    id=queue_id,
+                    kind=NodeKind.QUEUE,
+                    label=f"rabbitmq:{queue}",
+                    properties={"broker": "rabbitmq", "queue": queue},
+                ))
+            return queue_id
+
+        # Detect @RabbitListener consumers
+        for i, line in enumerate(lines):
+            m = _RABBIT_LISTENER_RE.search(line)
+            if not m:
+                continue
+
+            queue = m.group(1)
+            queue_id = _ensure_queue_node(queue)
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=queue_id,
+                kind=EdgeKind.CONSUMES,
+                label=f"{class_name} consumes from {queue}",
+                properties={"queue": queue},
+            ))
+
+        # Detect RabbitTemplate sends
+        for i, line in enumerate(lines):
+            m = _RABBIT_SEND_RE.search(line)
+            if not m:
+                continue
+
+            exchange_or_queue = m.group(1)
+            routing_key = _ROUTING_KEY_RE.search(line)
+
+            props: dict[str, str] = {"exchange": exchange_or_queue}
+            if routing_key:
+                props["routing_key"] = routing_key.group(1)
+
+            queue_id = f"rabbitmq:exchange:{exchange_or_queue}"
+            if exchange_or_queue not in seen_queues:
+                seen_queues.add(exchange_or_queue)
+                result.nodes.append(GraphNode(
+                    id=queue_id,
+                    kind=NodeKind.QUEUE,
+                    label=f"rabbitmq:{exchange_or_queue}",
+                    properties={"broker": "rabbitmq", "exchange": exchange_or_queue},
+                ))
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=queue_id,
+                kind=EdgeKind.PRODUCES,
+                label=f"{class_name} produces to {exchange_or_queue}",
+                properties=props,
+            ))
+
+        # Detect exchange declarations
+        for m in _EXCHANGE_RE.finditer(text):
+            exchange_name = m.group(1)
+            line_num = text[:m.start()].count("\n") + 1
+            exchange_id = f"rabbitmq:exchange:{exchange_name}"
+            if exchange_name not in seen_queues:
+                seen_queues.add(exchange_name)
+                result.nodes.append(GraphNode(
+                    id=exchange_id,
+                    kind=NodeKind.QUEUE,
+                    label=f"rabbitmq:exchange:{exchange_name}",
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line_num),
+                    properties={"broker": "rabbitmq", "exchange": exchange_name},
+                ))
+
+        return result

osscodeiq/detectors/java/raw_sql.py

@@ -0,0 +1,136 @@
+"""Raw SQL query detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+
+# @Query annotations with SQL/JPQL
+_QUERY_ANNO_RE = re.compile(
+    r'@Query\s*\(\s*(?:value\s*=\s*)?"((?:[^"\\]|\\.)+)"', re.DOTALL
+)
+_NATIVE_QUERY_RE = re.compile(r"nativeQuery\s*=\s*true")
+
+# JdbcTemplate patterns
+_JDBC_TEMPLATE_RE = re.compile(
+    r'(?:jdbcTemplate|namedParameterJdbcTemplate|JdbcTemplate)\s*\.'
+    r'(?:query|queryForObject|queryForList|queryForMap|update|execute|batchUpdate)'
+    r'\s*\(\s*"((?:[^"\\]|\\.)+)"',
+    re.DOTALL,
+)
+
+# EntityManager.createNativeQuery / createQuery
+_EM_QUERY_RE = re.compile(
+    r'(?:entityManager|em)\s*\.(?:createNativeQuery|createQuery)\s*\(\s*"((?:[^"\\]|\\.)+)"',
+    re.DOTALL,
+)
+
+# SQL table references
+_TABLE_REF_RE = re.compile(
+    r'\b(?:FROM|JOIN|INTO|UPDATE|TABLE)\s+(\w+)', re.IGNORECASE
+)
+
+
+class RawSqlDetector:
+    """Detects raw SQL queries in @Query annotations and JdbcTemplate calls."""
+
+    name: str = "raw_sql"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        if "@Query" not in text and "jdbcTemplate" not in text and "JdbcTemplate" not in text and "createNativeQuery" not in text and "createQuery" not in text:
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        class_name = class_name or "Unknown"
+
+        # Detect @Query annotations
+        for m in _QUERY_ANNO_RE.finditer(text):
+            query_str = m.group(1)
+            line_num = text[:m.start()].count("\n") + 1
+            is_native = bool(_NATIVE_QUERY_RE.search(text[m.start():m.end() + 50]))
+
+            tables = _TABLE_REF_RE.findall(query_str)
+
+            query_id = f"{ctx.file_path}:{class_name}:query:L{line_num}"
+            result.nodes.append(GraphNode(
+                id=query_id,
+                kind=NodeKind.QUERY,
+                label=query_str[:80] + ("..." if len(query_str) > 80 else ""),
+                fqn=f"{class_name}.query@L{line_num}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line_num),
+                annotations=["@Query"],
+                properties={
+                    "query": query_str,
+                    "native": is_native,
+                    "source": "annotation",
+                    "tables": tables,
+                },
+            ))
+
+        # Detect JdbcTemplate queries
+        for m in _JDBC_TEMPLATE_RE.finditer(text):
+            query_str = m.group(1)
+            line_num = text[:m.start()].count("\n") + 1
+            tables = _TABLE_REF_RE.findall(query_str)
+
+            query_id = f"{ctx.file_path}:{class_name}:jdbc:L{line_num}"
+            result.nodes.append(GraphNode(
+                id=query_id,
+                kind=NodeKind.QUERY,
+                label=query_str[:80] + ("..." if len(query_str) > 80 else ""),
+                fqn=f"{class_name}.jdbc@L{line_num}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line_num),
+                properties={
+                    "query": query_str,
+                    "native": True,
+                    "source": "jdbc_template",
+                    "tables": tables,
+                },
+            ))
+
+        # Detect EntityManager queries
+        for m in _EM_QUERY_RE.finditer(text):
+            query_str = m.group(1)
+            line_num = text[:m.start()].count("\n") + 1
+            tables = _TABLE_REF_RE.findall(query_str)
+
+            query_id = f"{ctx.file_path}:{class_name}:em:L{line_num}"
+            result.nodes.append(GraphNode(
+                id=query_id,
+                kind=NodeKind.QUERY,
+                label=query_str[:80] + ("..." if len(query_str) > 80 else ""),
+                fqn=f"{class_name}.em@L{line_num}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line_num),
+                properties={
+                    "query": query_str,
+                    "native": "createNativeQuery" in text[max(0, m.start() - 30):m.start() + 20],
+                    "source": "entity_manager",
+                    "tables": tables,
+                },
+            ))
+
+        return result