Struct SuperConfig 

pub struct SuperConfig { /* private fields */ }

SuperConfig is a universal configuration management platform that combines advanced features with 100% Figment compatibility.

Built on Figment’s solid foundation, SuperConfig adds production-ready capabilities including hierarchical configuration cascades, advanced array merging, intelligent format detection, verbosity debugging, and performance optimizations - while maintaining seamless compatibility with existing Figment code.

Core Features

• Hierarchical Configuration: Git-like config inheritance across system → user → project levels
• Advanced Array Merging: Compose configurations with _add/_remove patterns
• Intelligent Format Detection: Content-based parsing with caching and fallback strategies
• Verbosity System: CLI-style debugging with -v, -vv, -vvv levels for troubleshooting
• Performance Optimized: Lazy loading, caching, and optimized data structures

Quick Start Example

use superconfig::{SuperConfig, VerbosityLevel};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Default)]
struct AppConfig {
    database_url: String,
    log_level: String,
    port: u16,
}

// Basic configuration loading
let config: AppConfig = SuperConfig::new()
    .with_defaults(AppConfig::default())
    .with_file("config.toml")
    .with_env("APP_")
    .extract()?;

Verbosity for Debugging

Enable verbosity to debug configuration loading issues:

use superconfig::{SuperConfig, VerbosityLevel};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Default)]
struct Config {
    host: String,
    port: u16,
}

// Enable debug verbosity (equivalent to -vv in CLI)
let config: Config = SuperConfig::new()
    .with_verbosity(VerbosityLevel::Debug)  // Shows detailed loading steps
    .with_hierarchical_config("myapp")
    .with_env("APP_")
    .extract()?;

CLI Integration Example

Integrate verbosity with CLI argument parsing:

use superconfig::{SuperConfig, VerbosityLevel};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Default)]
struct Config {
    host: String,
    port: u16,
}

// Parse CLI verbosity (normally from clap, structopt, etc.)
fn parse_verbosity() -> u8 {
    std::env::args()
        .skip(1)
        .filter(|arg| arg.starts_with("-v"))
        .map(|arg| arg.matches('v').count() as u8)
        .max()
        .unwrap_or(0)
}

let verbosity = VerbosityLevel::from_cli_args(parse_verbosity());

let config: Config = SuperConfig::new()
    .with_verbosity(verbosity)  // Respects -v, -vv, -vvv from command line
    .with_defaults(Config::default())
    .with_hierarchical_config("myapp")
    .with_env("APP_")
    .extract()?;

Advanced Features

Array Merging

// config/base.toml
// features = ["auth", "logging"]

// config/production.toml
// features_add = ["metrics", "tracing"]
// features_remove = ["logging"]

// Result: features = ["auth", "metrics", "tracing"]
let config = SuperConfig::new()
    .with_file("config/base.toml")
    .with_file("config/production.toml");

Debug Message Collection

use superconfig::{SuperConfig, VerbosityLevel};

let config = SuperConfig::new()
    .with_verbosity(VerbosityLevel::Debug)
    .with_file("config.toml");

// Access debug messages programmatically
let debug_messages = config.debug_messages();
for msg in debug_messages {
    println!("{}: {}", msg.provider, msg.message);
}

Universal Platform Vision

SuperConfig is designed to become the universal configuration standard across popular languages through WebAssembly bindings, REST APIs, and protocol standardization.

Implementations

impl SuperConfig

pub fn as_json(&self) -> Result<String, Error>

Export configuration as pretty-formatted JSON string

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String }

let config = SuperConfig::new()
    .with_defaults(Config { name: "test".to_string() });
     
let json_str = config.as_json()?;
println!("{}", json_str); // Pretty-printed JSON

pub fn as_yaml(&self) -> Result<String, Error>

Export configuration as YAML string

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String }

let config = SuperConfig::new()
    .with_defaults(Config { name: "test".to_string() });
     
let yaml_str = config.as_yaml()?;
println!("{}", yaml_str);

pub fn as_toml(&self) -> Result<String, Error>

Export configuration as TOML string

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String }

let config = SuperConfig::new()
    .with_defaults(Config { name: "test".to_string() });
     
let toml_str = config.as_toml()?;
println!("{}", toml_str);

pub fn get_string<K: AsRef<str>>(&self, key: K) -> Result<String, Error>

Get a string value from configuration

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { database: Database }

#[derive(Serialize)]
struct Database { host: String }

