raxe 0.4.6__py3-none-any.whl

raxe/infrastructure/rules/custom_loader.py

@@ -0,0 +1,224 @@
+"""Custom rule loader - infrastructure layer.
+
+Handles I/O operations for loading custom rules from YAML files.
+"""
+import logging
+from pathlib import Path
+
+import yaml
+
+from raxe.domain.rules.custom import CustomRuleBuilder, CustomRuleValidator
+from raxe.domain.rules.models import Rule
+
+logger = logging.getLogger(__name__)
+
+
+class CustomRuleLoader:
+    """Load custom rules from YAML files.
+
+    Infrastructure layer - handles file I/O.
+    """
+
+    def __init__(self, custom_rules_dir: Path | str | None = None):
+        """Initialize loader.
+
+        Args:
+            custom_rules_dir: Directory containing custom rule YAML files
+                             Defaults to ~/.raxe/custom_rules/
+        """
+        if custom_rules_dir is None:
+            self.custom_rules_dir = Path.home() / ".raxe" / "custom_rules"
+        else:
+            self.custom_rules_dir = Path(custom_rules_dir)
+
+        # Create directory if it doesn't exist
+        self.custom_rules_dir.mkdir(parents=True, exist_ok=True)
+
+    def load_rule_from_file(self, file_path: Path | str) -> Rule:
+        """Load a single rule from a YAML file.
+
+        Args:
+            file_path: Path to YAML file
+
+        Returns:
+            Rule object
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If file is invalid or rule is malformed
+        """
+        file_path = Path(file_path)
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"Rule file not found: {file_path}")
+
+        try:
+            with open(file_path) as f:
+                rule_dict = yaml.safe_load(f)
+
+            if not rule_dict:
+                raise ValueError(f"Empty rule file: {file_path}")
+
+            # Validate
+            is_valid, errors = CustomRuleValidator.validate_rule_dict(rule_dict)
+            if not is_valid:
+                raise ValueError(f"Invalid rule in {file_path}: {', '.join(errors)}")
+
+            # Build rule
+            rule = CustomRuleBuilder.from_dict(rule_dict)
+
+            # Test against examples
+            examples_passed, failures = CustomRuleValidator.test_rule_examples(rule)
+            if not examples_passed:
+                logger.warning(
+                    f"Rule {rule.rule_id} examples failed: {', '.join(failures[:3])}"
+                )
+
+            logger.info(f"Loaded custom rule: {rule.rule_id}@{rule.version} from {file_path}")
+            return rule
+
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in {file_path}: {e}") from e
+
+    def load_all_rules(self) -> list[Rule]:
+        """Load all custom rules from the custom rules directory.
+
+        Returns:
+            List of Rule objects (may be empty)
+        """
+        rules = []
+
+        if not self.custom_rules_dir.exists():
+            logger.debug(f"Custom rules directory doesn't exist: {self.custom_rules_dir}")
+            return rules
+
+        for yaml_file in self.custom_rules_dir.glob("*.yaml"):
+            try:
+                rule = self.load_rule_from_file(yaml_file)
+                rules.append(rule)
+            except Exception as e:
+                logger.error(f"Failed to load custom rule from {yaml_file}: {e}")
+                # Continue loading other rules
+                continue
+
+        logger.info(f"Loaded {len(rules)} custom rules from {self.custom_rules_dir}")
+        return rules
+
+    def save_rule_to_file(self, rule: Rule, file_path: Path | str | None = None) -> Path:
+        """Save a rule to a YAML file.
+
+        Args:
+            rule: Rule to save
+            file_path: Optional path to save to. If None, uses default location.
+
+        Returns:
+            Path where rule was saved
+
+        Raises:
+            ValueError: If rule is invalid
+        """
+        if file_path is None:
+            file_path = self.custom_rules_dir / f"{rule.rule_id}.yaml"
+        else:
+            file_path = Path(file_path)
+
+        # Ensure parent directory exists
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Convert to dict
+        rule_dict = CustomRuleBuilder.to_dict(rule)
+
+        # Write to file
+        with open(file_path, "w") as f:
+            yaml.dump(rule_dict, f, default_flow_style=False, sort_keys=False)
+
+        logger.info(f"Saved custom rule {rule.rule_id} to {file_path}")
+        return file_path
+
+    def delete_rule(self, rule_id: str) -> bool:
+        """Delete a custom rule file.
+
+        Args:
+            rule_id: ID of rule to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        rule_file = self.custom_rules_dir / f"{rule_id}.yaml"
+
+        if rule_file.exists():
+            rule_file.unlink()
+            logger.info(f"Deleted custom rule: {rule_id}")
+            return True
+        else:
+            logger.warning(f"Rule file not found for deletion: {rule_id}")
+            return False
+
+    def validate_file(self, file_path: Path | str) -> tuple[bool, list[str]]:
+        """Validate a rule file without loading it.
+
+        Args:
+            file_path: Path to YAML file
+
+        Returns:
+            Tuple of (is_valid, list of errors)
+        """
+        file_path = Path(file_path)
+
+        if not file_path.exists():
+            return False, [f"File not found: {file_path}"]
+
+        try:
+            with open(file_path) as f:
+                rule_dict = yaml.safe_load(f)
+
+            if not rule_dict:
+                return False, ["Empty YAML file"]
+
+            # Validate structure
+            is_valid, errors = CustomRuleValidator.validate_rule_dict(rule_dict)
+
+            if is_valid:
+                # Also try to build and test
+                rule = CustomRuleBuilder.from_dict(rule_dict)
+                examples_passed, example_errors = CustomRuleValidator.test_rule_examples(rule)
+
+                if not examples_passed:
+                    # Warn about example failures but don't fail validation
+                    errors.extend([f"Example test failed: {e}" for e in example_errors])
+
+            return is_valid, errors
+
+        except yaml.YAMLError as e:
+            return False, [f"Invalid YAML: {e}"]
+        except Exception as e:
+            return False, [f"Validation error: {e}"]
+
+    def list_custom_rules(self) -> list[dict[str, str]]:
+        """List all custom rule files.
+
+        Returns:
+            List of dicts with rule metadata (id, name, version, file_path)
+        """
+        rules_info = []
+
+        if not self.custom_rules_dir.exists():
+            return rules_info
+
+        for yaml_file in self.custom_rules_dir.glob("*.yaml"):
+            try:
+                with open(yaml_file) as f:
+                    rule_dict = yaml.safe_load(f)
+
+                if rule_dict:
+                    rules_info.append({
+                        "id": rule_dict.get("id", "unknown"),
+                        "name": rule_dict.get("name", "unknown"),
+                        "version": rule_dict.get("version", "0.0.1"),
+                        "file_path": str(yaml_file),
+                    })
+            except Exception as e:
+                logger.debug(f"Could not read metadata from {yaml_file}: {e}")
+                continue
+
+        return rules_info

raxe/infrastructure/rules/versioning.py

@@ -0,0 +1,222 @@
+"""Schema versioning and compatibility checking.
+
+Handles semantic versioning for rule schema and ensures compatibility
+between different schema versions.
+"""
+from dataclasses import dataclass
+
+
+class VersionError(Exception):
+    """Exception raised when version compatibility check fails."""
+    pass
+
+
+@dataclass(frozen=True)
+class Version:
+    """Semantic version representation.
+
+    Attributes:
+        major: Major version number (breaking changes)
+        minor: Minor version number (backward compatible features)
+        patch: Patch version number (backward compatible fixes)
+    """
+    major: int
+    minor: int
+    patch: int
+
+    def __post_init__(self) -> None:
+        """Validate version numbers are non-negative."""
+        if self.major < 0 or self.minor < 0 or self.patch < 0:
+            raise ValueError(f"Version numbers must be non-negative: {self}")
+
+    @classmethod
+    def parse(cls, version_str: str) -> 'Version':
+        """Parse semver string like '1.2.3'.
+
+        Args:
+            version_str: Version string in semver format
+
+        Returns:
+            Parsed Version object
+
+        Raises:
+            ValueError: If version string is invalid
+        """
+        parts = version_str.split('.')
+        if len(parts) != 3:
+            raise ValueError(
+                f"Version must be in semver format (X.Y.Z), got '{version_str}'"
+            )
+
+        try:
+            major = int(parts[0])
+            minor = int(parts[1])
+            patch = int(parts[2])
+            return cls(major=major, minor=minor, patch=patch)
+        except ValueError as e:
+            raise ValueError(
+                f"Version parts must be integers, got '{version_str}'"
+            ) from e
+
+    def __str__(self) -> str:
+        """Return string representation in semver format.
+
+        Returns:
+            Version string in format 'major.minor.patch'
+        """
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    def __lt__(self, other: 'Version') -> bool:
+        """Compare versions for ordering.
+
+        Args:
+            other: Version to compare against
+
+        Returns:
+            True if this version is less than other
+        """
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def __le__(self, other: 'Version') -> bool:
+        """Compare versions for ordering.
+
+        Args:
+            other: Version to compare against
+
+        Returns:
+            True if this version is less than or equal to other
+        """
+        return (self.major, self.minor, self.patch) <= (other.major, other.minor, other.patch)
+
+    def __gt__(self, other: 'Version') -> bool:
+        """Compare versions for ordering.
+
+        Args:
+            other: Version to compare against
+
+        Returns:
+            True if this version is greater than other
+        """
+        return (self.major, self.minor, self.patch) > (other.major, other.minor, other.patch)
+
+    def __ge__(self, other: 'Version') -> bool:
+        """Compare versions for ordering.
+
+        Args:
+            other: Version to compare against
+
+        Returns:
+            True if this version is greater than or equal to other
+        """
+        return (self.major, self.minor, self.patch) >= (other.major, other.minor, other.patch)
+
+    def is_compatible_with(self, other: 'Version') -> bool:
+        """Check if this version can load rules from other version.
+
+        Compatibility rules:
+        - Same major version: compatible (minor/patch differences OK)
+        - Different major version: incompatible (breaking changes)
+
+        Args:
+            other: Version to check compatibility against
+
+        Returns:
+            True if versions are compatible, False otherwise
+        """
+        return self.major == other.major
+
+
+class VersionChecker:
+    """Check schema version compatibility for rules.
+
+    Ensures that rule files are compatible with the current parser version.
+    """
+
+    # Current schema version supported by this implementation
+    CURRENT_VERSION = Version(1, 1, 0)
+
+    # Minimum supported version (can load rules from this version onwards)
+    MINIMUM_VERSION = Version(1, 0, 0)
+
+    def check_compatibility(self, rule_version: str) -> None:
+        """Verify rule schema version is compatible.
+
+        Args:
+            rule_version: Version string from rule file
+
+        Raises:
+            VersionError: If rule version is incompatible with parser
+        """
+        try:
+            rule_v = Version.parse(rule_version)
+        except ValueError as e:
+            raise VersionError(f"Invalid rule version format: {e}") from e
+
+        # Check if rule version is too old
+        if rule_v < self.MINIMUM_VERSION:
+            raise VersionError(
+                f"Rule schema v{rule_version} is too old. "
+                f"Minimum supported version is v{self.MINIMUM_VERSION}"
+            )
+
+        # Check major version compatibility
+        if not self.CURRENT_VERSION.is_compatible_with(rule_v):
+            raise VersionError(
+                f"Rule schema v{rule_version} is incompatible with "
+                f"parser v{self.CURRENT_VERSION}. "
+                f"Major version mismatch indicates breaking changes."
+            )
+
+        # Warn if rule is newer minor/patch version (still compatible)
+        if rule_v > self.CURRENT_VERSION:
+            # This is a warning condition, not an error
+            # Could be logged, but we don't do logging in infrastructure
+            pass
+
+    def is_compatible(self, rule_version: str) -> bool:
+        """Check if rule version is compatible without raising exception.
+
+        Args:
+            rule_version: Version string from rule file
+
+        Returns:
+            True if compatible, False otherwise
+        """
+        try:
+            self.check_compatibility(rule_version)
+            return True
+        except VersionError:
+            return False
+
+    def get_migration_path(
+        self,
+        from_version: str,
+        to_version: str | None = None
+    ) -> list[tuple[Version, Version]]:
+        """Get the migration path between two versions.
+
+        Future use: Returns list of version transitions needed for migration.
+
+        Args:
+            from_version: Starting version
+            to_version: Target version (defaults to CURRENT_VERSION)
+
+        Returns:
+            List of (from, to) version tuples representing migration steps
+
+        Raises:
+            VersionError: If migration path doesn't exist
+        """
+        from_v = Version.parse(from_version)
+        to_v = Version.parse(to_version) if to_version else self.CURRENT_VERSION
+
+        # For now, only same-major migrations are supported
+        if not from_v.is_compatible_with(to_v):
+            raise VersionError(
+                f"Cannot migrate from v{from_v} to v{to_v}: "
+                f"different major versions (breaking changes)"
+            )
+
+        # If versions are compatible, no migration needed
+        # Future: Could return intermediate migration steps
+        return [(from_v, to_v)] if from_v != to_v else []