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

tree_sitter_analyzer/platform_compat/compare.py

@@ -0,0 +1,224 @@
+from dataclasses import dataclass
+from typing import Any
+
+from deepdiff import DeepDiff
+
+from .profiles import BehaviorProfile
+
+
+@dataclass
+class BehaviorDifference:
+    """Represents a difference in behavior for a specific construct."""
+
+    construct_id: str
+    diff_type: (
+        str  # "missing", "attribute_mismatch", "error_mismatch", "count_mismatch"
+    )
+    details: str
+    platform_a_value: Any
+    platform_b_value: Any
+
+
+@dataclass
+class ProfileComparison:
+    """Result of comparing two profiles."""
+
+    platform_a: str
+    platform_b: str
+    differences: list[BehaviorDifference]
+
+    @property
+    def has_differences(self) -> bool:
+        return len(self.differences) > 0
+
+
+def compare_profiles(
+    profile_a: BehaviorProfile, profile_b: BehaviorProfile
+) -> ProfileComparison:
+    """
+    Compares two behavior profiles and identifies differences.
+
+    Args:
+        profile_a: First profile.
+        profile_b: Second profile.
+
+    Returns:
+        ProfileComparison: The comparison result.
+    """
+    differences = []
+
+    # Check for missing constructs
+    keys_a = set(profile_a.behaviors.keys())
+    keys_b = set(profile_b.behaviors.keys())
+
+    for key in keys_a - keys_b:
+        differences.append(
+            BehaviorDifference(
+                construct_id=key,
+                diff_type="missing",
+                details=f"Construct {key} missing in {profile_b.platform_key}",
+                platform_a_value="present",
+                platform_b_value="missing",
+            )
+        )
+
+    for key in keys_b - keys_a:
+        differences.append(
+            BehaviorDifference(
+                construct_id=key,
+                diff_type="missing",
+                details=f"Construct {key} missing in {profile_a.platform_key}",
+                platform_a_value="missing",
+                platform_b_value="present",
+            )
+        )
+
+    # Compare common constructs
+    for key in keys_a.intersection(keys_b):
+        beh_a = profile_a.behaviors[key]
+        beh_b = profile_b.behaviors[key]
+
+        # Compare error status
+        if beh_a.has_error != beh_b.has_error:
+            differences.append(
+                BehaviorDifference(
+                    construct_id=key,
+                    diff_type="error_mismatch",
+                    details=f"Error status mismatch for {key}",
+                    platform_a_value=beh_a.has_error,
+                    platform_b_value=beh_b.has_error,
+                )
+            )
+
+        # Compare element count
+        if beh_a.element_count != beh_b.element_count:
+            differences.append(
+                BehaviorDifference(
+                    construct_id=key,
+                    diff_type="count_mismatch",
+                    details=f"Element count mismatch for {key}",
+                    platform_a_value=beh_a.element_count,
+                    platform_b_value=beh_b.element_count,
+                )
+            )
+
+        # Compare attributes
+        # We use DeepDiff for detailed comparison if needed, or just set comparison
+        if beh_a.attributes != beh_b.attributes:
+            # Use DeepDiff to get readable diff
+            diff = DeepDiff(beh_a.attributes, beh_b.attributes, ignore_order=True)
+            if diff:
+                differences.append(
+                    BehaviorDifference(
+                        construct_id=key,
+                        diff_type="attribute_mismatch",
+                        details=f"Attributes mismatch for {key}",
+                        platform_a_value=beh_a.attributes,
+                        platform_b_value=beh_b.attributes,
+                    )
+                )
+
+    return ProfileComparison(
+        platform_a=profile_a.platform_key,
+        platform_b=profile_b.platform_key,
+        differences=differences,
+    )
+
+
+def generate_diff_report(comparison: ProfileComparison) -> str:
+    """
+    Generates a human-readable report of the differences.
+
+    Args:
+        comparison: The comparison result.
+
+    Returns:
+        str: The report text.
+    """
+    if not comparison.has_differences:
+        return f"No differences found between {comparison.platform_a} and {comparison.platform_b}."
+
+    lines = [
+        f"Comparison Report: {comparison.platform_a} vs {comparison.platform_b}",
+        "=" * 60,
+        f"Total differences: {len(comparison.differences)}",
+        "",
+    ]
+
+    for diff in comparison.differences:
+        lines.append(f"Construct: {diff.construct_id}")
+        lines.append(f"Type: {diff.diff_type}")
+        lines.append(f"Details: {diff.details}")
+        lines.append(f"  {comparison.platform_a}: {diff.platform_a_value}")
+        lines.append(f"  {comparison.platform_b}: {diff.platform_b_value}")
+        lines.append("-" * 40)
+
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+    from pathlib import Path
+
+    parser = argparse.ArgumentParser(description="Compare two SQL behavior profiles")
+    parser.add_argument("profile_a", type=str, help="Path to first profile")
+    parser.add_argument("profile_b", type=str, help="Path to second profile")
+    parser.add_argument(
+        "--fail-on-diff",
+        action="store_true",
+        help="Exit with error code if differences found",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        path_a = Path(args.profile_a)
+        path_b = Path(args.profile_b)
+
+        if not path_a.exists():
+            print(f"Error: Profile not found: {path_a}")
+            sys.exit(1)
+
+        if not path_b.exists():
+            print(f"Error: Profile not found: {path_b}")
+            sys.exit(1)
+
+        # Load profiles manually since BehaviorProfile.load expects a platform key
+        # We need to load from specific files
+        import json
+
+        from .profiles import BehaviorProfile, ParsingBehavior
+
+        def load_profile_from_file(path: Path) -> BehaviorProfile:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+
+            # Convert behaviors dict to ParsingBehavior 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
+
+            return BehaviorProfile(
+                schema_version=data.get("schema_version", "1.0.0"),
+                platform_key=data["platform_key"],
+                behaviors=behaviors,
+                adaptation_rules=data.get("adaptation_rules", []),
+            )
+
+        profile_a = load_profile_from_file(path_a)
+        profile_b = load_profile_from_file(path_b)
+
+        comparison = compare_profiles(profile_a, profile_b)
+        report = generate_diff_report(comparison)
+        print(report)
+
+        if args.fail_on_diff and comparison.has_differences:
+            sys.exit(1)
+
+    except Exception as e:
+        print(f"Error comparing profiles: {e}")
+        sys.exit(1)

tree_sitter_analyzer/platform_compat/detector.py

@@ -0,0 +1,67 @@
+import platform
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class PlatformInfo:
+    """Platform identification information."""
+
+    os_name: str
+    os_version: str
+    python_version: str
+    platform_key: str
+
+
+class PlatformDetector:
+    """Detects current platform and Python version."""
+
+    @staticmethod
+    def detect() -> PlatformInfo:
+        """
+        Detects the current platform information.
+
+        Returns:
+            PlatformInfo: The detected platform information.
+        """
+        os_name = platform.system().lower()
+        os_version = platform.release()
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+        # Normalize os_name
+        if os_name == "darwin":
+            os_name = "macos"
+
+        platform_key = f"{os_name}-{python_version}"
+
+        return PlatformInfo(
+            os_name=os_name,
+            os_version=os_version,
+            python_version=python_version,
+            platform_key=platform_key,
+        )
+
+    @staticmethod
+    def get_profile_path(
+        base_path: Path, platform_info: PlatformInfo | None = None
+    ) -> Path:
+        """
+        Resolves the path to the profile file for the given platform.
+
+        Args:
+            base_path: The base directory where profiles are stored.
+            platform_info: The platform info to use. If None, detects current platform.
+
+        Returns:
+            Path: The path to the profile file.
+        """
+        if platform_info is None:
+            platform_info = PlatformDetector.detect()
+
+        return (
+            base_path
+            / platform_info.os_name
+            / platform_info.python_version
+            / "profile.json"
+        )

tree_sitter_analyzer/platform_compat/fixtures.py

@@ -0,0 +1,228 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class SQLTestFixture:
+    """A SQL code sample for testing platform compatibility."""
+
+    id: str
+    sql: str
+    description: str
+    expected_constructs: list[
+        str
+    ]  # List of construct types expected (e.g. "table", "view")
+    is_edge_case: bool = False
+    known_platform_issues: list[str] | None = None
+
+
+# Standard SQL constructs
+
+FIXTURE_SIMPLE_TABLE = SQLTestFixture(
+    id="simple_table",
+    sql="""
+    CREATE TABLE users (
+        id INT PRIMARY KEY,
+        username VARCHAR(50) NOT NULL,
+        email VARCHAR(100)
+    );
+    """,
+    description="Basic table with columns",
+    expected_constructs=["table"],
+)
+
+FIXTURE_COMPLEX_TABLE = SQLTestFixture(
+    id="complex_table",
+    sql="""
+    CREATE TABLE orders (
+        order_id INT PRIMARY KEY,
+        user_id INT,
+        order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        total_amount DECIMAL(10, 2),
+        CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+    """,
+    description="Table with constraints and foreign keys",
+    expected_constructs=["table"],
+)
+
+FIXTURE_VIEW_WITH_JOIN = SQLTestFixture(
+    id="view_with_join",
+    sql="""
+    CREATE VIEW user_orders AS
+    SELECT u.username, o.order_date, o.total_amount
+    FROM users u
+    JOIN orders o ON u.id = o.user_id;
+    """,
+    description="View with JOIN operations",
+    expected_constructs=["view"],
+)
+
+FIXTURE_STORED_PROCEDURE = SQLTestFixture(
+    id="stored_procedure",
+    sql="""
+    CREATE PROCEDURE GetUserOrders(IN userId INT)
+    BEGIN
+        SELECT * FROM orders WHERE user_id = userId;
+    END;
+    """,
+    description="Procedure with parameters",
+    expected_constructs=["procedure"],
+)
+
+FIXTURE_FUNCTION_WITH_PARAMS = SQLTestFixture(
+    id="function_with_params",
+    sql="""
+    CREATE FUNCTION CalculateTax(amount DECIMAL(10,2))
+    RETURNS DECIMAL(10,2)
+    BEGIN
+        RETURN amount * 0.15;
+    END;
+    """,
+    description="Function with parameters and return type",
+    expected_constructs=["function"],
+)
+
+FIXTURE_TRIGGER_BEFORE_INSERT = SQLTestFixture(
+    id="trigger_before_insert",
+    sql="""
+    CREATE TRIGGER before_order_insert
+    BEFORE INSERT ON orders
+    FOR EACH ROW
+    BEGIN
+        SET NEW.order_date = NOW();
+    END;
+    """,
+    description="Trigger with timing and event",
+    expected_constructs=["trigger"],
+)
+
+FIXTURE_INDEX_UNIQUE = SQLTestFixture(
+    id="index_unique",
+    sql="""
+    CREATE UNIQUE INDEX idx_user_email ON users(email);
+    """,
+    description="Unique index on table",
+    expected_constructs=["index"],
+)
+
+# Edge case fixtures for platform issues
+
+FIXTURE_FUNCTION_WITH_SELECT = SQLTestFixture(
+    id="function_with_select",
+    sql="""
+    CREATE FUNCTION GetTotalSales() RETURNS DECIMAL(10,2)
+    BEGIN
+        DECLARE total DECIMAL(10,2);
+        SELECT SUM(total_amount) INTO total FROM orders;
+        RETURN total;
+    END;
+    """,
+    description="Function with SELECT in body (Ubuntu 3.12 issue)",
+    expected_constructs=["function"],
+    is_edge_case=True,
+    known_platform_issues=["ubuntu-3.12"],
+)
+
+FIXTURE_TRIGGER_WITH_DESCRIPTION = SQLTestFixture(
+    id="trigger_with_description",
+    sql="""
+    CREATE TRIGGER update_description
+    BEFORE UPDATE ON products
+    FOR EACH ROW
+    BEGIN
+        -- Trigger logic here
+    END;
+    """,
+    description="Trigger name extraction (macOS issue where name might be confused with description keyword if present)",
+    expected_constructs=["trigger"],
+    is_edge_case=True,
+    known_platform_issues=["macos"],
+)
+
+FIXTURE_FUNCTION_WITH_AUTO_INCREMENT = SQLTestFixture(
+    id="function_with_auto_increment",
+    sql="""
+    CREATE TABLE items (
+        id INT AUTO_INCREMENT PRIMARY KEY
+    );
+
+    CREATE FUNCTION GetNextId() RETURNS INT
+    BEGIN
+        RETURN 1;
+    END;
+    """,
+    description="Function near AUTO_INCREMENT (Windows issue)",
+    expected_constructs=["table", "function"],
+    is_edge_case=True,
+    known_platform_issues=["windows"],
+)
+
+FIXTURE_VIEW_IN_ERROR_NODE = SQLTestFixture(
+    id="view_in_error_node",
+    sql="""
+    -- Some complex SQL that might confuse the parser
+    CREATE VIEW complex_view AS
+    WITH cte AS (SELECT 1)
+    SELECT * FROM cte;
+    """,
+    description="View that appears in ERROR nodes on some platforms",
+    expected_constructs=["view"],
+    is_edge_case=True,
+)
+
+FIXTURE_PHANTOM_TRIGGER = SQLTestFixture(
+    id="phantom_trigger",
+    sql="""
+    -- A comment that looks like a trigger
+    -- CREATE TRIGGER phantom_trigger
+    CREATE TABLE real_table (id INT);
+    """,
+    description="Trigger that creates phantom elements on some platforms",
+    expected_constructs=["table"],  # Should NOT contain trigger
+    is_edge_case=True,
+    known_platform_issues=["ubuntu-3.12"],
+)
+
+FIXTURE_PROCEDURE_WITH_COMMENTS = SQLTestFixture(
+    id="procedure_with_comments",
+    sql="""
+    CREATE PROCEDURE ComplexProc()
+    BEGIN
+        /*
+           Multi-line comment
+           that might confuse parser
+        */
+        SELECT 1;
+    END;
+    """,
+    description="Procedure with complex comments",
+    expected_constructs=["procedure"],
+    is_edge_case=True,
+)
+
+FIXTURE_INDEX_ON_EXPRESSION = SQLTestFixture(
+    id="index_on_expression",
+    sql="""
+    CREATE INDEX idx_lower_email ON users((lower(email)));
+    """,
+    description="Index on expression",
+    expected_constructs=["index"],
+    is_edge_case=True,
+)
+
+ALL_FIXTURES = [
+    FIXTURE_SIMPLE_TABLE,
+    FIXTURE_COMPLEX_TABLE,
+    FIXTURE_VIEW_WITH_JOIN,
+    FIXTURE_STORED_PROCEDURE,
+    FIXTURE_FUNCTION_WITH_PARAMS,
+    FIXTURE_TRIGGER_BEFORE_INSERT,
+    FIXTURE_INDEX_UNIQUE,
+    FIXTURE_FUNCTION_WITH_SELECT,
+    FIXTURE_TRIGGER_WITH_DESCRIPTION,
+    FIXTURE_FUNCTION_WITH_AUTO_INCREMENT,
+    FIXTURE_VIEW_IN_ERROR_NODE,
+    FIXTURE_PHANTOM_TRIGGER,
+    FIXTURE_PROCEDURE_WITH_COMMENTS,
+    FIXTURE_INDEX_ON_EXPRESSION,
+]