uRustIniParser

IniParserEx is a lightweight and robust INI file parser for Rust. It supports:

• Section-based key/value parsing
• Variable substitution like ${Section:key}
• Environment-variable substitution ${ENV:VAR} with optional fallback ${ENV:VAR:-default}
• Recursive value resolution
• Typed getters: get_string, get_bool, get_int, get_float
• Retrieving whole sections with all values resolved
• Graceful handling of missing keys, sections, or circular references

Perfect for configuration files and projects that require flexible INI parsing.

Features

• Load INI files from disk into memory
• Retrieve values with optional default values
• Nested variable substitution across sections
• Environment-variable support with fallback
• Check if sections exist
• Retrieve resolved sections as HashMap<String, String>
• Typed getters for strings, booleans, integers, and floats
• Ignores comments (; or #) and empty lines
• Circular reference detection

Installation

Add this to your Cargo.toml:

[dependencies]
uiniparser = "0.1.0"

Then include it in your project:

use uiniparser::IniParserEx;

Usage

use uiniparser::IniParserEx;

fn main() {
    let mut parser = IniParserEx::default();

    if parser.load("config.ini").is_ok() {
        // String with automatic fallback
        let path = parser.get_string("Common", "path", 5).unwrap_or("/default/path".to_string());
        println!("Common.path = {}", path);

        // Boolean
        let enabled = parser.get_bool("Common", "enabled", 5).unwrap_or(false);
        println!("Common.enabled = {}", enabled);

        // Integer
        let port = parser.get_int("Common", "port", 5).unwrap_or(8080);
        println!("Common.port = {}", port);

        // Float
        let factor = parser.get_float("Common", "factor", 5).unwrap_or(1.0);
        println!("Common.factor = {}", factor);

        // Fully resolved section
        if let Ok(section) = parser.get_resolved_section("Common", 5) {
            println!("Resolved Common section:");
            for (k, v) in section {
                println!("  {} = {}", k, v);
            }
        }
    } else {
        println!("Failed to load INI file.");
    }
}

Example INI File

#--------------------------------
# Common settings
#--------------------------------

[COMMON]
FAULT_TOLERANT = FALSE
UART_PORT = COM1
PORT = 1234
ENABLED = true
FACTOR = 1.234

#--------------------------------
# Plugin settings
#--------------------------------

[UTILS]
FAULT_TOLERANT = ${COMMON:FAULT_TOLERANT}
PRIVILEGED = FALSE
UART_PORT = ${COMMON:UART_PORT}

[MATH]
FAULT_TOLERANT = ${COMMON:FAULT_TOLERANT}
PRIVILEGED = TRUE
UART_PORT = ${COMMON:UART_PORT}

[ENV_TEST]
HOST = ${ENV:TEST_HOST:-localhost}
HOME_DIR = ${ENV:HOME}

Features in Action

Variable substitution

let uart = parser.get_string("UTILS", "UART_PORT", 5).unwrap();
// "COM1"

let priv_math = parser.get_bool("MATH", "PRIVILEGED", 5).unwrap();
// true

Environment variable resolution

std::env::set_var("TEST_HOST", "myhost.local");
let host = parser.get_string("ENV_TEST", "HOST", 5).unwrap();
// "myhost.local"

let fallback_host = parser.get_string("ENV_TEST", "NON_EXISTENT", 5)
    .unwrap_or("default_host".to_string());
// "default_host"

Typed getters

let port = parser.get_int("COMMON", "PORT", 5).unwrap();
// 1234

let factor = parser.get_float("COMMON", "FACTOR", 5).unwrap();
// 1.234

let enabled = parser.get_bool("COMMON", "ENABLED", 5).unwrap();
// true

Tests

This crate includes unit tests covering:

• Loading INI files

• Section/key parsing

• Variable substitution and recursive resolution

• Environment-variable resolution with fallback

• Typed getters (get_string, get_bool, get_int, get_float)

• Circular reference detection

• Missing keys or sections

Run tests with:

cargo test

CLI Binary Example

use std::env;
use std::process;
use uiniparser::IniParserEx;

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() != 2 {
        eprintln!("Usage: parse_ini <path-to-ini-file>");
        process::exit(1);
    }

    let filename = &args[1];
    let mut parser = IniParserEx::default();

    if let Err(e) = parser.load(filename) {
        eprintln!("Failed to load INI file {}: {:?}", filename, e);
        process::exit(1);
    }

    println!("Loaded INI file: {}\n", filename);

    println!("=== RESOLVED SECTIONS ===");
    for (section, _) in parser.ini_data.iter() {
        println!("[{}]", section);
        if let Ok(resolved) = parser.get_resolved_section(section, 10) {
            for (key, val) in resolved {
                println!("  {} = {}", key, val);
            }
        }
        println!();
    }

    // Example direct lookups
    let uart_port = parser.get_string("UTILS", "UART_PORT", 10).unwrap_or("<missing>".to_string());
    println!("UTILS.UART_PORT = {}", uart_port);

    let priv_math = parser.get_bool("MATH", "PRIVILEGED", 10).unwrap_or(false);
    println!("MATH.PRIVILEGED = {}", priv_math);

    let port = parser.get_int("COMMON", "PORT", 10).unwrap_or(8080);
    println!("COMMON.PORT = {}", port);

    let factor = parser.get_float("COMMON", "FACTOR", 10).unwrap_or(1.0);
    println!("COMMON.FACTOR = {}", factor);

    let host = parser.get_string("ENV_TEST", "HOST", 10).unwrap_or("<missing>".to_string());
    println!("ENV_TEST.HOST = {}", host);

    let home = parser.get_string("ENV_TEST", "HOME_DIR", 10).unwrap_or("<missing>".to_string());
    println!("ENV_TEST.HOME_DIR = {}", home);
}

Run it with:

cargo run --example parseini ./data/testcfg.ini