fraiseql-confiture 0.3.7__cp311-cp311-macosx_11_0_arm64.whl

confiture/__init__.py

@@ -0,0 +1,48 @@
+"""Confiture: PostgreSQL migrations, sweetly done 🍓
+
+Confiture is a modern PostgreSQL migration tool with a build-from-scratch
+philosophy and 4 migration strategies.
+
+Example:
+    >>> from confiture import __version__
+    >>> print(__version__)
+    0.3.7
+"""
+
+from typing import Any
+
+from confiture.core.linting import SchemaLinter
+
+__version__ = "0.3.7"
+__author__ = "Lionel Hamayon"
+__email__ = "lionel.hamayon@evolution-digitale.fr"
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__email__",
+    "SchemaLinter",
+]
+
+# Lazy imports to avoid errors during development
+# These will be enabled as components are implemented:
+# - SchemaBuilder (Milestone 1.3+)
+# - Migrator (Milestone 1.7+)
+# - Environment (Milestone 1.2+)
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy import for not-yet-implemented components"""
+    if name == "SchemaBuilder":
+        from confiture.core.builder import SchemaBuilder
+
+        return SchemaBuilder
+    elif name == "Migrator":
+        from confiture.core.migrator import Migrator
+
+        return Migrator
+    elif name == "Environment":
+        from confiture.config.environment import Environment
+
+        return Environment
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

confiture/cli/dry_run.py

@@ -0,0 +1,116 @@
+"""Dry-run mode helpers for CLI integration.
+
+This module provides helper functions for dry-run analysis integration with the CLI.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+def save_text_report(report_text: str, filepath: Path) -> None:
+    """Save text report to file.
+
+    Args:
+        report_text: Formatted text report
+        filepath: Path to save report to
+
+    Raises:
+        IOError: If file write fails
+    """
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text(report_text)
+
+
+def save_json_report(report_data: dict, filepath: Path) -> None:
+    """Save JSON report to file.
+
+    Args:
+        report_data: Report dictionary to save
+        filepath: Path to save report to
+
+    Raises:
+        IOError: If file write fails
+    """
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    with filepath.open("w") as f:
+        json.dump(report_data, f, indent=2)
+
+
+def print_json_report(report_data: dict) -> None:
+    """Print JSON report to console.
+
+    Args:
+        report_data: Report dictionary to print
+    """
+    console.print_json(data=report_data)
+
+
+def show_report_summary(report: Any) -> None:
+    """Show a brief summary of the report status.
+
+    Args:
+        report: Report object with has_unsafe_statements, unsafe_count,
+                total_estimated_time_ms, and total_estimated_disk_mb attributes
+    """
+    if not report.has_unsafe_statements:
+        console.print("[green]✓ SAFE[/green]", end=" ")
+    else:
+        unsafe_msg = f"[red]❌ UNSAFE ({report.unsafe_count} statements)[/red]"
+        console.print(unsafe_msg, end=" ")
+
+    time_str = report.total_estimated_time_ms
+    disk_str = report.total_estimated_disk_mb
+    console.print(f"| Time: {time_str}ms | Disk: {disk_str:.1f}MB")
+
+
+def ask_dry_run_execute_confirmation() -> bool:
+    """Ask user to confirm real execution after dry-run-execute test.
+
+    Returns:
+        True if user confirms, False otherwise
+    """
+    import typer
+
+    return typer.confirm("\n🔄 Proceed with real execution?", default=False)
+
+
+def extract_sql_statements_from_migration(migration_class) -> list[str]:
+    """Extract SQL statements from a migration's up() method.
+
+    This is a helper that attempts to extract SQL statements from migration
+    code by inspecting the migration object. This is limited and approximate
+    since migrations use self.execute() calls.
+
+    Args:
+        migration_class: Migration class (not instance)
+
+    Returns:
+        List of SQL statement strings (may be approximate/incomplete)
+    """
+    # This is a placeholder - in Day 2 implementation, we would:
+    # 1. Create a migration instance with a mock connection
+    # 2. Track calls to self.execute()
+    # 3. Extract the SQL statements
+    # For now, return empty list - actual implementation in Day 2
+    return []
+
+
+def display_dry_run_header(mode: str) -> None:
+    """Display header for dry-run analysis.
+
+    Args:
+        mode: Either "analysis" for --dry-run or "testing" for --dry-run-execute
+    """
+    if mode == "testing":
+        msg = "[cyan]🧪 Executing migrations in SAVEPOINT (guaranteed rollback)...[/cyan]"
+        console.print(msg + "\n")
+    else:
+        msg = "[cyan]🔍 Analyzing migrations without execution...[/cyan]"
+        console.print(msg + "\n")

confiture/cli/lint_formatter.py

