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

apisec_code_bolt/parsing/csharp/language_services.py

@@ -0,0 +1,203 @@
+"""
+C#-specific LanguageServices factory.
+
+Implements the LanguageServices abstract class for C#/.NET, wiring together:
+- CSharpTypeResolver (cross-file class/interface/record resolution with
+  transitive inheritance — see type_resolver.py)
+- CSharpConstantResolver (appsettings.json / environment variables)
+- CSharpPathResolver (string interpolation — stub for now)
+"""
+
+from __future__ import annotations
+
+import json
+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 CSharpTypeResolver
+
+if TYPE_CHECKING:
+    from ..base import ParsedFile
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Constant resolver — reads appsettings.json / environment variables
+# =============================================================================
+
+
+class CSharpConstantResolver:
+    """
+    Resolves constants from appsettings.json and environment variable patterns.
+    """
+
+    def __init__(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> None:
+        self._constants: dict[str, str] = {}
+        self._load_appsettings(project_root)
+
+    def _load_appsettings(self, project_root: Path | None) -> None:
+        if project_root is None:
+            return
+        for candidate in [
+            project_root / "appsettings.json",
+            project_root / "appsettings.Development.json",
+        ]:
+            if not candidate.exists():
+                continue
+            try:
+                data = json.loads(candidate.read_text(encoding="utf-8"))
+                self._flatten_json(data, "")
+            except Exception as exc:
+                logger.debug("Could not load %s: %s", candidate, exc)
+
+    def _flatten_json(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_json(v, full_key)
+        elif isinstance(data, (str, int, float, bool)):
+            self._constants[prefix] = str(data)
+
+    # ConstantResolver protocol
+    def resolve(
+        self,
+        expression: str,
+        in_file: Path | None = None,
+    ) -> ResolvedConstant | None:
+        value = self._constants.get(expression)
+        if value is not None:
+            return ResolvedConstant(
+                name=expression,
+                value=value,
+                source_type="appsettings",
+                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
+# =============================================================================
+
+
+class CSharpPathResolver:
+    """
+    Resolves computed route paths from string interpolation / concatenation.
+
+    Lightweight stub — passes through already-clean paths.
+    """
+
+    def resolve(
+        self,
+        path_expression: str,
+        file_path: Path,
+        additional_context: dict[str, str] | None = None,
+    ) -> ResolvedPath:
+        if path_expression.startswith("/") or path_expression.startswith("api/"):
+            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 {}
+
+
+# =============================================================================
+# CSharpLanguageServices factory
+# =============================================================================
+
+
+class CSharpLanguageServices(LanguageServices):
+    """
+    Factory for C# analysis services.
+
+    Returns a CSharpTypeResolver, optional CSharpConstantResolver,
+    and a lightweight CSharpPathResolver.
+    """
+
+    def build_type_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> TypeResolver:
+        return CSharpTypeResolver(parsed_files)
+
+    def build_constant_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> ConstantResolverProtocol | None:
+        return CSharpConstantResolver(parsed_files, project_root)
+
+    def build_path_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> PathResolverProtocol | None:
+        return CSharpPathResolver()
+
+    def build_framework_services(
+        self,
+        framework: str,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        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={},
+        )

apisec_code_bolt/parsing/csharp/literals.py

@@ -0,0 +1,72 @@
+"""C# string-literal parsing utilities.
+
+Used by route / endpoint extractors that need to read a URL template
+or address string out of source code without tokenising the whole
+file.  Handles the two C# literal forms that show up in real route
+declarations:
+
+  - Plain:    `"api/users"` — `\\` escapes the next character.
+  - Verbatim: `@"api/users"` — `\\` is literal; `""` is the escape
+              for an embedded `"`, decoded back to a single `"` in
+              the returned content.
+
+Interpolated `$"..."` and the verbatim-interpolated `$@"..."` /
+`@$"..."` are NOT handled here.  Callers that want to defer those
+should bail when they see a `$` at the start of the literal — and
+typically do, since interpolated route templates can't be matched
+against resolved-value ground truth without a constant-resolution
+pass first.
+"""
+
+from __future__ import annotations
+
+
+def parse_csharp_string_literal(
+    text: str,
+    start: int,
+) -> tuple[str, int, int] | None:
+    """
+    Parse a C# string literal at `text[start:]`, skipping leading whitespace.
+
+    Returns `(content, open_quote_pos, after_close_quote_pos)` — both
+    positions absolute in `text` — or None when no literal starts at
+    the position (after the optional whitespace prefix).
+    """
+    j = start
+    while j < len(text) and text[j] in " \t\r\n":
+        j += 1
+    is_verbatim = False
+    if j < len(text) and text[j] == "@":
+        is_verbatim = True
+        j += 1
+    if j >= len(text) or text[j] != '"':
+        return None
+    open_pos = j
+    k = j + 1
+    if is_verbatim:
+        pieces: list[str] = []
+        content_start = k
+        while k < len(text):
+            if text[k] == '"':
+                if k + 1 < len(text) and text[k + 1] == '"':
+                    # `""` → literal quote, continue scanning.
+                    pieces.append(text[content_start:k])
+                    pieces.append('"')
+                    k += 2
+                    content_start = k
+                    continue
+                # Lone `"` ends the verbatim string.
+                pieces.append(text[content_start:k])
+                return "".join(pieces), open_pos, k + 1
+            k += 1
+        return None
+    # Plain literal: `\` escapes the next char.
+    content_start = k
+    while k < len(text):
+        if text[k] == "\\":
+            k += 2
+            continue
+        if text[k] == '"':
+            return text[content_start:k], open_pos, k + 1
+        k += 1
+    return None