How to write the config back to the config file?

[MTRNord]

Hi I use set_default() to set default values. How can I write these back to the config file?

[mehcode]

This is not a feature I'm looking at implementing in the near future but I'm definitely open to the idea. With the merging it'd require a bit of thinking on the implementation but it should be do-able.

[mehcode]

Looking back at this, I'm thinking we could implement something that would work for enough use cases to be useful.

I looked around and it seems there are two common use cases for serializing configuration:

• Generating a "default" configuration file.
• Reading a file, editing it, and saving those edits.

The first is significantly easier than the second. We could offer something like (to hopefully tighten up your code, here):

config.set_default("ip", "0.0.0.0");
config.set_default("db.ip", "127.0.0.1");
config.set_default("username", "root");
config.set_default("password", "");

// Write defaults to file if the file doesn't exist
if let Ok(mut f) = OpenOptions::new().write(true).create_new(true).open(&config_dir) {
    config.serialize_defaults_to(FileFormat::Json, f)?;
}

Would the above work for you @MTRNord ?

---

I could further envision a .serialize method that serializes the current configuration stack. It'd be quite useful for debugging the library too.

This is probably enough to solve the second use case for some people but it's really not good enough. I'd love to hear some thoughts on API design if someone is interested in exploring this space. Below is a rough spike on what could possibly work (if you wrap the child configurations in RwLock).

let mut default_config = Config::new();
default_config.merge(File::with_name("default.json"));

let mut user_config = Config::new();
user_config.merge(File::with_name("user.json"));

let mut config = Config::new();
config.merge(default_config); 
config.merge(user_config);

user_config.set("update", 2); // updates user config which updates the config
user_config.serialize( ... ); // serialize just user.json plus changes

Another issue with the second use case is preserving file format. The main issue here is format libraries just don't seem to be able to do this at this time.

[wbthomason]

It wouldn't entirely solve this, but adding #[derive(Serialize)] to config::Value would make it easier for users to roll their own solutions for writing default config back out to a file.

[eberkund]

Another question to consider is whether writing back would preserve formatting like indentation, line breaks and comments or whether it would just rewrite a new file with the given values

[psox]

Take a look at https://crates.io/crates/trope

[mehcode]

There are two main use cases at play:

• Write back changes to a loaded config file. Think Atom/VS Code. App loads from multiple sources and writes back only dynamic ( config.set ) changes to a single file.

• Write the entire config tree. Would be useful in trope and for debugging.

I'm planning on supporting both of these cases soon.

[kunicmarko20]

Lost 2 hours trying to figure this out and what am I doing wrong, maybe mention in the docs that this is not possible?

[mehcode]

Apologies for the time lost. What specific use case were you wanting to do?

[kunicmarko20]

No problem, now that I think about it, it sounded a bit rude, it's a great crate and I am using it, just expected since you can read from a file and update values you would be able to write to a file.

[GeorgeHahn]

I'm also interested in this. I currently have a single config object that is loaded from multiple files (user config and an application generated config - these are non-overlapping Json files). It would be really cool if the library had a way to track/define which config keys were loaded from each file and could save updates to the respective files.

That said, this would be trivial to refactor into separate config objects - and it probably makes sense to do so. In that use case, very simple save-all functionality would be sufficient.

[kunicmarko20]

A dirty and easy solution I wrote as a test:

use std::fs::File;
use std::path::Path;
use std::io::Write;
use std::fs::OpenOptions;
use config::*;

    pub fn save(&mut self) {
        let path = Path::new("Config.toml");

        if let Ok(mut file) = OpenOptions::new().write(true).open(path) {
            file.set_len(0).unwrap();
            for (key, value) in self.config.collect().unwrap() {
                file.write_all(
                    format!(
                        "{}=\"{}\"\n",
                        key,
                        value.into_str().unwrap()
                    ).as_bytes()
                ).unwrap();
            }
        }
    }

I created a wrapper struct around the config and added this method. I know this is a bad solution for a library, but in case someone comes searching for it.