character-traits-transformative-abilities 0.1.0

A Rust crate providing a conceptual framework for defining and analyzing transformative abilities using complex attributes and domains.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// ---------------- [ File: character-traits-transformative-abilities/src/tests.rs ]
crate::ix!();

#[cfg(test)]
mod profile_tests {
    use super::*;

    #[traced_test]
    fn builder_resolves_descriptors_correctly() {
        let attrs = BTreeSet::from_iter([NuancedTransformAttribute::Innovation]);

        let profile = TransformAbilityProfileBuilder::default()
            .core_domain(CoreTransformDomain::ScientificProgress)
            .nuanced_attributes(attrs.clone())
            .build()
            .expect("profile build should succeed");

        assert!(
            profile
                .descriptors()
                .contains(&TransformativeAbilityDescriptor::AdvancesInterdisciplinaryScientificApproaches),
            "expected scientific innovation descriptor"
        );

        for d in profile.descriptors() {
            let (_, got_attrs) = analyze_transformative_ability_descriptor(d);
            assert!(attrs.is_subset(&got_attrs));
        }
    }

    #[traced_test]
    fn from_descriptor_round_trips() {
        let original = TransformativeAbilityDescriptor::EncouragesAdaptationAndResilience;
        let profile  = TransformAbilityProfile::from(original.clone());

        assert_eq!(profile.core_domain(), &CoreTransformDomain::AdaptationResilience);
        assert!(profile
            .nuanced_attributes()
            .contains(&NuancedTransformAttribute::Resilience));
        assert_eq!(profile.descriptors(), &[original]);
    }

    /// Exhaustive: every descriptor is reachable from its own
    /// (core, nuanced) signature.
    #[traced_test]
    fn every_descriptor_is_reachable() {
        for d in TransformativeAbilityDescriptor::iter() {
            let (c, a) = analyze_transformative_ability_descriptor(&d);

            let profile = TransformAbilityProfileBuilder::default()
                .core_domain(c.clone())
                .nuanced_attributes(a.clone())
                .build()
                .unwrap();

            assert!(
                profile.descriptors().contains(&d),
                "{d:?} should be part of the resolved set"
            );
        }
    }

    #[traced_test]
    fn subset_matching_works() {
        let descriptor = TransformativeAbilityDescriptor::TransformsDecayIntoNourishment;
        let (_, full_attrs) = analyze_transformative_ability_descriptor(&descriptor);

        // Strict subset ‑ only Renewal.
        assert!(full_attrs.contains(&NuancedTransformAttribute::Renewal));
        let subset = BTreeSet::from_iter([NuancedTransformAttribute::Renewal]);

        let profile = TransformAbilityProfileBuilder::default()
            .core_domain(CoreTransformDomain::EcologicalRenewal)
            .nuanced_attributes(subset)
            .build()
            .unwrap();

        assert!(
            profile.descriptors().contains(&descriptor),
            "descriptor should appear under subset attribute query"
        );

        // Disjoint attributes fail to match.
        let disjoint = BTreeSet::from_iter([NuancedTransformAttribute::Strategy]);
        let empty_profile = TransformAbilityProfileBuilder::default()
            .core_domain(CoreTransformDomain::EcologicalRenewal)
            .nuanced_attributes(disjoint)
            .build()
            .unwrap();

        assert!(
            !empty_profile.descriptors().contains(&descriptor),
            "descriptor must not appear with disjoint attributes"
        );
    }

    #[traced_test]
    fn earliest_token_precedence() {
        // Contains both "strateg" and "societ" – the *earliest* token
        // (“Strategic…”) should dictate the core domain.
        let original = TransformativeAbilityDescriptor::TransformsSituationsThroughStrategicManipulation;
        let profile  = TransformAbilityProfile::from(original);

        assert_eq!(
            profile.core_domain(),
            &CoreTransformDomain::StrategicMastery,
            "earliest keyword should win when multiple core signals exist"
        );
    }
}