let config = SuperConfig::new()
    .with_defaults(Config {
        database: Database { host: "localhost".to_string() }
    });
     
let host = config.get_string("database.host")?;
println!("Database host: {}", host);

pub fn get_array<T>(&self, key: &str) -> Result<Vec<T>, Error>

where T: DeserializeOwned,

Get an array value from configuration

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { cors: Cors }

#[derive(Serialize)]
struct Cors { allowed_origins: Vec<String> }

let config = SuperConfig::new()
    .with_defaults(Config {
        cors: Cors { allowed_origins: vec!["https://example.com".to_string()] }
    });
     
let origins = config.get_array::<String>("cors.allowed_origins")?;
println!("CORS origins: {:?}", origins);

pub fn has_key(&self, key: &str) -> Result<bool, Error>

Check if a configuration key exists

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { redis: Redis }

#[derive(Serialize)]
struct Redis { enabled: bool }

let config = SuperConfig::new()
    .with_defaults(Config {
        redis: Redis { enabled: true }
    });
     
if config.has_key("redis.enabled")? {
    println!("Redis is configured");
}

pub fn keys(&self) -> Result<Vec<String>, Error>

Get all top-level configuration keys

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { database: String, redis: String }

let config = SuperConfig::new()
    .with_defaults(Config {
        database: "postgres://localhost".to_string(),
        redis: "redis://localhost".to_string()
    });
     
let keys = config.keys()?;
println!("Config sections: {:?}", keys);

pub fn debug_config(&self) -> Result<String, Error>

Debug configuration with pretty-printed values and source information

Returns a formatted string showing the final configuration values along with metadata about which providers contributed each value.

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String }

let config = SuperConfig::new()
    .with_defaults(Config { name: "test".to_string() });
     
println!("{}", config.debug_config()?);
// Output shows merged config with provider information

pub fn debug_sources(&self) -> Vec<Metadata>

Get debug information about configuration sources

Returns metadata about the providers that contributed to the configuration.

Examples

use superconfig::SuperConfig;
use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String }

let config = SuperConfig::new()
    .with_defaults(Config { name: "test".to_string() });
     
let sources = config.debug_sources();
println!("Configuration sources: {:#?}", sources);

impl SuperConfig

pub fn with_verbosity(self, level: VerbosityLevel) -> Self

Set the verbosity level for configuration debugging

Controls the amount of debug information displayed during configuration loading. Higher levels include all information from lower levels.

Examples

use superconfig::{SuperConfig, VerbosityLevel};

let config = SuperConfig::new()
    .with_verbosity(VerbosityLevel::Debug)  // -vv level debugging
    .with_file("config.toml");

pub fn with_info_verbosity(self) -> Self

Enable basic configuration loading progress (equivalent to -v)

Shows which providers are being loaded and final success/failure.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_info_verbosity()  // -v level
    .with_file("config.toml");

pub fn with_debug_verbosity(self) -> Self

Enable detailed step-by-step information (equivalent to -vv)

Shows file discovery, individual provider results, and merge operations.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_debug_verbosity()  // -vv level
    .with_hierarchical_config("myapp");

pub fn with_trace_verbosity(self) -> Self

Enable full introspection with configuration values (equivalent to -vvv)

Shows actual configuration values at each step and final merged result.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_trace_verbosity()  // -vvv level
    .with_env("APP_");

pub fn with_file<P: AsRef<Path>>(self, path: P) -> Self

Add a configuration file with smart format detection

Uses the Universal provider for automatic format detection and caching. Supports .toml, .yaml/.yml, .json files with fallback chains.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_file("config")        // Auto-detects config.toml, config.yaml, etc.
    .with_file("app.json");     // Explicit JSON file

pub fn with_env<S: AsRef<str>>(self, prefix: S) -> Self

Add environment variables with a prefix

Uses the Nested provider for JSON parsing and automatic nesting. Supports complex structures like arrays and objects in environment variables.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_env("APP_")           // APP_DATABASE_HOST, APP_FEATURES, etc.
    .with_env("MYAPP_");        // Multiple prefixes supported

pub fn with_hierarchical_config<S: AsRef<str>>(self, base_name: S) -> Self

Add hierarchical configuration cascade

Uses the Wildcard provider for Git-like config inheritance: system → user → project levels with automatic discovery.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_hierarchical_config("myapp");  // Loads system, user, project configs

pub fn with_defaults<T: Serialize>(self, defaults: T) -> Self

