yuho 5.0.0__py3-none-any.whl

yuho/testing/coverage.py

@@ -0,0 +1,274 @@
+"""
+Coverage tracking for Yuho statute test implementations.
+
+Tracks which elements, conditions, and branches are exercised by tests.
+"""
+
+from typing import Dict, List, Set, Optional, Any
+from dataclasses import dataclass, field
+from pathlib import Path
+import json
+
+
+@dataclass
+class ElementCoverage:
+    """Coverage tracking for a single statute element."""
+    element_type: str  # actus_reus, mens_rea, circumstance
+    name: str
+    covered: bool = False
+    test_count: int = 0
+    test_files: List[str] = field(default_factory=list)
+
+
+@dataclass
+class StatuteCoverage:
+    """Coverage tracking for a single statute."""
+    section_number: str
+    title: str = ""
+    elements: Dict[str, ElementCoverage] = field(default_factory=dict)
+    penalty_covered: bool = False
+    illustrations_covered: Set[str] = field(default_factory=set)
+    total_illustrations: int = 0
+
+    @property
+    def element_coverage_percent(self) -> float:
+        """Calculate percentage of elements covered."""
+        if not self.elements:
+            return 0.0
+        covered = sum(1 for e in self.elements.values() if e.covered)
+        return (covered / len(self.elements)) * 100
+
+    @property
+    def overall_coverage_percent(self) -> float:
+        """Calculate overall coverage percentage."""
+        total_items = len(self.elements) + 1  # +1 for penalty
+        if self.total_illustrations > 0:
+            total_items += self.total_illustrations
+
+        covered_items = sum(1 for e in self.elements.values() if e.covered)
+        if self.penalty_covered:
+            covered_items += 1
+        covered_items += len(self.illustrations_covered)
+
+        return (covered_items / total_items) * 100 if total_items > 0 else 0.0
+
+
+@dataclass
+class CoverageReport:
+    """Complete coverage report for a test run."""
+    statutes: Dict[str, StatuteCoverage] = field(default_factory=dict)
+    total_tests: int = 0
+    passed_tests: int = 0
+    failed_tests: int = 0
+
+    @property
+    def overall_coverage_percent(self) -> float:
+        """Calculate overall coverage across all statutes."""
+        if not self.statutes:
+            return 0.0
+        total = sum(s.overall_coverage_percent for s in self.statutes.values())
+        return total / len(self.statutes)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "summary": {
+                "total_statutes": len(self.statutes),
+                "overall_coverage": f"{self.overall_coverage_percent:.1f}%",
+                "total_tests": self.total_tests,
+                "passed_tests": self.passed_tests,
+                "failed_tests": self.failed_tests,
+            },
+            "statutes": {
+                section: {
+                    "title": cov.title,
+                    "element_coverage": f"{cov.element_coverage_percent:.1f}%",
+                    "overall_coverage": f"{cov.overall_coverage_percent:.1f}%",
+                    "elements": {
+                        name: {
+                            "type": elem.element_type,
+                            "covered": elem.covered,
+                            "test_count": elem.test_count,
+                        }
+                        for name, elem in cov.elements.items()
+                    },
+                    "penalty_covered": cov.penalty_covered,
+                    "illustrations_covered": len(cov.illustrations_covered),
+                    "total_illustrations": cov.total_illustrations,
+                }
+                for section, cov in self.statutes.items()
+            },
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        """Convert to JSON string."""
+        return json.dumps(self.to_dict(), indent=indent)
+
+
+class CoverageTracker:
+    """
+    Tracks test coverage for Yuho statute implementations.
+
+    Usage:
+        tracker = CoverageTracker()
+        tracker.load_statutes_from_ast(ast)
+        tracker.mark_element_covered("378", "actus_reus", "taking", "test_theft.yh")
+        report = tracker.generate_report()
+    """
+
+    def __init__(self):
+        self.report = CoverageReport()
+
+    def load_statutes_from_ast(self, ast) -> None:
+        """Load statute structure from AST for coverage tracking."""
+        for statute in ast.statutes:
+            section = statute.section_number
+            title = statute.title.value if statute.title else ""
+
+            cov = StatuteCoverage(section_number=section, title=title)
+
+            # Track elements
+            for element in (statute.elements or []):
+                elem_key = f"{element.element_type}:{element.name}"
+                cov.elements[elem_key] = ElementCoverage(
+                    element_type=element.element_type,
+                    name=element.name,
+                )
+
+            # Track illustrations
+            if hasattr(statute, 'illustrations') and statute.illustrations:
+                cov.total_illustrations = len(statute.illustrations)
+
+            self.report.statutes[section] = cov
+
+    def mark_element_covered(
+        self,
+        section: str,
+        element_type: str,
+        element_name: str,
+        test_file: str,
+    ) -> None:
+        """Mark an element as covered by a test."""
+        if section not in self.report.statutes:
+            return
+
+        elem_key = f"{element_type}:{element_name}"
+        cov = self.report.statutes[section]
+
+        if elem_key in cov.elements:
+            cov.elements[elem_key].covered = True
+            cov.elements[elem_key].test_count += 1
+            if test_file not in cov.elements[elem_key].test_files:
+                cov.elements[elem_key].test_files.append(test_file)
+
+    def mark_penalty_covered(self, section: str) -> None:
+        """Mark penalty section as covered."""
+        if section in self.report.statutes:
+            self.report.statutes[section].penalty_covered = True
+
+    def mark_illustration_covered(self, section: str, illustration_label: str) -> None:
+        """Mark an illustration as covered."""
+        if section in self.report.statutes:
+            self.report.statutes[section].illustrations_covered.add(illustration_label)
+
+    def add_test_result(self, passed: bool) -> None:
+        """Record a test result."""
+        self.report.total_tests += 1
+        if passed:
+            self.report.passed_tests += 1
+        else:
+            self.report.failed_tests += 1
+
+    def generate_report(self) -> CoverageReport:
+        """Generate the coverage report."""
+        return self.report
+
+    def print_summary(self) -> None:
+        """Print a human-readable coverage summary."""
+        print("\n" + "=" * 60)
+        print("STATUTE COVERAGE REPORT")
+        print("=" * 60)
+
+        for section, cov in self.report.statutes.items():
+            print(f"\n{section}: {cov.title}")
+            print(f"  Element coverage: {cov.element_coverage_percent:.1f}%")
+
+            for elem_key, elem in cov.elements.items():
+                status = "COVERED" if elem.covered else "NOT COVERED"
+                print(f"    [{status}] {elem.element_type}: {elem.name}")
+
+            penalty_status = "COVERED" if cov.penalty_covered else "NOT COVERED"
+            print(f"    [{penalty_status}] penalty")
+
+            if cov.total_illustrations > 0:
+                ill_cov = len(cov.illustrations_covered)
+                print(f"    Illustrations: {ill_cov}/{cov.total_illustrations}")
+
+        print("\n" + "-" * 60)
+        print(f"Overall coverage: {self.report.overall_coverage_percent:.1f}%")
+        print(f"Tests: {self.report.passed_tests}/{self.report.total_tests} passed")
+        print("=" * 60)
+
+
+def analyze_test_coverage(
+    statute_files: List[Path],
+    test_files: List[Path],
+) -> CoverageReport:
+    """
+    Analyze test coverage for a set of statute and test files.
+
+    Args:
+        statute_files: List of .yh statute files
+        test_files: List of test files
+
+    Returns:
+        CoverageReport with coverage analysis
+    """
+    from yuho.parser import Parser
+    from yuho.ast import ASTBuilder
+
+    tracker = CoverageTracker()
+    parser = Parser()
+
+    # Load statute structure
+    for statute_file in statute_files:
+        try:
+            result = parser.parse_file(statute_file)
+            if result.is_valid:
+                builder = ASTBuilder(result.source, str(statute_file))
+                ast = builder.build(result.root_node)
+                tracker.load_statutes_from_ast(ast)
+        except Exception:
+            continue
+
+    # Analyze test files for coverage
+    for test_file in test_files:
+        try:
+            result = parser.parse_file(test_file)
+            if result.is_valid:
+                builder = ASTBuilder(result.source, str(test_file))
+                ast = builder.build(result.root_node)
+
+                # Check what elements are referenced in tests
+                for statute in ast.statutes:
+                    section = statute.section_number
+
+                    # Mark elements as covered if they appear in test assertions
+                    for elem in (statute.elements or []):
+                        tracker.mark_element_covered(
+                            section,
+                            elem.element_type,
+                            elem.name,
+                            str(test_file),
+                        )
+
+                    if statute.penalty:
+                        tracker.mark_penalty_covered(section)
+
+                tracker.add_test_result(passed=True)
+            else:
+                tracker.add_test_result(passed=False)
+        except Exception:
+            tracker.add_test_result(passed=False)
+
+    return tracker.generate_report()

