apisec-code-bolt 0.1.0__py3-none-any.whl

apisec_code_bolt/parsing/jvm/language_services.py

@@ -0,0 +1,270 @@
+"""
+Java-specific LanguageServices factory.
+
+Implements the LanguageServices abstract class for Java, wiring together:
+- JavaTypeResolver (cross-file symbol + type resolution)
+- JavaConstantResolver (application.properties / @Value)
+- JavaPathResolver (String.format / concatenation — stub for now)
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ..services import (
+    AnalysisContext,
+    LanguageServices,
+    ResolvedConstant,
+    ResolvedPath,
+    TypeResolver,
+)
+from ..services import (
+    ConstantResolver as ConstantResolverProtocol,
+)
+from ..services import (
+    PathResolver as PathResolverProtocol,
+)
+from .type_resolver import JavaTypeResolver
+
+if TYPE_CHECKING:
+    from ..base import ParsedFile
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Constant resolver — reads application.properties / application.yml
+# =============================================================================
+
+
+class JavaConstantResolver:
+    """
+    Resolves constants from Spring application properties and @Value annotations.
+    """
+
+    def __init__(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> None:
+        self._constants: dict[str, str] = {}
+        self._load_properties(project_root)
+        self._scan_value_annotations(parsed_files)
+
+    def _load_properties(self, project_root: Path | None) -> None:
+        if project_root is None:
+            return
+        for candidate in [
+            project_root / "src" / "main" / "resources" / "application.properties",
+            project_root / "src" / "main" / "resources" / "application.yml",
+            project_root / "application.properties",
+            project_root / "application.yml",
+        ]:
+            if not candidate.exists():
+                continue
+            try:
+                if candidate.suffix == ".properties":
+                    self._parse_properties_file(candidate)
+                elif candidate.suffix in (".yml", ".yaml"):
+                    self._parse_yaml_file(candidate)
+            except Exception as e:
+                logger.debug("Could not load %s: %s", candidate, e)
+
+    def _parse_properties_file(self, path: Path) -> None:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key, _, value = line.partition("=")
+                self._constants[key.strip()] = value.strip()
+
+    def _parse_yaml_file(self, path: Path) -> None:
+        try:
+            import yaml  # type: ignore
+
+            data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+            self._flatten_yaml(data, "")
+        except ImportError:
+            pass  # PyYAML not available, skip
+
+    def _flatten_yaml(self, data: Any, prefix: str) -> None:
+        if isinstance(data, dict):
+            for k, v in data.items():
+                full_key = f"{prefix}.{k}" if prefix else k
+                self._flatten_yaml(v, full_key)
+        elif isinstance(data, (str, int, float, bool)):
+            self._constants[prefix] = str(data)
+
+    def _scan_value_annotations(self, parsed_files: list[ParsedFile]) -> None:
+        """Extract @Value("${key}") and @Value("#{key}") from parsed Java files.
+
+        Spring's @Value annotation injects property values at runtime.
+        We capture the property key so the constant resolver can answer
+        lookups for those keys against application.properties / .yml.
+        """
+        import re
+
+        _value_re = re.compile(r"[$#]\{([^}]+)\}")
+
+        for pf in parsed_files:
+            if not pf.success:
+                continue
+            for cls in pf.classes:
+                for field in cls.fields:
+                    # ParsedField decorators carry annotation args as positional
+                    # or named values captured by the Java parser.
+                    for dec in getattr(field, "decorators", []) or []:
+                        if dec.name != "Value":
+                            continue
+                        # Positional arg 0 or keyword "value"
+                        raw: str | None = None
+                        if dec.positional_args:
+                            raw = str(dec.positional_args[0])
+                        if raw is None and dec.arguments:
+                            raw = str(dec.arguments.get("value", "")) or None
+                        if not raw:
+                            continue
+                        m = _value_re.search(raw)
+                        if m:
+                            key = m.group(1)
+                            # If already in properties, keep that value;
+                            # otherwise register the key with an empty sentinel
+                            # so callers know the field is externalised.
+                            if key not in self._constants:
+                                self._constants[key] = ""
+
+    # ConstantResolver protocol
+    def resolve(
+        self,
+        expression: str,
+        in_file: Path | None = None,
+    ) -> ResolvedConstant | None:
+        # Handle ${key} and #{key} patterns
+        key = expression
+        if key.startswith("${") and key.endswith("}") or key.startswith("#{") and key.endswith("}"):
+            key = key[2:-1]
+
+        value = self._constants.get(key)
+        if value is not None:
+            return ResolvedConstant(
+                name=key,
+                value=value,
+                source_type="properties",
+                is_default=True,
+            )
+        return None
+
+    def resolve_value(
+        self,
+        expression: str,
+        in_file: Path | None = None,
+    ) -> str | None:
+        result = self.resolve(expression, in_file)
+        return result.value if result else None
+
+    def get_all_constants(self) -> dict[str, str]:
+        return dict(self._constants)
+
+
+# =============================================================================
+# Path resolver — handles Spring path concatenation
+# =============================================================================
+
+
+class JavaPathResolver:
+    """
+    Resolves computed route paths from String concatenation / String.format().
+
+    Currently a lightweight stub — passes through paths it cannot resolve.
+    """
+
+    def resolve(
+        self,
+        path_expression: str,
+        file_path: Path,
+        additional_context: dict[str, str] | None = None,
+    ) -> ResolvedPath:
+        # If it's already a clean path literal, pass through
+        if path_expression.startswith("/"):
+            return ResolvedPath(
+                path=path_expression,
+                confidence=1.0,
+                is_fully_resolved=True,
+            )
+        return ResolvedPath(
+            path=path_expression,
+            confidence=0.5,
+            is_fully_resolved=False,
+            unresolved_vars=[path_expression],
+        )
+
+    def get_all_constants(self) -> dict[str, str]:
+        return {}
+
+
+# =============================================================================
+# JavaLanguageServices factory
+# =============================================================================
+
+
+class JavaLanguageServices(LanguageServices):
+    """
+    Factory for Java analysis services.
+
+    Returns a JavaTypeResolver, optional JavaConstantResolver,
+    and a lightweight JavaPathResolver.
+    """
+
+    def build_type_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> TypeResolver:
+        return JavaTypeResolver(parsed_files)
+
+    def build_constant_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> ConstantResolverProtocol | None:
+        return JavaConstantResolver(parsed_files, project_root)
+
+    def build_path_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> PathResolverProtocol | None:
+        return JavaPathResolver()
+
+    def build_framework_services(
+        self,
+        framework: str,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        # Spring doesn't need a RouterRegistry equivalent —
+        # class-level @RequestMapping is handled in the plugin directly.
+        return {}
+
+    def build_context(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+        framework: str | None = None,
+    ) -> AnalysisContext:
+        type_resolver = self.build_type_resolver(parsed_files, project_root)
+        constant_resolver = self.build_constant_resolver(parsed_files, project_root)
+        path_resolver = self.build_path_resolver(parsed_files, project_root)
+
+        return AnalysisContext(
+            type_resolver=type_resolver,
+            constant_resolver=constant_resolver,
+            path_resolver=path_resolver,
+            router_registry=None,
+            project_root=project_root,
+            all_parsed_files=parsed_files,
+            language_services={},
+        )