Every time I make a mistake in my gura file, I get an error and I need to figure out where this damn error is located. Having a line information would be a massive quality of life improvement!

So far I've only met one instance of error coming with the line number

Err: Input text does not have a valid Gura format. Parsing failed with error "Expected end of string but got 'a' at line 65 position 1800", in file Some("my_file_path.ura")

But all other errors have been a hide and seek game between me and my configuration file.

Hashmaps seem to be incorrectly serialized (or at least I guess it must be a serialization issue, because the resulting string cannot be parsed back by the Gura parser).

use std::collections::HashMap;

use serde::{Deserialize, Serialize};
use serde_gura::Result;
use gura::parse;

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

fn main() -> Result<()> {

    let database = Database {
        ip: "127.0.0.1".to_string(),
        port: vec![80, 8080],
        connection_max: 1200,
        enabled: true,
    };

    let mut map = HashMap::new();
    map.insert("k", database);

    let sss_str = serde_gura::to_string(&map)?;
    
    println!("{}", sss_str);
    serde_gura::from_str(&sss_str)?;
}

output:

"k":
    ip: "127.0.0.1"
    port: [80, 8080]
    connection_max: 1200
    enabled: true
Error: Syntax("Expected end of string but got '\"' at line 0 position 0")

If I understand the Gura format correctly, the serialized version should be:

k: # no «"» around the key name
    ip: "127.0.0.1"
    port: [80, 8080]
    connection_max: 1200
    enabled: true

And this does parse correctly:

use std::collections::HashMap;

use serde::{Deserialize, Serialize};
use serde_gura::Result;
use gura::parse;

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

fn main() -> Result<()> {

    let database_str = r##"
k:
    ip: "127.0.0.1"
    port: [80, 8080]
    connection_max: 1200
    enabled: true

    "##;

    // Deserialize it back to a Rust type
    let deserialized_database: HashMap<String, Database> = serde_gura::from_str(&database_str)?;
    
    println!("{}", deserialized_database.get("k").unwrap().ip);

    Ok(())
}

Serde allows different enum representations: Internally tagged, Adjacently tagged and Untagged in addition to the default Externally tagged representation see Enum representations in Serde's doc.

Serde gura properly support seralization of such enum representation, but fails to perform deserialization of such representation.

Example:

Internally tagged

use serde::{Deserialize, Serialize};
use serde_gura::Result;

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[serde(rename_all = "lowercase",tag = "type")]
enum MyEnum{
    Database(Database)
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

fn main() -> Result<()> {


    // You have some type.
    let database = MyEnum::Database(Database {
        ip: "127.0.0.1".to_string(),
        port: vec![80, 8080],
        connection_max: 1200,
        enabled: true,
    });

    let sss_str = serde_gura::to_string(&database)?;
    
    println!("{}", &sss_str);
 

    // Deserialize it back to a Rust type
    let deserialized_database: MyEnum = serde_gura::from_str(&sss_str)?;
    
    println!("{:#?}", deserialized_database);

    Ok(())
}

type: "database"
ip: "127.0.0.1"
port: [80, 8080]
connection_max: 1200
enabled: true
Error: ExpectedIdentifier

Untagged

use serde::{Deserialize, Serialize};
use serde_gura::Result;

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[serde(rename_all = "lowercase",untagged)]
enum MyEnum{
    Database(Database)
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

fn main() -> Result<()> {


    // You have some type.
    let database = MyEnum::Database(Database {
        ip: "127.0.0.1".to_string(),
        port: vec![80, 8080],
        connection_max: 1200,
        enabled: true,
    });

    let sss_str = serde_gura::to_string(&database)?;
    
    println!("{}", &sss_str);
 

    // Deserialize it back to a Rust type
    let deserialized_database: MyEnum = serde_gura::from_str(&sss_str)?;
    
    println!("{:#?}", deserialized_database);

    Ok(())
}

output

ip: "127.0.0.1"
port: [80, 8080]
connection_max: 1200
enabled: true
Error: InvalidType

Adjacently tagged

use serde::{Deserialize, Serialize};
use serde_gura::Result;

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[serde(rename_all = "lowercase",tag = "t", content = "c")]
enum MyEnum{
    Database(Database)
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

fn main() -> Result<()> {


    // You have some type.
    let database = MyEnum::Database(Database {
        ip: "127.0.0.1".to_string(),
        port: vec![80, 8080],
        connection_max: 1200,
        enabled: true,
    });

    let sss_str = serde_gura::to_string(&database)?;
    
    println!("{}", &sss_str);
 

    // Deserialize it back to a Rust type
    let deserialized_database: MyEnum = serde_gura::from_str(&sss_str)?;
    
    println!("{:#?}", deserialized_database);

    Ok(())
}

output

t: "database"
c:
    ip: "127.0.0.1"
    port: [80, 8080]
    connection_max: 1200
    enabled: true
Error: ExpectedIdentifier