tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/platform_compat/profiles.py

@@ -0,0 +1,217 @@
+import json
+import logging
+import threading
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import jsonschema
+from cachetools import TTLCache
+
+logger = logging.getLogger(__name__)
+
+PROFILE_SCHEMA_VERSION = "1.0.0"
+
+
+@dataclass
+class ParsingBehavior:
+    """Describes how a specific SQL construct parses on a platform."""
+
+    construct_id: str
+    node_type: str
+    element_count: int
+    attributes: list[str]
+    has_error: bool
+    known_issues: list[str] = field(default_factory=list)
+
+
+@dataclass
+class BehaviorProfile:
+    """Complete behavior profile for a platform."""
+
+    schema_version: str
+    platform_key: str
+    behaviors: dict[str, ParsingBehavior]
+    adaptation_rules: list[str]
+
+    def __post_init__(self):
+        """Ensure behaviors are ParsingBehavior objects."""
+        if self.behaviors:
+            for key, value in self.behaviors.items():
+                if isinstance(value, dict):
+                    self.behaviors[key] = ParsingBehavior(**value)
+
+    @classmethod
+    def load(
+        cls, platform_key: str, base_path: Path | None = None
+    ) -> Optional["BehaviorProfile"]:
+        """
+        Loads a profile for the given platform key.
+
+        Args:
+            platform_key: The platform key (e.g. "windows-3.12").
+            base_path: The base directory where profiles are stored.
+
+        Returns:
+            BehaviorProfile: The loaded profile, or None if not found.
+        """
+        if base_path is None:
+            # Default to tests/platform_profiles relative to package root?
+            # Or maybe we should require base_path.
+            # For now, let's assume the caller provides it or we look in a standard location.
+            # Let's try to find the package root.
+            current_file = Path(__file__)
+            # tree_sitter_analyzer/platform_compat/profiles.py -> tree_sitter_analyzer/ -> root
+            package_root = current_file.parent.parent.parent
+            base_path = package_root / "tests" / "platform_profiles"
+
+        # We need to reconstruct the path from the key
+        # key format: os-version
+        try:
+            parts = platform_key.split("-")
+            os_name = parts[0]
+            python_version = parts[1]
+        except IndexError:
+            logger.error(f"Invalid platform key format: {platform_key}")
+            return None
+
+        profile_path = base_path / os_name / python_version / "profile.json"
+
+        if not profile_path.exists():
+            logger.warning(f"Profile not found for {platform_key} at {profile_path}")
+            return None
+
+        try:
+            with open(profile_path, encoding="utf-8") as f:
+                data = json.load(f)
+
+            validate_profile(data)
+            data = migrate_profile_schema(data)
+
+            # Convert behaviors dict to ParsingBehavior objects
+            behaviors = {}
+            for key, b_data in data.get("behaviors", {}).items():
+                behaviors[key] = ParsingBehavior(**b_data)
+
+            return cls(
+                schema_version=data["schema_version"],
+                platform_key=data["platform_key"],
+                behaviors=behaviors,
+                adaptation_rules=data.get("adaptation_rules", []),
+            )
+        except Exception as e:
+            logger.error(f"Error loading profile for {platform_key}: {e}")
+            return None
+
+    def save(self, base_path: Path) -> None:
+        """Saves the profile to disk."""
+        parts = self.platform_key.split("-")
+        os_name = parts[0]
+        python_version = parts[1]
+
+        profile_dir = base_path / os_name / python_version
+        profile_dir.mkdir(parents=True, exist_ok=True)
+
+        profile_path = profile_dir / "profile.json"
+
+        data = asdict(self)
+
+        with open(profile_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+
+
+# Schema definition
+PROFILE_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "schema_version": {"type": "string"},
+        "platform_key": {"type": "string"},
+        "behaviors": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "object",
+                "properties": {
+                    "construct_id": {"type": "string"},
+                    "node_type": {"type": "string"},
+                    "element_count": {"type": "integer"},
+                    "attributes": {"type": "array", "items": {"type": "string"}},
+                    "has_error": {"type": "boolean"},
+                    "known_issues": {"type": "array", "items": {"type": "string"}},
+                },
+                "required": [
+                    "construct_id",
+                    "node_type",
+                    "element_count",
+                    "attributes",
+                    "has_error",
+                ],
+            },
+        },
+        "adaptation_rules": {"type": "array", "items": {"type": "string"}},
+    },
+    "required": ["schema_version", "platform_key", "behaviors", "adaptation_rules"],
+}
+
+
+def validate_profile(data: dict[str, Any]) -> None:
+    """Validates profile data against the schema."""
+    jsonschema.validate(instance=data, schema=PROFILE_SCHEMA)
+
+
+def migrate_profile_schema(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrates profile data to the current schema version."""
+    version = data.get("schema_version", "0.0.0")
+    if version == PROFILE_SCHEMA_VERSION:
+        return data
+
+    if version == "0.0.0":
+        return migrate_to_1_0_0(data)
+
+    return data
+
+
+def migrate_to_1_0_0(data: dict[str, Any]) -> dict[str, Any]:
+    """Initial migration to 1.0.0."""
+    data["schema_version"] = "1.0.0"
+    if "behaviors" not in data:
+        data["behaviors"] = {}
+    if "adaptation_rules" not in data:
+        data["adaptation_rules"] = []
+    return data
+
+
+class ProfileCache:
+    """Thread-safe cache for behavior profiles."""
+
+    def __init__(self, maxsize: int = 10, ttl: int = 3600):
+        self._cache = TTLCache(maxsize=maxsize, ttl=ttl)
+        self._lock = threading.RLock()
+        self._hits = 0
+        self._misses = 0
+
+    def get(self, key: str) -> BehaviorProfile | None:
+        with self._lock:
+            if key in self._cache:
+                self._hits += 1
+                return self._cache[key]
+            self._misses += 1
+            return None
+
+    def put(self, key: str, profile: BehaviorProfile) -> None:
+        with self._lock:
+            self._cache[key] = profile
+
+    def clear(self) -> None:
+        with self._lock:
+            self._cache.clear()
+            self._hits = 0
+            self._misses = 0
+
+    @property
+    def stats(self) -> dict[str, int]:
+        with self._lock:
+            return {
+                "hits": self._hits,
+                "misses": self._misses,
+                "size": len(self._cache),
+            }

tree_sitter_analyzer/platform_compat/record.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+CLI tool for recording SQL behavior profiles.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from tree_sitter_analyzer.platform_compat.recorder import BehaviorRecorder
+from tree_sitter_analyzer.utils import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Record SQL behavior profile for current platform"
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        help="Directory to save the profile",
+        default="tests/platform_profiles",
+    )
+    args = parser.parse_args()
+
+    try:
+        logger.info("Starting SQL behavior recording...")
+        recorder = BehaviorRecorder()
+        profile = recorder.record_all()
+
+        logger.info(f"Recorded profile for {profile.platform_key}")
+        logger.info(f"Captured {len(profile.behaviors)} behaviors")
+
+        output_dir = Path(args.output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Save profile
+        # The save method expects a base path and constructs the structure {os}/{python}/profile.json
+        # But if we want to save to a specific artifact directory in CI, we might want more control.
+        # BehaviorProfile.save(base_path) does:
+        # path = base_path / self.platform_key.replace("-", "/") / "profile.json"
+
+        # Let's use the standard save mechanism
+        profile.save(output_dir)
+        logger.info(f"Profile saved to {output_dir}")
+
+    except Exception as e:
+        logger.error(f"Failed to record profile: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tree_sitter_analyzer/platform_compat/recorder.py

@@ -0,0 +1,155 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+import tree_sitter
+import tree_sitter_sql
+
+from tree_sitter_analyzer.platform_compat.detector import PlatformDetector
+from tree_sitter_analyzer.platform_compat.fixtures import ALL_FIXTURES, SQLTestFixture
+from tree_sitter_analyzer.platform_compat.profiles import (
+    PROFILE_SCHEMA_VERSION,
+    BehaviorProfile,
+    ParsingBehavior,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BehaviorRecorder:
+    """Records SQL parsing behavior on the current platform."""
+
+    def __init__(self):
+        self.language = tree_sitter.Language(tree_sitter_sql.language())
+        self.parser = tree_sitter.Parser(self.language)
+        self.platform_info = PlatformDetector.detect()
+
+    def record_all(self) -> BehaviorProfile:
+        """
+        Records behavior for all fixtures.
+
+        Returns:
+            BehaviorProfile: The recorded profile.
+        """
+        behaviors = {}
+
+        for fixture in ALL_FIXTURES:
+            behavior = self.record_fixture(fixture)
+            behaviors[fixture.id] = behavior
+
+        return BehaviorProfile(
+            schema_version=PROFILE_SCHEMA_VERSION,
+            platform_key=self.platform_info.platform_key,
+            behaviors=behaviors,
+            adaptation_rules=[],  # Rules are added manually or via analysis, not recording
+        )
+
+    def record_fixture(self, fixture: SQLTestFixture) -> ParsingBehavior:
+        """
+        Records behavior for a single fixture.
+
+        Args:
+            fixture: The fixture to record.
+
+        Returns:
+            ParsingBehavior: The recorded behavior.
+        """
+        tree = self.parser.parse(bytes(fixture.sql, "utf8"))
+        root_node = tree.root_node
+
+        # Analyze AST
+        analysis = self.analyze_ast(root_node)
+
+        return ParsingBehavior(
+            construct_id=fixture.id,
+            node_type=root_node.type,
+            element_count=analysis["element_count"],
+            attributes=analysis["attributes"],
+            has_error=analysis["has_error"],
+            known_issues=[],  # Populated by comparison or manual review
+        )
+
+    def analyze_ast(self, node: Any) -> dict[str, Any]:
+        """
+        Analyzes the AST to extract characteristics.
+
+        Args:
+            node: The root node of the AST.
+
+        Returns:
+            Dict containing analysis results.
+        """
+        element_count = 0
+        attributes = set()
+        has_error = False
+
+        # Traverse the tree
+        cursor = node.walk()
+        visited_children = False
+
+        while True:
+            if not visited_children:
+                # Process current node
+                if cursor.node.type == "ERROR":
+                    has_error = True
+
+                # Count "interesting" elements (top-level statements usually)
+                # This is a simplification; we might want to count specific types
+                # based on the fixture expectation.
+                # For now, let's count nodes that look like definitions.
+                if cursor.node.type in {
+                    "create_table_statement",
+                    "create_view_statement",
+                    "create_procedure_statement",
+                    "create_function_statement",
+                    "create_trigger_statement",
+                    "create_index_statement",
+                }:
+                    element_count += 1
+
+                # Collect attributes (field names)
+                if cursor.node.type == "column_definition":
+                    # Try to find column name
+                    name_node = cursor.node.child_by_field_name("name")
+                    if name_node:
+                        attributes.add(f"col:{name_node.text.decode('utf8')}")
+
+                # Check for specific attributes we care about
+                # e.g. if it's a function, does it have parameters?
+
+                if cursor.goto_first_child():
+                    continue
+
+            if cursor.goto_next_sibling():
+                visited_children = False
+                continue
+
+            if cursor.goto_parent():
+                visited_children = True
+                continue
+
+            break
+
+        return {
+            "element_count": element_count,
+            "attributes": sorted(attributes),
+            "has_error": has_error,
+        }
+
+    def save_profile(self, profile: BehaviorProfile, base_path: Path) -> None:
+        """
+        Saves the recorded profile to disk.
+
+        Args:
+            profile: The profile to save.
+            base_path: The base directory.
+        """
+        profile.save(base_path)
+
+
+if __name__ == "__main__":
+    # Simple CLI for testing
+    recorder = BehaviorRecorder()
+    profile = recorder.record_all()
+    print(f"Recorded profile for {profile.platform_key}")
+    print(f"Behaviors: {len(profile.behaviors)}")

tree_sitter_analyzer/platform_compat/report.py

@@ -0,0 +1,92 @@
+import json
+from pathlib import Path
+
+from .profiles import BehaviorProfile, ParsingBehavior
+
+
+def generate_compatibility_matrix(profiles_dir: Path) -> str:
+    """
+    Generates a compatibility matrix report from a directory of profiles.
+
+    Args:
+        profiles_dir: Directory containing profile JSON files (recursively).
+
+    Returns:
+        str: Markdown formatted report.
+    """
+    profiles: list[BehaviorProfile] = []
+
+    # Find all profile.json files
+    for path in profiles_dir.rglob("profile.json"):
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+                # Basic validation
+                if "platform_key" in data:
+                    # Manual deserialization of nested objects
+                    behaviors = {}
+                    for key, b_data in data.get("behaviors", {}).items():
+                        if isinstance(b_data, dict):
+                            behaviors[key] = ParsingBehavior(**b_data)
+                        else:
+                            behaviors[key] = b_data
+
+                    profile = BehaviorProfile(
+                        schema_version=data.get("schema_version", "1.0.0"),
+                        platform_key=data["platform_key"],
+                        behaviors=behaviors,
+                        adaptation_rules=data.get("adaptation_rules", []),
+                    )
+                    profiles.append(profile)
+        except Exception:  # nosec
+            continue
+
+    if not profiles:
+        return "No profiles found."
+
+    # Sort profiles
+    profiles.sort(key=lambda p: p.platform_key)
+
+    # Collect all constructs
+    all_constructs = set()
+    for p in profiles:
+        all_constructs.update(p.behaviors.keys())
+    sorted_constructs = sorted(all_constructs)
+
+    # Build Matrix
+    # Rows: Constructs
+    # Cols: Platforms
+
+    lines = ["# SQL Compatibility Matrix", "", "| Construct |"]
+
+    # Header row
+    for p in profiles:
+        lines[0] += f" {p.platform_key} |"
+    lines.append("|" + "---|" * (len(profiles) + 1))
+
+    # Data rows
+    for construct in sorted_constructs:
+        row = f"| {construct} |"
+        for p in profiles:
+            behavior = p.behaviors.get(construct)
+            if not behavior:
+                status = "❌ Missing"
+            elif behavior.has_error:
+                status = "⚠️ Error"
+            else:
+                status = "✅ OK"
+            row += f" {status} |"
+        lines.append(row)
+
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate compatibility matrix")
+    parser.add_argument("profiles_dir", type=str, help="Directory containing profiles")
+    args = parser.parse_args()
+
+    report = generate_compatibility_matrix(Path(args.profiles_dir))
+    print(report)