Function parse 

pub fn parse<R: Read>(reader: R) -> Result<ParseResult<Puzzle>, PuzError>

Parse a .puz file from any source that implements Read.

This is the core parsing function that provides full control over error handling and warnings. Use parse_file for a simpler API when parsing from files.

Arguments

• reader - Any type that implements Read, such as a File or &[u8]

Returns

Returns a Result<ParseResult<Puzzle>, PuzError> containing the parsed puzzle data along with any warnings, or an error if parsing fails.

Example

use std::fs::File;
use puz_parse::parse;

let file = File::open("puzzle.puz")?;
let result = parse(file)?;
let puzzle = result.result;
for warning in &result.warnings {
    eprintln!("Warning: {}", warning);
}

Examples found in repository

examples/read-with-file.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "examples/data/rebus.puz";
    let file = match File::open(path) {
        Err(err) => match err.kind() {
            ErrorKind::NotFound => panic!("File not found at path: {}", &path),
            other_error => panic!("Problem opening the file: {other_error:?}"),
        },
        Ok(file) => file,
    };

    let result = parse(file)?;
    let puzzle = result.result;

    // Print any warnings
    for warning in &result.warnings {
        println!("Warning: {warning}");
    }

    // Pretty print the puzzle info
    println!("Title: {}", puzzle.info.title);
    println!("Author: {}", puzzle.info.author);
    println!("Size: {}x{}", puzzle.info.width, puzzle.info.height);
    println!("Version: {}", puzzle.info.version);
    println!("Scrambled: {}", puzzle.info.is_scrambled);
    println!("Across clues: {}", puzzle.clues.across.len());
    println!("Down clues: {}", puzzle.clues.down.len());

    // Print some sample clues
    println!("\nSample across clues:");
    for (num, clue) in puzzle.clues.across.iter().take(3) {
        println!("  {num}: {clue}");
    }

    println!("\nSample down clues:");
    for (num, clue) in puzzle.clues.down.iter().take(3) {
        println!("  {num}: {clue}");
    }

    if let Some(rebus) = &puzzle.extensions.rebus {
        println!("\nRebus entries found: {}", rebus.table.len());
        for (key, value) in &rebus.table {
            println!("  {key}: {value}");
        }
    }

    println!("\nPuzzle parsed successfully!");

    Ok(())
}

examples/basic_usage.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example 1: Simple file parsing
    println!("=== Simple File Parsing ===");
    let puzzle = parse_file("examples/data/standard1.puz")?;
    println!("Title: {}", puzzle.info.title);
    println!("Author: {}", puzzle.info.author);
    println!("Size: {}x{}", puzzle.info.width, puzzle.info.height);
    println!();

    // Example 2: Parsing with error handling and warnings
    println!("=== Advanced Parsing with Warnings ===");
    let file = File::open("examples/data/rebus.puz")?;
    let result = parse(file)?;
    let puzzle = result.result;

    println!("Title: {}", puzzle.info.title);

    // Handle any warnings
    for warning in &result.warnings {
        println!("Warning: {warning}");
    }
    println!();

    // Example 3: Working with clues
    println!("=== Working with Clues ===");
    println!("Across clues:");
    for (num, clue) in puzzle.clues.across.iter().take(5) {
        println!("  {num}: {clue}");
    }

    println!("Down clues:");
    for (num, clue) in puzzle.clues.down.iter().take(5) {
        println!("  {num}: {clue}");
    }
    println!();

    // Example 4: Working with the grid
    println!("=== Working with the Grid ===");
    println!("First few rows of solution:");
    for (i, row) in puzzle.grid.solution.iter().take(3).enumerate() {
        println!("  Row {}: {}", i + 1, row);
    }

    println!("First few rows of blank grid:");
    for (i, row) in puzzle.grid.blank.iter().take(3).enumerate() {
        println!("  Row {}: {}", i + 1, row);
    }
    println!();

    // Example 5: Working with extensions (rebus, circles, etc.)
    println!("=== Working with Extensions ===");
    if let Some(rebus) = &puzzle.extensions.rebus {
        println!("Rebus found! Entries:");
        for (key, value) in &rebus.table {
            println!("  {key}: {value}");
        }
    } else {
        println!("No rebus in this puzzle");
    }

    if let Some(_circles) = &puzzle.extensions.circles {
        println!("This puzzle has circled squares");
    } else {
        println!("No circled squares in this puzzle");
    }

    if let Some(_given) = &puzzle.extensions.given {
        println!("This puzzle has given squares");
    } else {
        println!("No given squares in this puzzle");
    }
    println!();

    // Example 6: Parsing from bytes
    println!("=== Parsing from Bytes ===");
    let data = std::fs::read("examples/data/standard1.puz")?;
    let puzzle_from_bytes = parse_bytes(&data)?;
    println!("Parsed from bytes: {}", puzzle_from_bytes.info.title);

    Ok(())
}