Add default configuration values from a serializable struct

Uses Figment’s Serialized provider to set defaults that can be overridden by other configuration sources.

Examples

use superconfig::SuperConfig;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Default)]
struct Config {
    host: String,
    port: u16,
}

let config = SuperConfig::new()
    .with_defaults(Config::default())
    .with_file("config.toml");

pub fn with_defaults_string(self, content: &str) -> Self

Add default configuration from a raw string (TOML, JSON, or YAML)

Uses the Universal provider to parse the string content with automatic format detection. Perfect for embedded configuration strings.

Examples

use superconfig::SuperConfig;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct CliArgs { host: Option<String> }

// Embedded default configuration (common pattern)
const DEFAULT_CONFIG: &str = r#"
host = "localhost"
port = 8080

[database]
url = "postgres://localhost"
timeout = 30
"#;

let cli_args = CliArgs { host: None };
let config = SuperConfig::new()
    .with_defaults_string(DEFAULT_CONFIG)  // Load TOML string as defaults
    .with_hierarchical_config("myapp")     // Apply hierarchical configs
    .with_env("APP_")                      // Apply env variables
    .with_cli_opt(Some(cli_args));         // Apply CLI overrides

pub fn with_cli_opt<T: Serialize>(self, cli_opt: Option<T>) -> Self

Add CLI option values with empty value filtering

Uses the Empty provider to filter out empty values while preserving meaningful falsy values (false, 0, etc.).

Examples

use superconfig::SuperConfig;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct CliArgs {
    host: Option<String>,
    port: Option<u16>,
}

let cli_args = CliArgs { host: Some("localhost".to_string()), port: None };
let config = SuperConfig::new()
    .with_file("config.toml")
    .with_cli_opt(Some(cli_args));

pub fn with_file_opt<P: AsRef<Path>>(self, path: Option<P>) -> Self

Add an optional configuration file with smart format detection

Uses the Universal provider for automatic format detection and caching. Only adds the file if the path is Some, otherwise returns self unchanged.

Examples

use superconfig::SuperConfig;
use std::path::PathBuf;

let optional_config: Option<PathBuf> = Some("config.toml".into());
let config = SuperConfig::new()
    .with_file_opt(optional_config)    // Only loads if Some
    .with_env("APP_");

pub fn with_env_ignore_empty<S: AsRef<str>>(self, prefix: S) -> Self

Add environment variables with a prefix and empty value filtering

Combines the Nested provider for JSON parsing and automatic nesting with the Empty provider to filter out empty values.

Examples

use superconfig::SuperConfig;

let config = SuperConfig::new()
    .with_env_ignore_empty("APP_");  // Filters empty env vars

impl SuperConfig

pub fn merge<P: Provider>(self, provider: P) -> Self

Merge a provider with warning collection and array merging

This method extends Figment’s merge functionality by:

1. Collecting validation warnings from providers (like Wildcard) if they support it
2. Continuing configuration loading even if providers have validation errors
3. Applying array merging with _add/_remove patterns

Examples

use superconfig::{SuperConfig, Wildcard};

let config = SuperConfig::new()
    .merge(Wildcard::new("invalid[pattern"))  // Stores warning, continues
    .merge(Wildcard::new("*.toml"));          // Normal loading
     
// Check for warnings after loading
for warning in config.warnings() {
    eprintln!("Configuration warning: {}", warning);
}

pub fn merge_validated<P: Provider + ValidatedProvider>( self, provider: P, ) -> Self

Merge a validated provider with warning collection

pub fn merge_opt<P: Provider>(self, provider: Option<P>) -> Self

Merge an optional provider with warning collection

Convenience method for merging optional providers. If the provider is None, no merge operation is performed.

Examples

use superconfig::{SuperConfig, Wildcard};

let optional_config = Some(Wildcard::new("*.toml"));
let config = SuperConfig::new()
    .merge_opt(optional_config);

pub fn warnings(&self) -> &[String]

Get all collected warnings

Returns a slice of warning messages collected during configuration loading. Warnings indicate non-fatal issues like invalid patterns in providers that were safely handled without stopping the configuration process.

Examples

use superconfig::{SuperConfig, Wildcard};

let config = SuperConfig::new()
    .merge(Wildcard::new("invalid[pattern"));
     
assert!(!config.warnings().is_empty());
println!("Warnings: {:?}", config.warnings());

pub fn has_warnings(&self) -> bool

Check if there are any warnings

