astrology 3.0.3

Astrology lib connected to the C lib 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::path::Path;

/// Check if the path for the swissephem files exist
pub fn validator_parse_path(path: String) -> Result<(), String> {
    if Path::new(path.clone().as_str()).exists() {
        Ok(())
    } else {
        Err(format!(
            "The path for your swiss emphem files don't exist: {}",
            path
        ))
    }
}

/// Check if size is ok
pub fn validator_parse_size(size: String) -> Result<(), String> {
    let i: u32 = size.parse::<u32>().unwrap();
    if i >= 800 && i <= 2000 {
        Ok(())
    } else {
        Err(format!("{} isn't between 800 and 2000.", size))
    }
}

/// Check if format of date is ok
/// . (3) and - (0-1) for eventual BC date
pub fn validator_parse_date(date: String) -> Result<(), String> {
    let d: &str = &date.as_str();
    let items: Vec<_> = d.split(&['.', '-'][..]).collect();
    for item in &items {
        if !item.chars().all(char::is_numeric) {
            return Err(format!("{} is invalid because: {} isn't numeric. Please enter in format dd.mm.yyyy", date, item));
        }
    }
    let mut bc_4_item = 0;
    for i in 0..date.clone().len() {
        let str_bytes = date.clone().as_bytes()[i] as char;
        if str_bytes == '-' {
            bc_4_item += 1;
        }
    }
    if (items.len() == 3 && bc_4_item == 0)
        || (items.len() == 4 && bc_4_item == 1)
    {
        Ok(())
    } else {
        Err(format!(
            "{} is invalid. Please enter in format dd.mm.yyyy.",
            date
        ))
    }
}

/// Check if format of time is ok
/// : (1-3) and after 3 ignore input
pub fn validator_parse_time(time: String) -> Result<(), String> {
    let d: &str = &time.as_str();
    let items: Vec<_> = d.split(&[':'][..]).collect();
    for (i, item) in items.clone().iter().enumerate() {
        if i > 2 {
            break;
        }
        if !item.chars().all(char::is_numeric) {
            return Err(format!("{} is invalid because: {} isn't numeric. Please enter in format hh:mm or hh:mm:ss", time, item));
        }
    }
    if items.len() >= 1 {
        if items.len() == 1 && !time.chars().all(char::is_numeric) {
            Err(format!(
                "{} is invalid. Please enter in format hh:mm or hh:mm:ss",
                time
            ))
        } else {
            Ok(())
        }
    } else {
        Err(format!(
            "{} is invalid. Please enter in format hh:mm or hh:mm:ss",
            time
        ))
    }
}

/// Check if latitude or longitude is ok
/// . (0-1)
pub fn validator_parse_latlng(latlng: String) -> Result<(), String> {
    let d: &str = &latlng.as_str();
    let items: Vec<_> = d.split(&['.', '+', '-'][..]).collect();
    for item in items.clone() {
        if !item.chars().all(char::is_numeric) {
            return Err(format!("{} is invalid because: {} isn't numeric. Please enter in format 99.99", latlng, item));
        }
    }
    if items.len() >= 1 {
        if items.len() == 1 && !latlng.chars().all(char::is_numeric) {
            Err(format!(
                "{} is invalid. Please enter in format 99.99",
                latlng
            ))
        } else {
            Ok(())
        }
    } else {
        Err(format!(
            "{} is invalid. Please enter in format 99.99",
            latlng
        ))
    }
}

/// Check if timezone is ok
/// . (0-1)
pub fn validator_parse_timezone(time_zone: String) -> Result<(), String> {
    let d: &str = &time_zone.as_str();
    let items: Vec<_> = d.split(&['.', '+', '-'][..]).collect();
    for item in items.clone() {
        if !item.chars().all(char::is_numeric) {
            return Err(format!("{} is invalid because isn't numeric. Please enter in format numeric", time_zone));
        }
    }
    if items.len() >= 1 {
        if items.len() == 1 && !time_zone.chars().all(char::is_numeric) {
            Err(format!(
                "{} is invalid. Please enter in format numeric",
                time_zone
            ))
        } else {
            Ok(())
        }
    } else {
        Err(format!(
            "{} is invalid. Please enter in format numeric",
            time_zone
        ))
    }
}

/// Check if aspect is valid
pub fn validator_parse_aspect(aspect: String) -> Result<(), String> {
    let i: u32 = aspect.parse::<u32>().unwrap();
    if i <= 12 {
        Ok(())
    } else {
        Err(format!(
            "{} isn't between 0 and 12 (--help for code list)",
            aspect
        ))
    }
}