Struct SimpleSource 

pub struct SimpleSource<'a> { /* private fields */ }

Simple source container that holds the filename and source text. Ariadne will automatically handle row/column calculations from byte offsets.

Usage Example

use bms_rs::bms::diagnostics::SimpleSource;

// Create source container
let source_text = "#TITLE test\n#ARTIST composer\n";
let source = SimpleSource::new("test.bms", source_text);

// Get source text
assert_eq!(source.text(), source_text);

Implementations

impl<'a> SimpleSource<'a>

pub const fn new(name: &'a str, text: &'a str) -> Self

Create a new source container instance.

Parameters

• name - Name of the source file
• text - Complete text content of the source file

Examples found in repository

examples/comprehensive_diagnostics.rs (line 23)

fn demonstrate_warning_types() {
    println!("1. Demonstrate ToAriadne implementation for all warning types:");

    let source_text = "#TITLE Demo\n#ARTIST Composer\n";
    let source = SimpleSource::new("demo.bms", source_text);

    // Create various types of warnings
    let warnings = vec![
        BmsWarning::PlayingWarning(PlayingWarning::TotalUndefined),
        BmsWarning::PlayingWarning(PlayingWarning::NoDisplayableNotes),
        BmsWarning::PlayingWarning(PlayingWarning::NoPlayableNotes),
    ];

    println!("   Created {} warnings", warnings.len());

    for (i, warning) in warnings.iter().enumerate() {
        println!("   Warning {}: {}", i + 1, warning);

        // Demonstrate ToAriadne trait usage
        let _report = warning.to_report(&source);
        println!("   -> Successfully converted to ariadne Report");
    }
}

fn demonstrate_integration() {
    println!("2. Complete integration workflow:");

    // Parse a BMS file that may produce warnings
    let bms_source = r#"#TITLE Integration Demo
#ARTIST Composer
#PLAYER 1
#GENRE Demo
#TOTAL 100

#00001:01000000
#00002:02000000
"#;

    println!("   Parsing BMS file...");
    let output = parse_bms::<KeyLayoutBeat>(bms_source);

    println!(
        "   Parsing completed, found {} warnings",
        output.warnings.len()
    );

    if !output.warnings.is_empty() {
        println!("   Using convenience function to output warnings:");
        emit_bms_warnings("integration_demo.bms", bms_source, &output.warnings);

        println!("\n   Handling each warning manually:");
        let source = SimpleSource::new("integration_demo.bms", bms_source);
        let ariadne_source = ariadne::Source::from(bms_source);

        for (i, warning) in output.warnings.iter().enumerate() {
            println!("   Warning {}: {}", i + 1, warning);

            // Manually convert to Report and print
            let report = warning.to_report(&source);
            let _ = report.print(("integration_demo.bms".to_string(), ariadne_source.clone()));
        }
    }

    println!("\n   Successfully demonstrated complete diagnostics integration workflow!");
}

examples/diagnostics_example.rs (line 37)

fn main() {
    // An example BMS file containing warnings
    let bms_source = r#"#TITLE Test Song
#ARTIST Test Composer
#INVALID_COMMAND this will cause a warning
#TOTAL 100

#00111:01010101
#00211:02020202
"#;

    println!("Parsing BMS file and displaying diagnostic information...\n");

    // Parse BMS file
    let output = parse_bms::<KeyLayoutBeat>(bms_source);

    // Display parsing results
    println!(
        "Parsing successful! Found {} warnings",
        output.warnings.len()
    );

    // Use diagnostics functionality to output beautiful diagnostic information
    if !output.warnings.is_empty() {
        println!("\n=== Diagnostic Information ===");
        emit_bms_warnings("example.bms", bms_source, &output.warnings);
    }

    // Can also handle each warning manually
    println!("\n=== Manual Warning Handling Example ===");
    let source = SimpleSource::new("example.bms", bms_source);
    let ariadne_source = ariadne::Source::from(bms_source);

    for warning in &output.warnings {
        let report = warning.to_report(&source);
        let _ = report.print(("example.bms".to_string(), ariadne_source.clone()));
    }

    println!("\nBMS parsing completed!");
}

pub const fn text(&self) -> &'a str

Get source text content.

Returns

Returns the complete text content of the source file