Allow optional fields for types that implement Default

[mmastrac]

I think that requiring fields that have a valid default makes the API awkward. ie, the below code should be allowed.

EDIT: I just noticed that #[builder(default = ...)] exists, but that seems like overkill when optional makes the most sense. Perhaps #[builder(optional)] could be inferred to always be #[builder(default = "Default::default()"]?

/// Represents a configuration schema object (type definition)
#[derive(Debug, Clone, Serialize, Deserialize, Builder)]
pub struct ConfigSchemaObject {
    /// Name of the type (e.g., "cfg::Config", "cfg::Auth")
    #[builder(required)]
    pub name: String,
    /// List of ancestor type IDs
    #[builder(optional)]
    pub ancestors: Vec<ConfigSchemaTypeReference>,
    /// Properties of this type
    #[builder(required)]
    pub properties: Vec<ConfigSchemaProperty>,
    /// Links (relationships) to other types
    #[builder(required)]
    pub links: Vec<ConfigSchemaLink>,
}

[tomoikey]

@mmastrac

Hi! Thank you for the new proposal.
I have opened a POC pull request; could you take a look? It adds conditional logic based on whether default includes an expression.
I also considered the optional-based approach you suggested, but I believe keeping optional as an independent concept will be clearer and help avoid confusing users. Once the POC PR is merged, the sample code below should work as expected.

Would that be acceptable?

#[test]
fn bare_default_success() {
    #[derive(Builder, PartialEq)]
    struct Config {
        #[builder(default)]
        name: String,
        #[builder(default)]
        port: i32,
        #[builder(default)]
        enabled: bool,
    }

    let config = ConfigBuilder::new().build();
    assert_eq!(config.name, String::default());
    assert_eq!(config.port, i32::default());
    assert_eq!(config.enabled, bool::default());

    let config = ConfigBuilder::new()
        .with_name("custom".to_string())
        .with_port(8080)
        .with_enabled(true)
        .build();
    assert_eq!(config.name, "custom");
    assert_eq!(config.port, 8080);
    assert_eq!(config.enabled, true);
}

#[test]
fn mixed_default_and_expression_default() {
    #[derive(Builder, PartialEq)]
    struct Config {
        #[builder(default)]
        name: String,
        #[builder(default = "42")]
        port: i32,
        #[builder(default = "vec![1, 2, 3]")]
        numbers: Vec<i32>,
    }

    let config = ConfigBuilder::new().build();
    assert_eq!(config.name, String::default());
    assert_eq!(config.port, 42);
    assert_eq!(config.numbers, vec![1, 2, 3]);
}

#[test]
fn bare_default_with_custom_types() {
    #[derive(PartialEq, Default, Debug)]
    struct CustomType {
        value: i32,
    }

    #[derive(Builder, PartialEq)]
    struct Config {
        #[builder(default)]
        custom: CustomType,
    }

    let config = ConfigBuilder::new().build();
    assert_eq!(config.custom, CustomType::default());
}

[mmastrac]

This would work!

[tomoikey]

@mmastrac
Thanks. I'm ganna merge it on this weekend

[tomoikey]

@mmastrac
Apologies for the delay. I’ve just merged the PR, and the release is complete.
https://github.com/tomoikey/typesafe_builder/releases/tag/v1.6

[mmastrac]

Awesome. I'll bump my dep next week and give it a shot.