Function print_parse_errors 

pub fn print_parse_errors(
    filename: &str,
    source: &str,
    errors: &[Rich<'_, char>],
)

Pretty-print parse errors using Ariadne

Examples found in repository

examples/usage.rs (line 48)

fn example_1() {
    println!("Example 1: Parsing a simple component\n");

    let input = r#"Text("Hello, World!")"#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Component name: {}", component.name);
            println!("✓ Arguments count: {}", component.arguments.arguments.len());

            if let Some(Argument::Positioned { value, .. }) =
                component.arguments.arguments.first()
            {
                println!("✓ First argument: {:?}", value);
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

fn example_2() {
    println!("Example 2: Extracting named and positional arguments\n");

    let input = r#"Button(text: "Click Me", enabled: true, color: blue)"#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Component: {}", component.name);

            // Get named argument
            if let Some(text) = component.arguments.get_named("text") {
                println!("✓ Text argument: {:?}", text);
            }

            // Get boolean argument
            if let Some(Value::Boolean(enabled)) = component.arguments.get_named("enabled") {
                println!("✓ Enabled: {}", enabled);
            }

            // Iterate all arguments
            println!("\nAll arguments:");
            for (i, arg) in component.arguments.arguments.iter().enumerate() {
                match arg {
                    Argument::Named { key, value } => {
                        println!("  [{}] {} = {:?}", i, key, value);
                    }
                    Argument::Positioned { position, value } => {
                        println!("  [{}] pos {} = {:?}", i, position, value);
                    }
                }
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

fn example_3() {
    println!("Example 3: Working with applicators (styling)\n");

    let input = r#"
        Text("Styled Text")
            .fontSize(18)
            .color(blue)
            .padding(16)
    "#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Component: {}", component.name);
            println!("✓ Applicators count: {}", component.applicators.len());

            println!("\nApplicators:");
            for applicator in &component.applicators {
                print!("  .{}(", applicator.name);
                for (i, arg) in applicator.arguments.arguments.iter().enumerate() {
                    if i > 0 {
                        print!(", ");
                    }
                    match arg {
                        Argument::Named { key, value } => print!("{}: {:?}", key, value),
                        Argument::Positioned { value, .. } => print!("{:?}", value),
                    }
                }
                println!(")");
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

fn example_4() {
    println!("Example 4: Navigating the component tree\n");

    let input = r#"
        Column {
            Text("Header")
                .fontSize(24)

            Row {
                Button("Left")
                Button("Right")
            }

            Text("Footer")
        }
    "#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Root component: {}", component.name);
            println!("✓ Children count: {}", component.children.len());

            // Walk the tree
            println!("\nComponent tree:");
            print_tree(&component, 0);

            // Flatten to list
            let all_components = component.flatten();
            println!("\nFlattened tree ({} total components):", all_components.len());
            for comp in &all_components {
                println!(
                    "  - {} (applicators: {})",
                    comp.name,
                    comp.applicators.len()
                );
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

fn print_tree(component: &hypen_parser::ComponentSpecification, depth: usize) {
    let indent = "  ".repeat(depth);
    print!("{}{}", indent, component.name);

    if !component.applicators.is_empty() {
        print!(" [");
        for (i, app) in component.applicators.iter().enumerate() {
            if i > 0 {
                print!(", ");
            }
            print!(".{}", app.name);
        }
        print!("]");
    }
    println!();

    for child in &component.children {
        print_tree(child, depth + 1);
    }
}

fn example_5() {
    println!("Example 5: Proper error handling\n");

    let inputs = vec![
        r#"Text("Valid input")"#,
        r#"Text("Missing closing paren"#,
        r#"Column { Text("Unclosed block"#,
    ];

    for (i, input) in inputs.iter().enumerate() {
        println!("Input {}: {}\n", i + 1, input);

        match parse_component(input) {
            Ok(component) => {
                println!("✓ Success: parsed component '{}'", component.name);
            }
            Err(errors) => {
                println!("✗ Parse error:");
                print_parse_errors(&format!("input-{}.hypen", i + 1), input, &errors);
            }
        }

        if i < inputs.len() - 1 {
            println!("\n{}\n", "-".repeat(60));
        }
    }
}

examples/pretty_errors.rs (line 10)

fn main() {
    println!("=== Hypen Parser Error Examples with Ariadne ===\n");

    // Example 1: Unclosed string
    println!("Example 1: Unclosed string\n");
    let input1 = r#"Text("Hello"#;
    if let Err(errors) = parse_component(input1) {
        print_parse_errors("example.hypen", input1, &errors);
    }

    println!("\n{}\n", "=".repeat(60));

    // Example 2: Unclosed parentheses
    println!("Example 2: Unclosed parentheses\n");
    let input2 = r#"Text("Hello""#;
    if let Err(errors) = parse_component(input2) {
        print_parse_errors("example.hypen", input2, &errors);
    }

    println!("\n{}\n", "=".repeat(60));

    // Example 3: Unclosed block
    println!("Example 3: Unclosed block\n");
    let input3 = r#"Column {
    Text("Hello")
    Row {
        Text("World")
"#;
    if let Err(errors) = parse_component(input3) {
        print_parse_errors("example.hypen", input3, &errors);
    }

    println!("\n{}\n", "=".repeat(60));

    // Example 4: Invalid syntax in arguments
    println!("Example 4: Invalid syntax in arguments\n");
    let input4 = r#"Text(key: , value: 123)"#;
    if let Err(errors) = parse_component(input4) {
        print_parse_errors("example.hypen", input4, &errors);
    }

    println!("\n{}\n", "=".repeat(60));

    // Example 5: Complex nested error
    println!("Example 5: Complex nested error\n");
    let input5 = r#"Column {
    Text("Header")
        .fontSize(18)
        .color(blue)

    Row {
        Button("Sign In")
            .padding(16
        Text("Footer")
    }
}
"#;
    if let Err(errors) = parse_component(input5) {
        print_parse_errors("example.hypen", input5, &errors);
    }

    println!("\n{}\n", "=".repeat(60));

    // Example 6: Show a successful parse
    println!("Example 6: Valid input (success)\n");
    let input6 = r#"Column {
    Text("Hello")
        .fontSize(18)
}"#;
    match parse_component(input6) {
        Ok(component) => println!("✓ Successfully parsed component: {}\n", component.name),
        Err(errors) => print_parse_errors("example.hypen", input6, &errors),
    }
}