Function parse 

pub fn parse(input: &str) -> Result<Vdf<'_>>

Parse a VDF document from text format.

Example

use steam_vdf_parser::parse_text;

let input = r#""root"
{
    "key" "value"
}"#;
let vdf = parse_text(input).unwrap();
assert_eq!(vdf.key(), "root");

Examples found in repository

examples/test_parse_real.rs (line 11)

fn main() {
    // Test localconfig.vdf (text format)
    println!("=== Parsing localconfig.vdf (text format) ===");
    let localconfig = fs::read_to_string(
        "/home/mexus/.local/share/Steam/userdata/127648749/config/localconfig.vdf",
    );
    match localconfig {
        Ok(content) => match parse_text(&content) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }

    println!("\n=== Parsing appinfo.vdf (binary format) ===");
    let appinfo = fs::read("/home/mexus/.local/share/Steam/appcache/appinfo.vdf");
    match appinfo {
        Ok(data) => match parse_binary(&data) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }
}

examples/print.rs (line 28)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file>", args[0]);
        eprintln!();
        eprintln!("Pretty-prints a VDF file to stdout in valid VDF text format.");
        eprintln!("Supports both text (.vdf) and binary (appinfo.vdf, packageinfo.vdf, shortcuts.vdf) formats.");
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let data = std::fs::read(path).expect("Failed to read file");

    // Try to detect format and parse accordingly
    let result = if let Ok(text) = std::str::from_utf8(&data) {
        // Looks like text, try text parser first
        parse_text(text)
            .map(|v| v.into_owned())
            .or_else(|_| parse_binary(&data).map(|v| v.into_owned()))
    } else {
        // Binary data - detect format from filename
        let filename = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or_default();

        if filename.contains("packageinfo") {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if filename.contains("appinfo") {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            // Use the pretty-print Display implementation
            println!("{:#}", vdf);
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}

examples/dump_vdf.rs (line 61)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file> [--text]", args[0]);
        eprintln!(
            "  --text: force text format parsing (default: auto-detect based on file extension)"
        );
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let force_text = args.len() > 2 && args[2] == "--text";

    let result = if force_text || path.extension().is_some_and(|e| e == "vdf") {
        // Try text first for .vdf files
        let content = std::fs::read_to_string(path);
        if let Ok(content) = content {
            parse_text(&content).map(|v| v.into_owned())
        } else {
            // Fall back to binary
            let data = std::fs::read(path).expect("Failed to read file");
            if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
            {
                binary::parse_packageinfo(&data).map(|v| v.into_owned())
            } else if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
            {
                binary::parse_appinfo(&data).map(|v| v.into_owned())
            } else {
                parse_binary(&data).map(|v| v.into_owned())
            }
        }
    } else {
        // Binary parsing
        let data = std::fs::read(path).expect("Failed to read file");
        if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
        {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
        {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            println!("\"{}\" {}", vdf.key(), dump_value(vdf.value(), 0));
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}