Returns true if any providers generated validation warnings during loading.

Examples

use superconfig::{SuperConfig, Wildcard};

let config = SuperConfig::new()
    .merge(Wildcard::new("*.toml"));
     
if config.has_warnings() {
    eprintln!("Configuration loaded with warnings");
}

pub fn print_warnings(&self)

Print all warnings to stderr

Convenience method to display all collected warnings. Useful during application startup to alert users about configuration issues.

Examples

use superconfig::{SuperConfig, Wildcard};

let config = SuperConfig::new()
    .merge(Wildcard::new("invalid[pattern"))
    .merge(Wildcard::new("*.toml"));
     
config.print_warnings(); // Prints to stderr if any warnings exist

impl SuperConfig

pub fn new() -> Self

Create a new SuperConfig instance

pub fn from_figment(figment: Figment) -> Self

Create SuperConfig from an existing Figment

pub fn extract<'de, T: Deserialize<'de>>(&self) -> Result<T, Error>

Extract configuration directly (equivalent to calling .extract() on the inner Figment)

This is a convenience method that makes the SuperConfig API more fluent by avoiding the need to dereference before extraction.

Examples

use superconfig::SuperConfig;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Default)]
struct Config {
    #[serde(default)]
    host: String,
    #[serde(default)]
    port: u16,
}

let config: Config = SuperConfig::new()
    .with_defaults(Config::default())
    .with_file("config.toml")
    .with_env("APP_")
    .extract()?;                 // Direct extraction with all enhancements

impl SuperConfig

pub fn verbosity(&self) -> VerbosityLevel

Get the current verbosity level

pub fn debug_messages(&self) -> Vec<DebugMessage>

Get all collected debug messages

pub fn debug_messages_at_level( &self, level: VerbosityLevel, ) -> Vec<DebugMessage>

Get debug messages filtered by verbosity level

pub fn print_debug_messages(&self)

Print all debug messages at or below the current verbosity level

pub fn clear_debug_messages(&self)

Clear all collected debug messages

Methods from Deref<Target = Figment>

pub fn focus(&self, key: &str) -> Figment

Returns a new Figment containing only the sub-dictionaries at key.

This “sub-figment” is a focusing of self with the property that:

• self.find(key + ".sub") <=> focused.find("sub")

In other words, all values in self with a key starting with key are in focused without the prefix and vice-versa.

Example

use figment::{Figment, providers::{Format, Toml}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        cat = [1, 2, 3]
        dog = [4, 5, 6]

        [subtree]
        cat = "meow"
        dog = "woof!"

        [subtree.bark]
        dog = true
        cat = false
    "#)?;

    let root = Figment::from(Toml::file("Config.toml"));
    assert_eq!(root.extract_inner::<Vec<u8>>("cat").unwrap(), vec![1, 2, 3]);
    assert_eq!(root.extract_inner::<Vec<u8>>("dog").unwrap(), vec![4, 5, 6]);
    assert_eq!(root.extract_inner::<String>("subtree.cat").unwrap(), "meow");
    assert_eq!(root.extract_inner::<String>("subtree.dog").unwrap(), "woof!");

    let subtree = root.focus("subtree");
    assert_eq!(subtree.extract_inner::<String>("cat").unwrap(), "meow");
    assert_eq!(subtree.extract_inner::<String>("dog").unwrap(), "woof!");
    assert_eq!(subtree.extract_inner::<bool>("bark.cat").unwrap(), false);
    assert_eq!(subtree.extract_inner::<bool>("bark.dog").unwrap(), true);

    let bark = subtree.focus("bark");
    assert_eq!(bark.extract_inner::<bool>("cat").unwrap(), false);
    assert_eq!(bark.extract_inner::<bool>("dog").unwrap(), true);

    let not_a_dict = root.focus("cat");
    assert!(not_a_dict.extract_inner::<bool>("cat").is_err());
    assert!(not_a_dict.extract_inner::<bool>("dog").is_err());

    Ok(())
});

pub fn extract<'a, T>(&self) -> Result<T, Error>

where T: Deserialize<'a>,

Deserializes the collected value into T.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