yuho/testing/fixtures.py

@@ -0,0 +1,263 @@
+"""
+Pytest fixtures for testing Yuho statute implementations.
+
+Provides ready-to-use fixtures for parsing, AST building, and validating
+Yuho code in user tests.
+
+Usage:
+    # In conftest.py
+    pytest_plugins = ["yuho.testing.fixtures"]
+
+    # In test files
+    def test_my_statute(yuho_parser, yuho_ast, parse_statute):
+        ast = parse_statute("statute 299 {...}")
+        assert len(ast.statutes) == 1
+"""
+
+from typing import Optional, List, Dict, Any, Callable
+from pathlib import Path
+from dataclasses import dataclass, field
+import pytest
+
+
+@pytest.fixture
+def yuho_parser():
+    """
+    Fixture providing a Yuho parser instance.
+
+    Usage:
+        def test_parse(yuho_parser):
+            result = yuho_parser.parse("statute 299 {...}")
+            assert result.is_valid
+    """
+    from yuho.parser import Parser
+    return Parser()
+
+
+@pytest.fixture
+def yuho_ast(yuho_parser):
+    """
+    Fixture providing an AST builder function.
+
+    Usage:
+        def test_ast(yuho_ast):
+            ast = yuho_ast("statute 299 {...}")
+            assert len(ast.statutes) == 1
+    """
+    from yuho.ast import ASTBuilder
+
+    def build_ast(source: str):
+        result = yuho_parser.parse(source)
+        if not result.is_valid:
+            raise ValueError(f"Parse error: {result.errors[0].message}")
+        builder = ASTBuilder(source)
+        return builder.build(result.root_node)
+
+    return build_ast
+
+
+@pytest.fixture
+def parse_statute(yuho_ast):
+    """
+    Fixture providing a function to parse statute code and return the first statute.
+
+    Usage:
+        def test_theft(parse_statute):
+            statute = parse_statute('''
+                statute 378 "Theft" {
+                    elements {
+                        actus_reus taking: "takes property"
+                    }
+                }
+            ''')
+            assert statute.section_number == "378"
+    """
+    def _parse(source: str):
+        ast = yuho_ast(source)
+        if not ast.statutes:
+            raise ValueError("No statute found in source")
+        return ast.statutes[0]
+
+    return _parse
+
+
+@pytest.fixture
+def parse_file(yuho_ast):
+    """
+    Fixture providing a function to parse a .yh file.
+
+    Usage:
+        def test_file(parse_file):
+            ast = parse_file("path/to/statute.yh")
+            assert len(ast.statutes) >= 1
+    """
+    def _parse_file(path: str):
+        file_path = Path(path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {path}")
+        source = file_path.read_text()
+        return yuho_ast(source)
+
+    return _parse_file
+
+
+@pytest.fixture
+def statute_validator():
+    """
+    Fixture providing a statute validator for checking statute completeness.
+
+    Usage:
+        def test_valid(statute_validator, parse_statute):
+            statute = parse_statute("...")
+            result = statute_validator(statute)
+            assert result.valid
+            assert not result.errors
+    """
+    @dataclass
+    class ValidationResult:
+        valid: bool
+        errors: List[str] = field(default_factory=list)
+        warnings: List[str] = field(default_factory=list)
+
+    def _validate(statute) -> ValidationResult:
+        errors = []
+        warnings = []
+
+        # Check required fields
+        if not statute.section_number:
+            errors.append("Missing section number")
+
+        if not statute.title:
+            warnings.append("Missing title")
+
+        if not statute.elements:
+            errors.append("No elements defined")
+        else:
+            # Check for at least one actus_reus
+            has_actus = any(
+                e.element_type == "actus_reus"
+                for e in statute.elements
+            )
+            if not has_actus:
+                warnings.append("No actus_reus element defined")
+
+            # Check for mens_rea
+            has_mens = any(
+                e.element_type == "mens_rea"
+                for e in statute.elements
+            )
+            if not has_mens:
+                warnings.append("No mens_rea element defined")
+
+        if not statute.penalty:
+            warnings.append("No penalty section defined")
+
+        return ValidationResult(
+            valid=len(errors) == 0,
+            errors=errors,
+            warnings=warnings,
+        )
+
+    return _validate
+
+
+@dataclass
+class StatuteTestCase:
+    """
+    Helper class for defining statute test cases.
+
+    Usage:
+        cases = [
+            StatuteTestCase(
+                name="theft_basic",
+                source='''statute 378 "Theft" {...}''',
+                expected_elements=["actus_reus:taking"],
+                expected_penalty_max=7,  # years
+            ),
+        ]
+
+        @pytest.mark.parametrize("case", cases, ids=lambda c: c.name)
+        def test_statute(case, parse_statute):
+            statute = parse_statute(case.source)
+            case.verify(statute)
+    """
+    name: str
+    source: str
+    expected_section: Optional[str] = None
+    expected_title: Optional[str] = None
+    expected_elements: List[str] = field(default_factory=list)
+    expected_penalty_max: Optional[int] = None  # years
+    expected_fine_max: Optional[float] = None
+
+    def verify(self, statute) -> None:
+        """Verify statute against expected values. Raises AssertionError on mismatch."""
+        if self.expected_section:
+            assert statute.section_number == self.expected_section, \
+                f"Section mismatch: expected {self.expected_section}, got {statute.section_number}"
+
+        if self.expected_title:
+            title = statute.title.value if statute.title else None
+            assert title == self.expected_title, \
+                f"Title mismatch: expected {self.expected_title}, got {title}"
+
+        if self.expected_elements:
+            actual_elements = [
+                f"{e.element_type}:{e.name}"
+                for e in (statute.elements or [])
+            ]
+            for expected in self.expected_elements:
+                assert expected in actual_elements, \
+                    f"Missing element: {expected}. Found: {actual_elements}"
+
+
+def element_check(statute, element_type: str, name: str) -> bool:
+    """
+    Check if a statute has a specific element.
+
+    Usage:
+        def test_has_actus_reus(parse_statute):
+            statute = parse_statute("...")
+            assert element_check(statute, "actus_reus", "taking")
+    """
+    if not statute.elements:
+        return False
+    return any(
+        e.element_type == element_type and e.name == name
+        for e in statute.elements
+    )
+
+
+def penalty_check(statute, penalty_type: str, max_value: Any = None) -> bool:
+    """
+    Check if a statute has a specific penalty type.
+
+    Usage:
+        def test_has_imprisonment(parse_statute):
+            statute = parse_statute("...")
+            assert penalty_check(statute, "imprisonment")
+    """
+    if not statute.penalty:
+        return False
+
+    # Check penalty structure
+    penalty = statute.penalty
+    if hasattr(penalty, penalty_type):
+        penalty_val = getattr(penalty, penalty_type)
+        if penalty_val is None:
+            return False
+        if max_value is not None and hasattr(penalty_val, 'max'):
+            return penalty_val.max is not None
+        return True
+
+    return False
+
+
+# Register as pytest plugin
+def pytest_configure(config):
+    """Register Yuho markers."""
+    config.addinivalue_line(
+        "markers", "statute(section): mark test as testing a specific statute section"
+    )
+    config.addinivalue_line(
+        "markers", "slow: mark test as slow running"
+    )

yuho/transpile/__init__.py

@@ -0,0 +1,52 @@
+"""
+Yuho transpilation module - multi-target code generation.
+
+Supports transpilation to:
+- JSON: Structured AST representation
+- JSON-LD: Linked data with legal ontology
+- English: Controlled natural language
+- LaTeX: Legal document formatting
+- Mermaid: Decision tree flowcharts
+- Alloy: Formal verification models
+"""
+
+from yuho.transpile.base import TranspileTarget, TranspilerBase
+from yuho.transpile.json_transpiler import JSONTranspiler
+from yuho.transpile.jsonld_transpiler import JSONLDTranspiler
+from yuho.transpile.english_transpiler import EnglishTranspiler
+from yuho.transpile.mermaid_transpiler import MermaidTranspiler
+from yuho.transpile.alloy_transpiler import AlloyTranspiler
+from yuho.transpile.latex_transpiler import LaTeXTranspiler, compile_to_pdf
+from yuho.transpile.registry import TranspilerRegistry
+
+__all__ = [
+    "TranspileTarget",
+    "TranspilerBase",
+    "TranspilerRegistry",
+    "JSONTranspiler",
+    "JSONLDTranspiler",
+    "EnglishTranspiler",
+    "LaTeXTranspiler",
+    "compile_to_pdf",
+    "MermaidTranspiler",
+    "AlloyTranspiler",
+    "get_transpiler",
+]
+
+
+def get_transpiler(target: TranspileTarget) -> TranspilerBase:
+    """
+    Get a transpiler instance for the given target.
+
+    This is a convenience function that uses the TranspilerRegistry singleton.
+
+    Args:
+        target: The transpilation target
+
+    Returns:
+        A transpiler instance for the target
+
+    Raises:
+        KeyError: If no transpiler is registered for the target
+    """
+    return TranspilerRegistry.instance().get(target)