pleiades-types 0.6.0

Shared typed vocabulary for the pleiades astrology workspace: angles, bodies, time scales, observers, coordinates, zodiac modes, house systems, and ayanamsas.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::*;

#[test]
fn custom_house_system_display_includes_aliases_and_notes() {
    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("MCH".to_string());
    custom.aliases.push("Test Houses".to_string());
    custom.notes = Some("based on a user-defined formula".to_string());

    assert_eq!(
        custom.to_string(),
        "My Custom Houses [aliases: MCH, Test Houses] (based on a user-defined formula)"
    );
}

#[test]
fn custom_house_system_validate_rejects_whitespace_and_duplicate_aliases() {
    assert_eq!(
        CustomHouseSystem::new("   ")
            .validate()
            .expect_err("blank house system names should be rejected")
            .to_string(),
        "custom house system name must not be blank"
    );

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("MCH".to_string());
    custom.aliases.push("MCH".to_string());

    assert_eq!(
        custom
            .validate()
            .expect_err("duplicate aliases should be rejected")
            .to_string(),
        "custom house system aliases must be unique: duplicate MCH"
    );

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("MCH".to_string());
    custom.aliases.push("mch".to_string());

    assert_eq!(
        custom
            .validate()
            .expect_err("case-normalized aliases should be rejected")
            .to_string(),
        "custom house system aliases must be unique: duplicate mch"
    );

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("my custom houses".to_string());

    assert_eq!(
        custom
            .validate()
            .expect_err("aliases should not duplicate the canonical name")
            .to_string(),
        "custom house system aliases must be unique: duplicate my custom houses"
    );

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.notes = Some("  ".to_string());

    assert_eq!(
        custom
            .validate()
            .expect_err("blank notes should be rejected")
            .to_string(),
        "custom house system notes must not be blank"
    );
}

#[test]
fn custom_house_system_validate_against_reserved_labels_rejects_builtin_collisions() {
    let custom = CustomHouseSystem::new("Equal");
    assert_eq!(
        custom
            .validate_against_reserved_labels(|label| label.eq_ignore_ascii_case("Equal"))
            .expect_err("built-in labels should be rejected")
            .to_string(),
        "custom house system name must not match a built-in label: Equal"
    );

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("Whole Sign".to_string());

    assert_eq!(
        custom
            .validate_against_reserved_labels(|label| label.eq_ignore_ascii_case("Whole Sign"))
            .expect_err("built-in aliases should be rejected")
            .to_string(),
        "custom house system alias[0] must not match a built-in label: Whole Sign"
    );
}

#[test]
fn house_systems_have_stable_display_names() {
    assert_eq!(HouseSystem::Placidus.to_string(), "Placidus");
    assert_eq!(HouseSystem::EqualMidheaven.to_string(), "Equal (MC)");
    assert_eq!(HouseSystem::Carter.to_string(), "Carter (poli-equatorial)");
    assert_eq!(HouseSystem::Gauquelin.to_string(), "Gauquelin sectors");

    let custom = CustomHouseSystem::new("My Custom Houses");
    assert_eq!(
        HouseSystem::Custom(custom.clone()).to_string(),
        custom.to_string()
    );
}

#[test]
fn house_system_validate_reuses_the_structured_validator() {
    assert!(HouseSystem::WholeSign.validate().is_ok());

    let mut custom = CustomHouseSystem::new("My Custom Houses");
    custom.aliases.push("MCH".to_string());
    custom.aliases.push("mch".to_string());

    assert_eq!(
        HouseSystem::Custom(custom)
            .validate()
            .expect_err("custom house systems should validate their aliases")
            .to_string(),
        "custom house system aliases must be unique: duplicate mch"
    );
}

#[test]
fn house_system_enum_validate_against_reserved_labels_checks_wrapped_custom() {
    let wrapped = HouseSystem::Custom(CustomHouseSystem::new("Equal"));
    assert!(wrapped
        .validate_against_reserved_labels(|label| label.eq_ignore_ascii_case("Equal"))
        .is_err());
    assert_eq!(
        HouseSystem::Placidus.validate_against_reserved_labels(|_| true),
        Ok(())
    );
}