#[derive(Debug, PartialEq, Deserialize)]
struct Config {
    name: String,
    numbers: Option<Vec<usize>>,
    debug: bool,
}

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        name = "test"
        numbers = [1, 2, 3, 10]
    "#)?;

    jail.set_env("config_name", "env-test");

    jail.create_file("Config.json", r#"
        {
            "name": "json-test",
            "debug": true
        }
    "#)?;

    let config: Config = Figment::new()
        .merge(Toml::file("Config.toml"))
        .merge(Env::prefixed("CONFIG_"))
        .join(Json::file("Config.json"))
        .extract()?;

    assert_eq!(config, Config {
        name: "env-test".into(),
        numbers: vec![1, 2, 3, 10].into(),
        debug: true
    });

    Ok(())
});

pub fn extract_lossy<'a, T>(&self) -> Result<T, Error>

where T: Deserialize<'a>,

As extract, but interpret numbers and booleans more flexibly.

See Value::to_bool_lossy and Value::to_num_lossy for a full explanation of the imputs accepted.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

#[derive(Debug, PartialEq, Deserialize)]
struct Config {
    name: String,
    numbers: Option<Vec<usize>>,
    debug: bool,
}

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        name = "test"
        numbers = ["1", "2", "3", "10"]
    "#)?;

    jail.set_env("config_name", "env-test");

    jail.create_file("Config.json", r#"
        {
            "name": "json-test",
            "debug": "yes"
        }
    "#)?;

    let config: Config = Figment::new()
        .merge(Toml::file("Config.toml"))
        .merge(Env::prefixed("CONFIG_"))
        .join(Json::file("Config.json"))
        .extract_lossy()?;

    assert_eq!(config, Config {
        name: "env-test".into(),
        numbers: vec![1, 2, 3, 10].into(),
        debug: true
    });

    Ok(())
});

pub fn extract_inner<'a, T>(&self, path: &str) -> Result<T, Error>

where T: Deserialize<'a>,

Deserializes the value at the key path in the collected value into T.

Example

use figment::{Figment, providers::{Format, Toml, Json}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        numbers = [1, 2, 3, 10]
    "#)?;

    jail.create_file("Config.json", r#"{ "debug": true } "#)?;

    let numbers: Vec<usize> = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Json::file("Config.json"))
        .extract_inner("numbers")?;

    assert_eq!(numbers, vec![1, 2, 3, 10]);

    Ok(())
});

pub fn extract_inner_lossy<'a, T>(&self, path: &str) -> Result<T, Error>

where T: Deserialize<'a>,

As extract, but interpret numbers and booleans more flexibly.

See Value::to_bool_lossy and Value::to_num_lossy for a full explanation of the imputs accepted.

Example

use figment::{Figment, providers::{Format, Toml, Json}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        numbers = ["1", "2", "3", "10"]
    "#)?;

    jail.create_file("Config.json", r#"{ "debug": true } "#)?;

    let numbers: Vec<usize> = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Json::file("Config.json"))
        .extract_inner_lossy("numbers")?;

    assert_eq!(numbers, vec![1, 2, 3, 10]);

    Ok(())
});

pub fn metadata(&self) -> impl Iterator<Item = &Metadata>

Returns an iterator over the metadata for all of the collected values in the order in which they were added to self.

Example

use figment::{Figment, providers::{Format, Toml, Json}};

let figment = Figment::new()
    .merge(Toml::file("Config.toml"))
    .join(Json::file("Config.json"));

assert_eq!(figment.metadata().count(), 2);
for (i, md) in figment.metadata().enumerate() {
    match i {
        0 => assert!(md.name.starts_with("TOML")),
        1 => assert!(md.name.starts_with("JSON")),
        _ => unreachable!(),
    }
}

pub fn profile(&self) -> &Profile

Returns the selected profile.

Example

use figment::Figment;

let figment = Figment::new();
assert_eq!(figment.profile(), "default");

let figment = figment.select("staging");
assert_eq!(figment.profile(), "staging");

pub fn profiles(&self) -> impl Iterator<Item = &Profile>

Returns an iterator over profiles with valid configurations in this figment. Note: this may not include the selected profile if the selected profile has no configured values.

Example

use figment::{Figment, providers::Serialized};

let figment = Figment::new();
let profiles = figment.profiles().collect::<Vec<_>>();
assert_eq!(profiles.len(), 0);

let figment = Figment::new()
    .join(Serialized::default("key", "hi"))
    .join(Serialized::default("key", "hey").profile("debug"));

let mut profiles = figment.profiles().collect::<Vec<_>>();
profiles.sort();
assert_eq!(profiles, &["debug", "default"]);

