So there is no need the escape the double quotes inside that string.

Quoting https://doc.rust-lang.org/reference/tokens.html#raw-string-literals Raw string literals do not process any escapes. They start with the character U+0072 (r), followed by zero or more of the character U+0023 (#) and a U+0022 (double-quote) character. The raw string body can contain any sequence of Unicode characters and is terminated only by another U+0022 (double-quote) character, followed by the same number of U+0023 (#) characters that preceded the opening U+0022 (double-quote) character.

clippy is a good linter. Ran it an it comes up with roughly 50 warnings. Should be marked as a beginner issue, as almost any of these lints are good to learn rust.

Summary: Help request a.k.a. missing an example

How to get content of a gura array of structures into an array of rust structures?

The rust structure would allow access to each field to the structure.

Say I have the this code:

use gura::{parse, GuraType};

fn main() {
    let gura_string = r##"
# This is a Gura document.

# Array of objects
tango_singers: [
    user1:
        name: "Carlos"
        surname: "Gardel"
        year_of_birth: 1890,
    user2:
        name: "Aníbal"
        surname: "Troilo"
        year_of_birth: 1914
]"##
    .to_string();

    // Parse: transforms a Gura string into a dictionary
    let parsed = parse(&gura_string).unwrap();

    // // Debug and Display
    // println!("{:#?}", parsed);
    // println!("{}", parsed);

    // Iterate over structure
    println!("\nTango singers:");
    if let GuraType::Array(tango_singers) = &parsed["tango_singers"] {
        for i in tango_singers.iter() {
            println!("tango singer -> {}", *i);
        }
    }
}

What should replace the

            println!("tango singer -> {}", *i);

so that content of i gets copied in a struct?

• This is mostly the result of cargo clippy --all --fix
• The exceptions are the transformations from s.push_str(&format!(...)) -> write!(s, ...), which clippy would not automate.

To avoid runtime errors with output like

thread 'main' panicked at 'IndexMap: key not found', src/main.rs:25:23

is some check on key present needed.

In case such functionality already exists, please where at https://docs.rs/gura/0.3.4/gura/ I should find it.

Hey, I really appreciate this project (the format itself and this implementation) :heart: and I plan to use it in one of my personal projects. However as of right now, this library is not as ergonomic as it could be which is why I am currently holding off on using it. Specifically, it lacks integration with serde.

With Serde support, one could write things like:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point { x: i32, y: i32 }

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = gura::to_string(&point).unwrap();
    let deserialized: Point = gura::from_str(&serialized).unwrap();
}

That is, without much boilerplate, one can (de-)serialize almost arbitrary structs and enums to/from Gura. The parsing and rendering in the user code gets hidden away by Serde.

Yet I have to mention that Serde is quite a big dependency. Thus it's advisable to make use of Rust's/Cargo's feature system and allow the user to either opt in or opt out of Serde (depending on your preference as the library author). For prior art, take a look at serde_json.

Serde is well known in the Rust community and for every major format there exists a crate with Serde support: JSON, XML, YAML, TOML, JSON5, BSON, RON, you name it.

If I had more time at hand, I would definitely implement this by myself and make a pull request but sadly I do not.

Thank you for your work!

• Also fixes a potential race condition when the file is deleted after the exists check passes.

Tested with examples/noaccess.rs:

// Basic Gura parser usage example
use gura::parse;

fn main() -> Result<(), String> {
    let gura_string = r##"
import "examples/noaccess.ura"
]"##;

    // Parse: transforms a Gura string into a dictionary
    let parsed = parse(gura_string).map_err(|e| e.to_string())?;

    println!("Parsed:\n{:?}", parsed);

    Ok(())
}

Create an unreadable file and try it:

$ touch examples/noaccess.ura
$ chmod -r examples/noaccess.ura
$ cargo run --example noaccess
   Compiling gura v0.5.0 (/Users/parasyte/other-projects/gura-rs-parser)
    Finished dev [unoptimized + debuginfo] target(s) in 1.62s
     Running `target/debug/examples/noaccess`
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 13, kind: PermissionDenied, message: "Permission denied" }', src/parser.rs:634:63
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

We can use a Cow to not allocate to a string when we have this case.

I know this pattern is common in other languages to check for something and then get it. However in rust if we are interested in the value we can just get it and match the returned Option. It removes double indexing in the map for the case.

qoute from lazy_static docs

Using this macro, it is possible to have statics that require code to be executed at runtime in order to be initialized. This includes anything requiring heap allocations, like vectors or hash maps, as well as anything that requires function calls to be computed.

Which is exactly whats happening here. Also cleaned up use statements.