kundli-rs 0.2.0

A Rust library for calculating astrological kundli charts using the Swiss Ephemeris.
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

use crate::kundli::astro::{
    AstroBodyPosition, AstroError, AstroMeta, AstroRequest, AstroResult, ephemeris::Ephemeris,
};

/// Backend abstraction for astronomical calculations.
pub trait AstroEngine {
    /// Calculates raw astronomical output for a validated request.
    fn calculate(&self, request: &AstroRequest) -> Result<AstroResult, AstroError>;
}

/// Configuration for [`SwissEphAstroEngine`].
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SwissEphConfig {
    ephemeris_path: Option<String>,
}

impl SwissEphConfig {
    /// Creates an empty Swiss Ephemeris configuration.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the ephemeris path used by the backend.
    pub fn with_ephemeris_path(mut self, ephemeris_path: impl Into<String>) -> Self {
        self.ephemeris_path = Some(ephemeris_path.into());
        self
    }

    pub(crate) fn ephemeris_path(&self) -> Option<&str> {
        self.ephemeris_path.as_deref()
    }
}

/// Default [`AstroEngine`] implementation backed by Swiss Ephemeris.
#[derive(Debug, Clone, Default)]
pub struct SwissEphAstroEngine {
    config: SwissEphConfig,
}

impl SwissEphAstroEngine {
    /// Creates a Swiss Ephemeris-backed engine with the provided config.
    pub fn new(config: SwissEphConfig) -> Self {
        Self { config }
    }
}

impl AstroEngine for SwissEphAstroEngine {
    fn calculate(&self, request: &AstroRequest) -> Result<AstroResult, AstroError> {
        request.validate()?;

        let raw = Ephemeris::calculate(request, &self.config)?;
        let bodies = std::array::from_fn(|index| {
            let body = crate::kundli::astro::AstroBody::ALL[index];
            let position = raw.bodies[index];
            AstroBodyPosition {
                body,
                longitude: position.longitude,
                latitude: position.latitude,
                distance: position.distance,
                speed_longitude: position.longitude_speed,
            }
        });

        Ok(AstroResult {
            bodies,
            ascendant_longitude: raw.houses.ascendant,
            mc_longitude: raw.houses.mc,
            house_cusps: raw.houses.cusps,
            meta: AstroMeta {
                jd_ut: request.jd_ut,
                latitude: request.latitude,
                longitude: request.longitude,
                zodiac: request.zodiac,
                ayanamsha: request.ayanamsha,
                ayanamsha_value: raw.ayanamsha_value,
                sidereal_time: raw.sidereal_time,
            },
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    fn sample_request() -> AstroRequest {
        AstroRequest::new(2451545.0, 37.5665, 126.978)
    }

    #[test]
    fn calculate_returns_full_body_set_and_house_shape() {
        let engine = SwissEphAstroEngine::default();
        let request = sample_request();
        let result = engine.calculate(&request).unwrap();

        assert_eq!(
            result.bodies.len(),
            crate::kundli::astro::AstroBody::ALL.len()
        );
        assert_eq!(result.house_cusps.len(), 12);
        assert!(result.ascendant_longitude >= 0.0);
        assert!(result.mc_longitude >= 0.0);
        assert_eq!(result.meta.jd_ut, request.jd_ut);
        assert!(result.meta.ayanamsha_value.is_some());
    }

    #[test]
    fn engine_accepts_declarative_config() {
        let engine = SwissEphAstroEngine::new(SwissEphConfig::new().with_ephemeris_path(""));

        let result = engine.calculate(&sample_request()).unwrap();

        assert_eq!(
            result.bodies.len(),
            crate::kundli::astro::AstroBody::ALL.len()
        );
    }
}