Apprendre à encoder/décoder du TOML avec toml-rs

#[derive(Deserialize)]
// Le scope racine de votre fichier toml. Contiendra les tables
// s'il y en a.
struct Config {
    title: String,
    owner: Option<Owner>,
}

fn main() {
    let config: Config = toml::from_str(r#"
        title = 'TOML Example'
    "#).unwrap(); // Nous pouvons nous permettre de ne pas
    // déclarer la table `[owner]`, puisque désormais optionnelle.
    assert_eq!(config.title, "TOML Example");
    // Cette assertion est également modifiée.
    // `config.owner` étant wrappé dans un conteneur
    // nous pouvons tester si la table existe ou non.
    assert_eq!(config.owner, None);
}

let meat = {
    let mut file_path: path::PathBuf = path::PathBuf::new();
    // On admettra ici que votre fichier est à la racine du projet.
    file_path.push(env::current_dir().unwrap().as_path());
    file_path.push("my_file.toml");
    let mut configuration_file: fs::File = fs::OpenOptions::new()
        .read(true)
        .open(file_path.as_path())
        .expect("Cannot open the configuration file");

    // tip: Si vous souhaitez récupérer le contenu de votre fichier
    // sous forme d'octets, il suffit de remplacer la ligne 16 par celle-ci:
    // `let mut raw_content: Vec<u8>: vec![];`

    let mut stringified_content: String = String::new();

    // Vous devrez également modifier la méthode utilisée ici par:
    // `configuration_file.read_to_end(&mut raw_content)`
    match configuration_file.read_to_string(&mut stringified_content) {
        Ok(bytes) => println!("{} bytes has been appended to buffer.", bytes),
        Err(error) => panic!(
            "
            The data in this stream is not valid UTF-8.\n
            See error: '{}'
            ",
            error
        ),
    }
    stringified_content
};

// Remplacez ici `from_str` par `from_slice`
// et modifiez votre paramètre en conséquence.
let config_content: Config = toml::from_str(meat.as_str())
    .expect("Something went wrong");

#[macro_use]
extern crate toml;
#[macro_use]
extern crate serde_derive;

// Certains de ces imports sont à supprimer si
// vous n'effectuez aucune opération d'entrée/sortie.
use std::{convert, env, fs, io, io::prelude::*, path};

let meat = toml! {
    [owner]
    name = "Songbird"
    mail = "johndoe@johnedoe.com"
    [[team.members]]
    name = "Alice"
    job = "Tech leader"
    mail = "resp@abc.xyz"

    [[team.members]]
    name = "Bob"
    job = "Developer"

    [[team.members]]
    name = "John"
    job = "Community Manager"
};

fn read_toml_file<'a, 'de, P: ?Sized, T>(path: &'a P, buffer: &'de mut String) -> Result<T, Error>
where
    P: convert::AsRef<path::Path>,
    T: Deserialize<'de>,
{
    let mut configuration_file: fs::File = fs::OpenOptions::new()
        .read(true)
        .open(path)
        .expect("Cannot read the configuration file");
    match configuration_file.read_to_string(buffer) {
        Ok(bytes) => {
            println!("{} bytes has been appended to buffer.", bytes);
            toml::from_str(buffer.as_str())
        }
        Err(error) => panic!(
            "
                The data in this stream is not valid UTF-8.\n
                See error: '{}'
                ",
            error
        ),
    }
}

let mut file_path: path::PathBuf = path::PathBuf::new();

file_path.push(env::current_dir().unwrap().as_path());
file_path.push("my_file.toml");
let mut buffer = String::new();
let config_content: Config = read_toml_file(&file_path, &mut buffer)
    .expect("Something went wrong");
println!("Your config object: {:#?}", config_content);

246 bytes has been appended to buffer.
Your config object: Config {
    projects: [
        ProjectConfig {
            project_home: "my/home/",
            project_root: "my_directory",
            subroots: Some(
                [
                    SubrootConfig {
                        path: "my/path/file"
                    },
                    SubrootConfig {
                        path: "my/path/file"
                    }
                ]
            )
        },
        ProjectConfig {
            project_home: "another/home/",
            project_root: "another_directory",
            subroots: None
        }
    ]
}

fn create_toml_file<'a, P: ?Sized>(path: &'a P, content: String) -> io::Result<()>
where
    P: convert::AsRef<path::Path>,
{
    let mut toml_file: fs::File = fs::OpenOptions::new()
        .write(true)
        .create(true)
        .open(path)?;

    let bytes: &[u8] = &content.into_bytes();

    toml_file.write_all(bytes)
}

let meat: toml::Value = toml! {
    [owner]
    name = "Songbird"
    mail = "johndoe@johnedoe.com"
    [[team.members]]
    name = "Alice"
    job = "Tech leader"
    mail = "resp@abc.xyz"

    [[team.members]]
    name = "Bob"
    job = "Developer"

    [[team.members]]
    name = "John"
    job = "Community Manager"
};

let config_content: String = toml::to_string(&meat)
    .expect("Something went wrong");
let mut file_path: path::PathBuf = path::PathBuf::new();

file_path.push(env::current_dir().unwrap().as_path());
file_path.push("a_file.toml");

assert!(create_toml_file(&file_path, config_content).is_ok());