let figment = Figment::new()
    .join(Serialized::default("key", "hi").profile("release"))
    .join(Serialized::default("key", "hi").profile("testing"))
    .join(Serialized::default("key", "hey").profile("staging"))
    .select("debug");

let mut profiles = figment.profiles().collect::<Vec<_>>();
profiles.sort();
assert_eq!(profiles, &["release", "staging", "testing"]);

pub fn find_value(&self, path: &str) -> Result<Value, Error>

Finds the value at path in the combined value.

If there is an error evaluating the combined figment, that error is returned. Otherwise if there is a value at path, returns Ok(value), and if there is no value at path, returns Err of kind MissingField.

See Value::find() for details on the syntax for path.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        name = "test"

        [package]
        name = "my-package"
    "#)?;

    jail.create_file("Config.json", r#"
        {
            "author": { "name": "Bob" }
        }
    "#)?;

    let figment = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Json::file("Config.json"));

    let name = figment.find_value("name")?;
    assert_eq!(name.as_str(), Some("test"));

    let package_name = figment.find_value("package.name")?;
    assert_eq!(package_name.as_str(), Some("my-package"));

    let author_name = figment.find_value("author.name")?;
    assert_eq!(author_name.as_str(), Some("Bob"));

    Ok(())
});

pub fn contains(&self, path: &str) -> bool

Returns true if the combined figment evaluates successfully and contains a value at path.

See Value::find() for details on the syntax for path.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#"
        name = "test"

        [package]
        name = "my-package"
    "#)?;

    jail.create_file("Config.json", r#"
        {
            "author": { "name": "Bob" }
        }
    "#)?;

    let figment = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Json::file("Config.json"));

    assert!(figment.contains("name"));
    assert!(figment.contains("package"));
    assert!(figment.contains("package.name"));
    assert!(figment.contains("author"));
    assert!(figment.contains("author.name"));
    assert!(!figment.contains("author.title"));
    Ok(())
});

pub fn find_metadata(&self, key: &str) -> Option<&Metadata>

Finds the metadata for the value at key path. See Value::find() for details on the syntax for key.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#" name = "test" "#)?;
    jail.set_env("CONF_AUTHOR", "Bob");

    let figment = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Env::prefixed("CONF_").only(&["author"]));

    let name_md = figment.find_metadata("name").unwrap();
    assert!(name_md.name.starts_with("TOML"));

    let author_md = figment.find_metadata("author").unwrap();
    assert!(author_md.name.contains("CONF_"));
    assert!(author_md.name.contains("environment"));

    Ok(())
});

pub fn get_metadata(&self, tag: Tag) -> Option<&Metadata>

Returns the metadata with the given tag if this figment contains a value with said metadata.

Example

use serde::Deserialize;

use figment::{Figment, providers::{Format, Toml, Json, Env}};

figment::Jail::expect_with(|jail| {
    jail.create_file("Config.toml", r#" name = "test" "#)?;
    jail.create_file("Config.json", r#" { "author": "Bob" } "#)?;

    let figment = Figment::new()
        .merge(Toml::file("Config.toml"))
        .join(Json::file("Config.json"));

    let name = figment.find_value("name").unwrap();
    let metadata = figment.get_metadata(name.tag()).unwrap();
    assert!(metadata.name.starts_with("TOML"));

    let author = figment.find_value("author").unwrap();
    let metadata = figment.get_metadata(author.tag()).unwrap();
    assert!(metadata.name.starts_with("JSON"));

    Ok(())
});

Trait Implementations

impl Debug for SuperConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DebugCollector for SuperConfig

fn debug(&self, level: VerbosityLevel, provider: &str, message: &str)

Add a debug message

fn debug_step( &self, level: VerbosityLevel, provider: &str, step: usize, message: &str, )

Add a debug message with step information

fn debug_result( &self, level: VerbosityLevel, provider: &str, message: &str, success: bool, )

Add a debug message with success/failure indication

fn debug_step_result( &self, level: VerbosityLevel, provider: &str, step: usize, message: &str, success: bool, )

Add a debug message with both step and success information

impl Default for SuperConfig

fn default() -> Self

Returns the “default value” for a type.

impl From<Figment> for SuperConfig

fn from(figment: Figment) -> Self

Converts to this type from the input type.

impl From<SuperConfig> for Figment

fn from(super_figment: SuperConfig) -> Self

Converts to this type from the input type.

impl Deref for SuperConfig

Deref to Figment provides 100% compatibility - all Figment methods work seamlessly

type Target = Figment

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.