A simple configuration parsing utility with no dependencies built on Rust.
configparser works on a subset of ini configuration syntax (for now). It is inspired by Python's configparser.
The current release is experimental, this means that future releases will be swift until we reach stable (1.0.0).
The codebase is thus subject to change for now.
Most ini files look something like this (but they don't need to be .ini files obviously):
```yaml
[some-section]
key1 = value1
key2 = value2
[some-other-section]
key3 = value3
maybekey1aswell = value1
``
Owing to how ini files usually are, this means that[,]and=are special symbols (this crate will allow you to use]` sparingly).
Key-value pairs or section headers cannot spread across multiple lines for obvious reasons because the parser cannot reliably parse it otherwise. A value on the next line could as well be a key for another.
An important note is that key-value pairs not attached to any section are automatically put in a section called DEFAULT.
Future releases will add support for escaping, comments and modifying default section naming.
You can install this easily via cargo by including it in your Cargo.toml file like:
yaml
[dependencies]
configparser = "0.3.1"
You can load an ini-file easily and parse it like:
```rust
use configparser::ini::Ini;
use std::collections::HashMap;
fn main() { let mut config = Ini::new();
match config.load("Path/to/file...") { Err(why) => panic!("{}", why), Ok(_) => println!("Yay!") }
// You can then access the map normally like: let map = match config.getmap() { None => HashMap::new(), // or whatever you want to do if the map is empty Some(map) => map }; // or let map = config.getmap().unwrap() instead of match
for (key, value) in &map {
println!("{:?}: {:?}", key, value);
}
// And safely fetch a value:
let val = config.get("section name", "key name").unwrap();
}
``
TheIni` struct is the way to go forward and will soon have more features, such as reading from a string, insertion, deletion and variable access.
As of now, there's also a public function, to load an ini-syntax file and parse it into a hashmap. Support for this will be dropped in the near future, and will be changed into a macro when it's dropped. ```rust use configparser::ini;
fn main() { let map = ini::load("Path/to/file...");
// You can then access the map normally like: for (key, value) in &map { println!("{:?}: {:?}", key, value); } // ...and do what you want with it. :) } ```
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the LGPL-3.0 license, shall be dual licensed as above, without any additional terms or conditions.
configparser module renamed to ini.Ini struct is added along with file-loading, parsing and hashmap functions. Documentation is added.get() for getting values from the map directly. Docs expanded as well.ini::load() for deprecation.ini::load() will be dropped in the next major releaser per SemVer (i.e. 1.0.0)
Ini struct, such as reading from a string, insertion, deletion.