celery 0.5.5

Rust implementation of Celery
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

use std::collections::HashSet;

use super::{Ordinal, TimeUnitField};
use crate::error::ScheduleError;

pub struct CronParsingError;

pub enum Shorthand {
    Yearly,
    Monthly,
    Weekly,
    Daily,
    Hourly,
}

pub fn parse_shorthand(s: &str) -> Result<Shorthand, ScheduleError> {
    use Shorthand::*;
    match s.to_lowercase().as_str() {
        "@yearly" => Ok(Yearly),
        "@monthly" => Ok(Monthly),
        "@weekly" => Ok(Weekly),
        "@daily" => Ok(Daily),
        "@hourly" => Ok(Hourly),
        _ => Err(ScheduleError::CronScheduleError(format!(
            "'{s}' is not a valid shorthand for a cron schedule"
        ))),
    }
}

enum ParsedElement {
    Star,
    StarWithStep {
        step: Ordinal,
    },
    Number(Ordinal),
    Range {
        lower: Ordinal,
        upper: Ordinal,
    }, // inclusive
    RangeWithStep {
        lower: Ordinal,
        upper: Ordinal,
        step: Ordinal,
    }, // inclusive
}

pub fn parse_longhand<T: TimeUnitField>(s: &str) -> Result<Vec<Ordinal>, ScheduleError> {
    let lower_bound = T::inclusive_min();
    let upper_bound = T::inclusive_max();
    let mut result = HashSet::new();

    for element in s.split(',') {
        let parsed_element = parse_element_with_step::<T>(element);
        use ParsedElement::*;
        match parsed_element {
            Err(_) => {
                let error_message = format!("'{}' is an invalid value for {}", s, T::name());
                return Err(ScheduleError::CronScheduleError(error_message));
            }
            Ok(Star) => {
                for i in lower_bound..=upper_bound {
                    result.insert(i);
                }
            }
            Ok(StarWithStep { step }) => {
                for i in (lower_bound..=upper_bound).step_by(step as usize) {
                    result.insert(i);
                }
            }
            Ok(Number(i)) => {
                result.insert(i);
            }
            Ok(Range { lower, upper }) => {
                for i in lower..=upper {
                    result.insert(i);
                }
            }
            Ok(RangeWithStep { lower, upper, step }) => {
                for i in (lower..=upper).step_by(step as usize) {
                    result.insert(i);
                }
            }
        }
    }

    let mut result: Vec<_> = result.iter().copied().collect();
    result.sort_unstable();
    Ok(result)
}

fn parse_element_with_step<T: TimeUnitField>(s: &str) -> Result<ParsedElement, CronParsingError> {
    use ParsedElement::*;
    if let Some(i) = s.find('/') {
        let element_without_step = parse_element::<T>(&s[0..i])?;
        let step = s[i + 1..].parse().map_err(|_| CronParsingError)?;
        match element_without_step {
            Star => Ok(StarWithStep { step }),
            Number(_) => Err(CronParsingError),
            Range { lower, upper } => Ok(RangeWithStep { lower, upper, step }),
            _ => panic!("parse_element returned an incorrect enum variant..."),
        }
    } else {
        parse_element::<T>(s)
    }
}

fn parse_element<T: TimeUnitField>(s: &str) -> Result<ParsedElement, CronParsingError> {
    use ParsedElement::*;

    if s == "*" {
        Ok(Star)
    } else if let Some(i) = s.find('-') {
        let lower = parse_ordinal::<T>(&s[0..i])?;
        let upper = parse_ordinal::<T>(&s[i + 1..])?;
        Ok(Range { lower, upper })
    } else {
        let number = parse_ordinal::<T>(s)?;
        Ok(Number(number))
    }
}

fn parse_ordinal<T: TimeUnitField>(s: &str) -> Result<Ordinal, CronParsingError> {
    if let Ok(ordinal) = s.parse() {
        Ok(ordinal)
    } else {
        T::ordinal_from_string(s)
    }
}

#[cfg(test)]
mod tests {
    use super::super::{Hours, Minutes, Months};
    use super::*;

    #[test]
    fn test_parse() -> Result<(), ScheduleError> {
        assert_eq!(parse_longhand::<Minutes>("3")?, vec![3]);
        assert_eq!(parse_longhand::<Minutes>("3-6/2")?, vec![3, 5]);
        assert_eq!(parse_longhand::<Months>("*/3")?, vec![1, 4, 7, 10]);
        assert_eq!(
            parse_longhand::<Hours>("*/3,2,7,2-5/3")?,
            vec![0, 2, 3, 5, 6, 7, 9, 12, 15, 18, 21]
        );
        assert!(parse_longhand::<Minutes>(",").is_err());
        Ok(())
    }
}