lib.rs

use serde::{Deserialize, Serialize};
use struct_patch::Catalyst;
use substrate::Base;

#[derive(Default, Catalyst)]
#[catalyst(bind = Base)]
// The Substrate has `#[serde(...)]` on fields , and catalyst keep_field_attribute
// so the complex should have the corresponding Serialize derive
#[catalyst(keep_field_attribute)]
#[complex(attribute(derive(Debug, Deserialize, Serialize)))]
#[allow(dead_code)]
struct Amyloid {
    pub extra_bool: bool,
    #[complex(attribute(serde(default = "default_str")))]
    pub extra_string: String,
    pub extra_option: Option<usize>,
    #[complex(attribute(serde(default = "default_extra_private_number")))]
    extra_private_number: u8,
}

fn default_str() -> String {
    "default".to_string()
}

fn default_extra_private_number() -> u8 {
    7
}

#[allow(dead_code)]
impl AmyloidComplex {
    /// Sum up the private_number(from Substrate) and the extra_private_number(from Catalyst)
    fn private_number_sum(&self) -> u8 {
        self.private_number + self.extra_private_number
    }
}

#[derive(Default, Catalyst)]
#[catalyst(bind = Base)]
#[catalyst(keep_field_attribute)]
#[catalyst(exclude_field_attributes = ["serde"])]
#[complex(attribute(derive(Debug, Deserialize)))]
#[allow(dead_code)]
struct ExcludedAmyloid {
    pub extra_bool: bool,
}

#[derive(Catalyst)]
#[catalyst(bind = Base)]
#[complex(name = "SmallCpx")]
#[allow(dead_code)]
#[complex(attribute(derive(Default, Deserialize)))]
#[complex(override_field_attribute("field_string", serde(default = "default_str")))]
#[complex(override_field_attribute("field_string", serde(rename = "renamed_field")))]
struct SmallAmyloid {
    pub extra_bool: bool,
}

#[allow(dead_code)]
impl SmallCpx {
    /// A reaction to change the substrate
    pub fn reaction(&mut self) {
        self.field_bool = true;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use struct_patch::Complex;

    #[test]
    fn complex_works() {
        let mut small_complex = SmallCpx::default();
        assert_eq!(small_complex.field_bool, false);
        assert_eq!(small_complex.field_string, String::new());
        assert_eq!(small_complex.field_option, None);
        assert_eq!(small_complex.extra_bool, false);

        small_complex.reaction();

        let (_cat, substrate) = small_complex.decouple();
        assert!(substrate.has_bool());

        let amyloid = Amyloid::default();
        let complex = amyloid.bind(substrate);
        assert_eq!(complex.field_bool, true);
        assert_eq!(complex.private_number_sum(), 0);

        let toml_str = toml::to_string_pretty(&complex).unwrap();
        assert_eq!(
            toml_str,
            r#"field_bool = true
field_string = ""
private_number = 0
extra_bool = false
extra_string = ""
extra_private_number = 0
"#
        );
        let toml_str = r#" field_bool = true
field_string = ""
private_number = 1
extra_bool = true
    "#;
        let complex: AmyloidComplex = toml::from_str(toml_str).unwrap();
        assert_eq!(complex.extra_string, "default");
        
        // the `extra_private_number` is 7 generated by `default_extra_private_number`, when serialize with a missing field
        // such that the `private_number` + `extra_private_number` = 1 + 7 = 8
        assert_eq!(complex.private_number_sum(), 8);
    }

    #[test]
    fn exclude_field_attributes_works() {
        // Base has `#[serde(default)]` on `field_bool`. With exclude_field_attributes = ["serde"],
        // that attribute is stripped from the complex, making `field_bool` a required field.
        let toml_missing_field_bool = r#"field_string = "test"
private_number = 0
extra_bool = false
"#;
        assert!(
            toml::from_str::<ExcludedAmyloidComplex>(toml_missing_field_bool).is_err(),
            "field_bool should be required when serde attributes are excluded"
        );

        let toml_all_fields = r#"field_bool = true
field_string = "test"
private_number = 0
extra_bool = false
"#;
        let complex: ExcludedAmyloidComplex =
            toml::from_str(toml_all_fields).expect("all required fields provided");
        assert_eq!(complex.field_bool, true);
        assert_eq!(complex.field_string, "test");
        assert_eq!(complex.extra_bool, false);
    }

    #[test]
    fn override_works() {
        let toml_str = r#"field_bool = false
private_number = 0
extra_bool = false
"#;
        let complex: SmallCpx = toml::from_str(toml_str).unwrap();
        assert_eq!(complex.field_string, "default");
        let toml_str = r#"field_bool = false
private_number = 0
renamed_field = "Renamed"
extra_bool = false
"#;
        let complex: SmallCpx = toml::from_str(toml_str).unwrap();
        assert_eq!(complex.field_string, "Renamed");
    }
}