osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/java/repository.py

@@ -0,0 +1,131 @@
+"""Spring Data repository 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,
+)
+
+_REPO_EXTENDS_RE = re.compile(
+    r"interface\s+(\w+)\s+extends\s+((?:JpaRepository|CrudRepository|"
+    r"PagingAndSortingRepository|ReactiveCrudRepository|"
+    r"MongoRepository|ElasticsearchRepository|"
+    r"R2dbcRepository|JpaSpecificationExecutor)\w*)"
+    r"(?:<\s*(\w+)\s*,\s*[\w<>]+\s*>)?"
+)
+_REPOSITORY_ANNO_RE = re.compile(r"@Repository")
+_INTERFACE_RE = re.compile(r"interface\s+(\w+)")
+_GENERIC_PARAMS_RE = re.compile(r"<\s*(\w+)\s*,")
+_QUERY_RE = re.compile(r'@Query\s*\(\s*(?:value\s*=\s*)?"([^"]+)"')
+_METHOD_RE = re.compile(r"(?:public\s+)?(?:[\w<>\[\],?\s]+)\s+(\w+)\s*\(")
+
+
+class RepositoryDetector:
+    """Detects Spring Data repository interfaces."""
+
+    name: str = "spring_repository"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Check for repository patterns
+        has_repo_annotation = _REPOSITORY_ANNO_RE.search(text) is not None
+        extends_match = _REPO_EXTENDS_RE.search(text)
+
+        if not extends_match and not has_repo_annotation:
+            return result
+
+        # Find interface name and entity type
+        interface_name: str | None = None
+        entity_type: str | None = None
+        parent_repo: str | None = None
+        interface_line: int = 0
+
+        if extends_match:
+            interface_name = extends_match.group(1)
+            parent_repo = extends_match.group(2)
+            entity_type = extends_match.group(3)
+            # Find line number
+            for i, line in enumerate(lines):
+                if interface_name and interface_name in line and "interface" in line:
+                    interface_line = i + 1
+                    break
+        else:
+            # Just @Repository on a class/interface
+            for i, line in enumerate(lines):
+                im = _INTERFACE_RE.search(line)
+                if im:
+                    interface_name = im.group(1)
+                    interface_line = i + 1
+                    # Try to extract generic params
+                    gm = _GENERIC_PARAMS_RE.search(line)
+                    if gm:
+                        entity_type = gm.group(1)
+                    break
+
+        if not interface_name:
+            return result
+
+        repo_id = f"{ctx.file_path}:{interface_name}"
+
+        properties: dict[str, object] = {}
+        if parent_repo:
+            properties["extends"] = parent_repo
+        if entity_type:
+            properties["entity_type"] = entity_type
+
+        # Extract @Query methods
+        custom_queries: list[dict[str, str]] = []
+        for i, line in enumerate(lines):
+            qm = _QUERY_RE.search(line)
+            if qm:
+                query_str = qm.group(1)
+                # Find method name on next lines
+                method_name = None
+                for k in range(i + 1, min(i + 4, len(lines))):
+                    mm = _METHOD_RE.search(lines[k])
+                    if mm:
+                        method_name = mm.group(1)
+                        break
+                custom_queries.append({
+                    "query": query_str,
+                    "method": method_name or "unknown",
+                })
+
+        if custom_queries:
+            properties["custom_queries"] = custom_queries
+
+        node = GraphNode(
+            id=repo_id,
+            kind=NodeKind.REPOSITORY,
+            label=interface_name,
+            fqn=interface_name,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=interface_line),
+            annotations=["@Repository"] if has_repo_annotation else [],
+            properties=properties,
+        )
+        result.nodes.append(node)
+
+        # Edge to entity
+        if entity_type:
+            edge = GraphEdge(
+                source=repo_id,
+                target=f"*:{entity_type}",
+                kind=EdgeKind.QUERIES,
+                label=f"{interface_name} queries {entity_type}",
+            )
+            result.edges.append(edge)
+
+        return result

osscodeiq/detectors/java/rmi.py

@@ -0,0 +1,129 @@
+"""Java RMI detector for 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,
+)
+
+_REMOTE_INTERFACE_RE = re.compile(
+    r"interface\s+(\w+)\s+extends\s+(?:java\.rmi\.)?Remote"
+)
+_UNICAST_RE = re.compile(
+    r"class\s+(\w+)\s+extends\s+(?:java\.rmi\.server\.)?UnicastRemoteObject"
+)
+_IMPLEMENTS_RE = re.compile(r"class\s+(\w+)\s+extends\s+\w+\s+implements\s+([\w,\s]+)")
+_REGISTRY_BIND_RE = re.compile(
+    r'(?:Registry|Naming)\s*\.(?:bind|rebind)\s*\(\s*"([^"]+)"'
+)
+_REGISTRY_LOOKUP_RE = re.compile(
+    r'(?:Registry|Naming)\s*\.lookup\s*\(\s*"([^"]+)"'
+)
+
+
+class RmiDetector:
+    """Detects Java RMI interfaces and remote object exports."""
+
+    name: str = "rmi"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        has_remote = "Remote" in text
+        has_unicast = "UnicastRemoteObject" in text
+        has_naming = "Naming." in text or "Registry." in text
+
+        if not has_remote and not has_unicast and not has_naming:
+            return result
+
+        # Detect Remote interfaces
+        for i, line in enumerate(lines):
+            m = _REMOTE_INTERFACE_RE.search(line)
+            if m:
+                iface_name = m.group(1)
+                iface_id = f"{ctx.file_path}:{iface_name}"
+                result.nodes.append(GraphNode(
+                    id=iface_id,
+                    kind=NodeKind.RMI_INTERFACE,
+                    label=iface_name,
+                    fqn=iface_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                    properties={"type": "remote_interface"},
+                ))
+
+        # Detect UnicastRemoteObject implementations
+        for i, line in enumerate(lines):
+            m = _UNICAST_RE.search(line)
+            if m:
+                class_name = m.group(1)
+                class_id = f"{ctx.file_path}:{class_name}"
+
+                # Find which interfaces it implements
+                impl_match = _IMPLEMENTS_RE.search(line)
+                implemented: list[str] = []
+                if impl_match:
+                    implemented = [s.strip() for s in impl_match.group(2).split(",")]
+
+                for iface in implemented:
+                    result.edges.append(GraphEdge(
+                        source=class_id,
+                        target=f"*:{iface}",
+                        kind=EdgeKind.EXPORTS_RMI,
+                        label=f"{class_name} exports {iface}",
+                    ))
+
+        # Detect registry bindings
+        for i, line in enumerate(lines):
+            m = _REGISTRY_BIND_RE.search(line)
+            if m:
+                binding_name = m.group(1)
+                # Find class context
+                class_name = self._find_enclosing_class(lines, i)
+                if class_name:
+                    class_id = f"{ctx.file_path}:{class_name}"
+                    result.edges.append(GraphEdge(
+                        source=class_id,
+                        target=f"rmi:binding:{binding_name}",
+                        kind=EdgeKind.EXPORTS_RMI,
+                        label=f"{class_name} binds {binding_name}",
+                        properties={"binding_name": binding_name},
+                    ))
+
+        # Detect registry lookups
+        for i, line in enumerate(lines):
+            m = _REGISTRY_LOOKUP_RE.search(line)
+            if m:
+                binding_name = m.group(1)
+                class_name = self._find_enclosing_class(lines, i)
+                if class_name:
+                    class_id = f"{ctx.file_path}:{class_name}"
+                    result.edges.append(GraphEdge(
+                        source=class_id,
+                        target=f"rmi:binding:{binding_name}",
+                        kind=EdgeKind.INVOKES_RMI,
+                        label=f"{class_name} invokes {binding_name}",
+                        properties={"binding_name": binding_name},
+                    ))
+
+        return result
+
+    @staticmethod
+    def _find_enclosing_class(lines: list[str], line_idx: int) -> str | None:
+        class_re = re.compile(r"class\s+(\w+)")
+        for i in range(line_idx, -1, -1):
+            m = class_re.search(lines[i])
+            if m:
+                return m.group(1)
+        return None

