Oak YAML Parser

High-performance incremental YAML parser for the oak ecosystem with flexible configuration, optimized for data serialization and configuration file processing.

🎯 Overview

Oak of yaml is a robust parser for YAML, designed to handle complete YAML syntax including modern features. Built on the solid foundation of oak-core, it provides both high-level convenience and detailed AST generation for data serialization and configuration processing.

✨ Features

• Complete YAML Syntax: Supports all YAML features including modern specifications
• Full AST Generation: Generates comprehensive Abstract Syntax Trees
• Lexer Support: Built-in tokenization with proper span information
• Error Recovery: Graceful handling of syntax errors with detailed diagnostics

🚀 Quick Start

Basic example:

use oak_yaml::YamlParser;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let parser = YamlParser::new();
    let yaml_content = r#"
server:
  host: localhost
  port: 8080
  
database:
  url: postgresql://localhost/mydb
  pool_size: 10
    "#;
    
    let document = parser.parse_document(yaml_content)?;
    println!("Parsed YAML document successfully.");
    Ok(())
}

📋 Parsing Examples

Document Parsing

use oak_yaml::{YamlParser, ast::Document};

let parser = YamlParser::new();
let yaml_content = r#"
name: John Doe
age: 30
hobbies:
  - reading
  - hiking
  - coding
"#;

let document = parser.parse_document(yaml_content)?;
println!("Person name: {:?}", document.get_value("name"));

Mapping Parsing

use oak_yaml::{YamlParser, ast::Mapping};

let parser = YamlParser::new();
let mapping_content = r#"
config:
  debug: true
  timeout: 30
  retries: 3
"#;

let mapping = parser.parse_mapping(mapping_content)?;
println!("Debug mode: {:?}", mapping.get_value("debug"));

🔧 Advanced Features

Token-Level Parsing

use oak_yaml::{YamlParser, lexer::Token};

let parser = YamlParser::new();
let tokens = parser.tokenize("key: value\nlist:\n  - item1\n  - item2")?;
for token in tokens {
    println!("{:?}", token.kind);
}

Error Handling

use oak_yaml::YamlParser;

let parser = YamlParser::new();
let invalid_yaml = r#"
config:
  key: value
    nested: invalid_indentation
"#;

match parser.parse_document(invalid_yaml) {
    Ok(document) => println!("Parsed YAML document successfully."),
    Err(e) => {
        println!("Parse error at line {} column {}: {}", 
            e.line(), e.column(), e.message());
        if let Some(context) = e.context() {
            println!("Error context: {}", context);
        }
    }
}

🏗️ AST Structure

The parser generates a comprehensive AST with the following main structures:

• Document: Root container for YAML documents
• Mapping: YAML key-value mappings
• Sequence: YAML arrays/sequences
• Scalar: YAML scalar values (string, number, boolean, null)
• Anchor: YAML anchor references
• Alias: YAML alias references

📊 Performance

• Streaming: Parse large YAML files without loading entirely into memory
• Incremental: Re-parse only changed sections
• Memory Efficient: Smart AST node allocation
• Fast Recovery: Quick error recovery for better IDE integration

🔗 Integration

Oak of yaml integrates seamlessly with:

• Configuration Management: Parse and validate application configurations
• Data Serialization: Serialize and deserialize YAML data
• API Processing: Handle YAML API requests and responses
• IDE Support: Language server protocol compatibility
• DevOps Tools: Configuration validation and processing

📚 Examples

Check out the examples directory for comprehensive examples:

• Complete YAML document parsing
• Configuration file analysis
• Data extraction and transformation
• Integration with development workflows

🤝 Contributing

Contributions are welcome!

Please feel free to submit pull requests at the project repository or open issues.