@@ -0,0 +1,193 @@
+"""Output formatting for linting results.
+
+This module provides functions to format LintReport results in various
+output formats (table, JSON, CSV) for the lint CLI command.
+"""
+
+import json
+from pathlib import Path
+from typing import Literal
+
+from rich.console import Console
+from rich.table import Table
+
+from confiture.models.lint import LintReport, LintSeverity
+
+
+def format_lint_report(
+    report: LintReport,
+    format_type: Literal["table", "json", "csv"] = "table",
+    console: Console | None = None,
+) -> str:
+    """Format a LintReport in the specified format.
+
+    Args:
+        report: LintReport to format
+        format_type: Output format (table, json, or csv)
+        console: Rich Console instance for table rendering
+
+    Returns:
+        Formatted report as string
+    """
+    if format_type == "json":
+        return format_json(report)
+    elif format_type == "csv":
+        return format_csv(report)
+    else:  # table
+        if console is None:
+            console = Console()
+        format_table(report, console)
+        return ""
+
+
+def _severity_string(severity: LintSeverity) -> str:
+    """Format severity level with color.
+
+    Args:
+        severity: Severity level to format
+
+    Returns:
+        Colored severity string for Rich output
+    """
+    if severity == LintSeverity.ERROR:
+        return "[red]ERROR[/red]"
+    elif severity == LintSeverity.WARNING:
+        return "[yellow]WARNING[/yellow]"
+    return "[blue]INFO[/blue]"
+
+
+def format_table(report: LintReport, console: Console) -> None:
+    """Display LintReport as a rich table.
+
+    Args:
+        report: LintReport to display
+        console: Rich Console instance for rendering
+    """
+    # Summary section
+    console.print(f"\n[bold]Schema Linting Results[/bold] - {report.schema_name}")
+    console.print(f"Tables: {report.tables_checked} checked")
+    console.print(f"Columns: {report.columns_checked} checked")
+    console.print(f"Time: {report.execution_time_ms}ms\n")
+
+    if not report.violations:
+        console.print("[green]✅ No violations found![/green]\n")
+        return
+
+    # Violations table
+    table = Table(title="Violations")
+    table.add_column("Severity", style="bold")
+    table.add_column("Rule", style="cyan")
+    table.add_column("Location", style="yellow")
+    table.add_column("Message", style="white")
+
+    for violation in sorted(
+        report.violations,
+        key=lambda v: (
+            v.severity == LintSeverity.ERROR,
+            v.severity == LintSeverity.WARNING,
+        ),
+        reverse=True,
+    ):
+        table.add_row(
+            _severity_string(violation.severity),
+            violation.rule_name,
+            violation.location,
+            violation.message,
+        )
+
+    console.print(table)
+
+    # Summary counts
+    console.print("\n[bold]Summary:[/bold]")
+    console.print(f"  {report.errors_count} errors")
+    console.print(f"  {report.warnings_count} warnings")
+    console.print(f"  {report.info_count} info")
+
+    # Suggested fixes (if any)
+    fixes = [v for v in report.violations if v.suggested_fix]
+    if fixes:
+        console.print("\n[bold]Suggested Fixes:[/bold]")
+        for violation in fixes:
+            console.print(f"  {violation.location}: {violation.suggested_fix}")
+
+
+def format_json(report: LintReport) -> str:
+    """Format LintReport as JSON.
+
+    Args:
+        report: LintReport to format
+
+    Returns:
+        JSON string representation
+    """
+    data = {
+        "schema_name": report.schema_name,
+        "tables_checked": report.tables_checked,
+        "columns_checked": report.columns_checked,
+        "execution_time_ms": report.execution_time_ms,
+        "violations": {
+            "total": len(report.violations),
+            "errors": report.errors_count,
+            "warnings": report.warnings_count,
+            "info": report.info_count,
+            "items": [
+                {
+                    "rule": v.rule_name,
+                    "severity": v.severity.value,
+                    "location": v.location,
+                    "message": v.message,
+                    "suggested_fix": v.suggested_fix,
+                }
+                for v in report.violations
+            ],
+        },
+    }
+    return json.dumps(data, indent=2)
+
+
+def format_csv(report: LintReport) -> str:
+    """Format LintReport as CSV.
+
+    Args:
+        report: LintReport to format
+
+    Returns:
+        CSV string representation
+    """
+    lines = [
+        "rule_name,severity,location,message,suggested_fix",
+    ]
+
+    for violation in report.violations:
+        # Escape quotes in fields
+        rule = violation.rule_name.replace('"', '""')
+        severity = violation.severity.value
+        location = violation.location.replace('"', '""')
+        message = violation.message.replace('"', '""')
+        fix = (violation.suggested_fix or "").replace('"', '""')
+
+        # Quote fields that contain commas
+        rule = f'"{rule}"' if "," in rule else rule
+        location = f'"{location}"' if "," in location else location
+        message = f'"{message}"' if "," in message else message
+        fix = f'"{fix}"' if "," in fix else fix
+
+        lines.append(f"{rule},{severity},{location},{message},{fix}")
+
+    return "\n".join(lines)
+
+
+def save_report(
+    report: LintReport,
+    output_path: Path,
+    format_type: Literal["json", "csv"] = "json",
+) -> None:
+    """Save LintReport to a file.
+
+    Args:
+        report: LintReport to save
+        output_path: Path to save to
+        format_type: Output format (json or csv)
+    """
+    content = format_json(report) if format_type == "json" else format_csv(report)
+    output_path.write_text(content)