osscodeiq/detectors/java/spring_events.py

@@ -0,0 +1,117 @@
+"""Spring application events 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+)")
+_EVENT_LISTENER_RE = re.compile(r"@EventListener")
+_TRANSACTIONAL_EVENT_RE = re.compile(r"@TransactionalEventListener")
+_PUBLISH_RE = re.compile(
+    r"(?:applicationEventPublisher|eventPublisher|publisher)\s*\.\s*publishEvent\s*\(\s*"
+    r"(?:new\s+(\w+)|(\w+))"
+)
+_METHOD_PARAM_RE = re.compile(r"(?:public|protected|private)?\s*\w+\s+(\w+)\s*\(\s*(\w+)\s+\w+\)")
+_EVENT_CLASS_RE = re.compile(r"class\s+(\w+)\s+extends\s+(?:ApplicationEvent|AbstractEvent|\w*Event)")
+
+
+class SpringEventsDetector:
+    """Detects Spring event listeners and publishers."""
+
+    name: str = "spring_events"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        has_listener = "@EventListener" in text or "@TransactionalEventListener" in text
+        has_publisher = "publishEvent" in text
+        has_event_class = _EVENT_CLASS_RE.search(text)
+
+        if not has_listener and not has_publisher and not has_event_class:
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        class_line: int = 0
+        for i, line in enumerate(lines):
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                class_line = i + 1
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+        seen_events: set[str] = set()
+
+        def _ensure_event_node(event_type: str) -> str:
+            event_id = f"event:{event_type}"
+            if event_type not in seen_events:
+                seen_events.add(event_type)
+                result.nodes.append(GraphNode(
+                    id=event_id,
+                    kind=NodeKind.EVENT,
+                    label=event_type,
+                    properties={"event_class": event_type},
+                ))
+            return event_id
+
+        # If this file defines an event class, register it
+        if has_event_class:
+            event_name = has_event_class.group(1)
+            _ensure_event_node(event_name)
+
+        # Detect @EventListener / @TransactionalEventListener
+        for i, line in enumerate(lines):
+            if not (_EVENT_LISTENER_RE.search(line) or _TRANSACTIONAL_EVENT_RE.search(line)):
+                continue
+
+            # Find method and its parameter type (the event type)
+            event_type: str | None = None
+            for k in range(i + 1, min(i + 5, len(lines))):
+                pm = _METHOD_PARAM_RE.search(lines[k])
+                if pm:
+                    event_type = pm.group(2)
+                    break
+
+            if event_type:
+                event_id = _ensure_event_node(event_type)
+                result.edges.append(GraphEdge(
+                    source=class_node_id,
+                    target=event_id,
+                    kind=EdgeKind.LISTENS,
+                    label=f"{class_name} listens to {event_type}",
+                ))
+
+        # Detect publishEvent calls
+        for i, line in enumerate(lines):
+            m = _PUBLISH_RE.search(line)
+            if not m:
+                continue
+
+            event_type = m.group(1) or m.group(2)
+            if event_type:
+                event_id = _ensure_event_node(event_type)
+                result.edges.append(GraphEdge(
+                    source=class_node_id,
+                    target=event_id,
+                    kind=EdgeKind.PUBLISHES,
+                    label=f"{class_name} publishes {event_type}",
+                ))
+
+        return result

osscodeiq/detectors/java/spring_rest.py

@@ -0,0 +1,168 @@
+"""Spring REST endpoint 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,
+)
+
+# Mapping annotations match patterns
+_MAPPING_ANNOTATIONS = {
+    "RequestMapping": None,  # method determined from annotation attributes
+    "GetMapping": "GET",
+    "PostMapping": "POST",
+    "PutMapping": "PUT",
+    "DeleteMapping": "DELETE",
+    "PatchMapping": "PATCH",
+}
+
+_MAPPING_RE = re.compile(
+    r"@(RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)"
+    r"\s*(?:\(([^)]*)\))?"
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+_VALUE_RE = re.compile(r'(?:value\s*=\s*|path\s*=\s*)?\{?\s*"([^"]*)"')
+_METHOD_ATTR_RE = re.compile(r'method\s*=\s*RequestMethod\.(\w+)')
+_PRODUCES_RE = re.compile(r'produces\s*=\s*\{?\s*"([^"]*)"')
+_CONSUMES_RE = re.compile(r'consumes\s*=\s*\{?\s*"([^"]*)"')
+_JAVA_METHOD_RE = re.compile(
+    r'(?:public|protected|private)?\s*(?:static\s+)?(?:[\w<>\[\],\s]+)\s+(\w+)\s*\('
+)
+
+
+def _extract_attr(attr_str: str | None, pattern: re.Pattern[str]) -> str | None:
+    if attr_str is None:
+        return None
+    m = pattern.search(attr_str)
+    return m.group(1) if m else None
+
+
+
+class SpringRestDetector:
+    """Detects Spring REST endpoints from mapping annotations."""
+
+    name: str = "spring_rest"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Find class name
+        class_name: str | None = None
+        class_base_path = ""
+        for i, line in enumerate(lines):
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                # Look backwards for class-level @RequestMapping
+                for j in range(max(0, i - 5), i):
+                    mm = _MAPPING_RE.search(lines[j])
+                    if mm and mm.group(1) == "RequestMapping":
+                        path = _extract_attr(mm.group(2), _VALUE_RE)
+                        if path:
+                            class_base_path = path.rstrip("/")
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+
+        # Scan for method-level mapping annotations
+        for i, line in enumerate(lines):
+            m = _MAPPING_RE.search(line)
+            if not m:
+                continue
+
+            annotation_name = m.group(1)
+            attr_str = m.group(2)
+
+            # Skip class-level RequestMapping (already handled)
+            # Heuristic: if next non-empty, non-annotation line has 'class ', skip
+            is_class_level = False
+            for k in range(i + 1, min(i + 5, len(lines))):
+                stripped = lines[k].strip()
+                if stripped.startswith("@") or not stripped:
+                    continue
+                if "class " in stripped or "interface " in stripped:
+                    is_class_level = True
+                break
+            if is_class_level:
+                continue
+
+            # Determine HTTP method
+            http_method = _MAPPING_ANNOTATIONS[annotation_name]
+            if http_method is None:
+                extracted = _extract_attr(attr_str, _METHOD_ATTR_RE)
+                http_method = extracted if extracted else "GET"
+
+            # Extract path
+            path = _extract_attr(attr_str, _VALUE_RE)
+            if path is None and attr_str:
+                # bare string value like @GetMapping("/foo")
+                bare = re.search(r'"([^"]*)"', attr_str or "")
+                if bare:
+                    path = bare.group(1)
+            path = path or ""
+
+            full_path = f"{class_base_path}/{path.lstrip('/')}" if path else class_base_path or "/"
+            if not full_path.startswith("/"):
+                full_path = "/" + full_path
+
+            # Extract produces/consumes
+            produces = _extract_attr(attr_str, _PRODUCES_RE)
+            consumes = _extract_attr(attr_str, _CONSUMES_RE)
+
+            # Find the method name on subsequent lines
+            method_name = None
+            for k in range(i + 1, min(i + 5, len(lines))):
+                mm = _JAVA_METHOD_RE.search(lines[k])
+                if mm:
+                    method_name = mm.group(1)
+                    break
+
+            endpoint_label = f"{http_method} {full_path}"
+            endpoint_id = f"{ctx.file_path}:{class_name}:{method_name or 'unknown'}:{http_method}:{full_path}"
+
+            properties: dict[str, Any] = {
+                "http_method": http_method,
+                "path": full_path,
+            }
+            if produces:
+                properties["produces"] = produces
+            if consumes:
+                properties["consumes"] = consumes
+
+            node = GraphNode(
+                id=endpoint_id,
+                kind=NodeKind.ENDPOINT,
+                label=endpoint_label,
+                fqn=f"{class_name}.{method_name}" if method_name else class_name,
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                annotations=[f"@{annotation_name}"],
+                properties=properties,
+            )
+            result.nodes.append(node)
+
+            edge = GraphEdge(
+                source=class_node_id,
+                target=endpoint_id,
+                kind=EdgeKind.EXPOSES,
+                label=f"{class_name} exposes {endpoint_label}",
+            )
+            result.edges.append(edge)
+
+        return result