sarif_rust 0.3.0

//! Basic usage demonstration of the SARIF Rust library
//!
//! This example shows the core functionality of creating, serializing, and parsing SARIF logs.

use sarif_rust::builder::*;
use sarif_rust::parser::*;
use sarif_rust::types::Level;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SARIF Rust Library - Basic Usage Demo");
    println!("=========================================\n");

    // 1. Create a simple SARIF log using the builder
    println!("1. Creating SARIF log with builder pattern");

    let sarif_log =
        SarifLogBuilder::single_warning("example-tool", "Unused variable found", "src/main.rs", 42)
            .build_unchecked();

    println!("✓ Created SARIF log with {} run(s)", sarif_log.runs.len());

    // 2. Create a more complex SARIF log
    println!("\n2. Creating complex SARIF log");

    let complex_log = SarifLogBuilder::new()
        .add_run(
            RunBuilder::with_tool("security-scanner", Some("1.0.0"))
                .add_result(
                    ResultBuilder::with_text_message("SQL injection vulnerability detected")
                        .with_rule_id("SQL001")
                        .with_level(Level::Error)
                        .add_file_location("src/database.rs", 150, 1)
                        .build(),
                )
                .add_result(
                    ResultBuilder::with_text_message("Consider using const instead of let")
                        .with_rule_id("STYLE001")
                        .with_level(Level::Note)
                        .add_file_location("src/utils.rs", 25, 1)
                        .build(),
                )
                .build(),
        )
        .build()?;

    println!(
        "✓ Created complex SARIF log with {} result(s)",
        complex_log.runs[0].results.as_ref().map_or(0, |r| r.len())
    );

    // 3. Serialize to JSON
    println!("\n3. Serializing to JSON");

    let json = sarif_rust::to_string_pretty(&complex_log)?;
    println!("✓ Serialized to JSON ({} bytes)", json.len());

    // Print a snippet of the JSON
    let preview = if json.len() > 200 {
        &json[..200]
    } else {
        &json
    };
    println!("JSON preview:\n{}", preview);
    if json.len() > 200 {
        println!("... [truncated]");
    }

    // 4. Parse the JSON back
    println!("\n4. Parsing JSON back to SARIF");

    let parsed_log = sarif_rust::from_str(&json)?;
    println!("✓ Successfully parsed SARIF log");
    println!("  - Version: {}", parsed_log.version);
    println!("  - Runs: {}", parsed_log.runs.len());

    // Print results from first run
    if let Some(results) = &parsed_log.runs[0].results {
        println!("  - Results in first run: {}", results.len());
        for (i, result) in results.iter().enumerate() {
            let message = result.message.text.as_deref().unwrap_or("No message");
            let level = result
                .level
                .as_ref()
                .map(|l| format!("{:?}", l))
                .unwrap_or("None".to_string());
            println!("    {}. [{}] {}", i + 1, level, message);
        }
    }

    // 5. Validation
    println!("\n5. Validating SARIF log");

    let validator = SarifValidator::new();
    match validator.validate_sarif_log(&parsed_log) {
        Ok(_) => println!("✓ SARIF log is valid"),
        Err(e) => println!("⚠ Validation warning: {}", e),
    }

    println!("\n✅ Demo completed successfully!");
    println!("\nThe SARIF Rust library provides:");
    println!("• Type-safe SARIF v2.1.0 support");
    println!("• Ergonomic builder patterns");
    println!("• Comprehensive validation");
    println!("• JSON serialization/deserialization");
    println!("• Advanced features like streaming, querying, and format conversion");

    Ok(())
}