Struct netlify_toml::Config

pub struct Config {
    pub build: Option<Build>,
    pub context: Option<HashMap<String, Context>>,
    pub redirects: Option<Vec<Redirect>>,
    pub headers: Option<Vec<Header>>,
    pub template: Option<Template>,
}

Config represents the global configuration within a netlify.toml file.

Fields

build: Option<Build>

context: Option<HashMap<String, Context>>

redirects: Option<Vec<Redirect>>

headers: Option<Vec<Header>>

template: Option<Template>

Implementations

impl Config

pub fn scoped_env(self, ctx: &str, branch: &str) -> HashMap<String, String>

Return a HashMap that aggregates all environment variables for a context within a git branch.

Arguments

ctx - The context name, for example deploy-preview, branch-deploy or production. branch - The deploy branch name, for example make-changes-to-my-site.

Example

let io = r#"
[build]
  command = "make site"
"#;

let config = netlify_toml::from_str(io).unwrap();
let env = config.scoped_env("deploy-preview", "new-styles");

pub fn scoped_redirects(&self, ctx: &str, branch: &str) -> Option<Vec<Redirect>>

Return a list of aggregated redirects for a context within a branch.

If a context includes a redirect that's defined by the global list, the redirect is replaced in the global list to preserve this ordering. This match is based on the exact comparison of the origin value.

If a context includes a redirect that's not defined by the global list, the redirect is appended before any other redirect in the global list to give it a higher precedence.

Arguments

ctx - The context name, for example deploy-preview, branch-deploy or production. branch - The deploy branch name, for example make-changes-to-my-site.

Example

let io = r#"
[[redirects]]
  from = "/api/*"
  to = "https://production.api.com/:splat"

[[context.deploy-preview.redirects]]
  from = "/api/*"
  to = "https://staging.api.com/:splat"
"#;

let config = netlify_toml::from_str(io).unwrap();
let redirects = config.scoped_redirects("deploy-preview", "new-styles").expect("missing redirects");
assert_eq!(1, redirects.len());
let dest = redirects.first().and_then(|r| r.to.as_ref()).expect("missing destination");
assert_eq!("https://staging.api.com/:splat", dest.as_str());

pub fn scoped_headers(&self, ctx: &str, branch: &str) -> Option<Vec<Header>>

Return a list of aggregated header rules for a context within a branch.

If a context includes a header rule that's defined by the global list, the header rule is replaced in the global list to preserve this ordering. This match is based on the exact comparison of the origin value.

If a context includes a header rule that's not defined by the global list, the header rule is appended before any other header rules in the global list to give it a higher precedence.

Arguments

ctx - The context name, for example deploy-preview, branch-deploy or production. branch - The deploy branch name, for example make-changes-to-my-site.

Example

    let io = r#"
    [[headers]]
    for = "/foo"
    values = {X-Foo = "Bar, Baz, Qux"}

    [[headers]]
    for = "/bar"
    values = {X-Foo = "Bar, Baz, Qux"}

    [[context.deploy-preview.headers]]
    for = "/foo"
    values = {X-BAR = "QUUX"}
"#;

    let config = netlify_toml::from_str(&io).unwrap();
    let headers = config
        .scoped_headers("deploy-preview", "new-styles")
        .expect("missing headers");
    assert_eq!(2, headers.len());

    let header = headers.first().unwrap();
    assert_eq!("/foo", header.path);
    assert!(header.headers.contains_key("X-BAR"));
    assert!(!header.headers.contains_key("X-Foo"));

Trait Implementations

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

pub fn default() -> Config

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Config

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Config> for Config

pub fn eq(&self, other: &Config) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Config) -> bool

This method tests for !=.

impl Serialize for Config

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Config