rwf 0.2.1

Framework for building web applications in the Rust programming language
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

//! Implements the UNIX cron syntax.
use super::Error;
use std::ops::Range;
use time::OffsetDateTime;

#[derive(Clone, Debug)]
enum CronValue {
    Exact(i64),
    Every(i64),
    Range(Range<i64>),
    Any,
}

impl CronValue {
    /// Parse a cron syntax.
    fn parse(value: &str) -> Result<Self, Error> {
        match value.parse::<i64>() {
            Ok(value) => Ok(CronValue::Exact(value)),
            Err(_) => {
                if value.starts_with("*/") {
                    match value.replace("*/", "").parse() {
                        Ok(value) => Ok(CronValue::Every(value)),
                        Err(_) => Err(Error::CronValueError),
                    }
                } else if value.contains("-") {
                    let range_parts = value.split("-").collect::<Vec<_>>();
                    if range_parts.len() != 2 {
                        return Err(Error::CronValueError);
                    }

                    let start = if let Ok(value) = range_parts[0].parse::<i64>() {
                        value
                    } else {
                        return Err(Error::CronValueError);
                    };

                    let end = if let Ok(value) = range_parts[1].parse::<i64>() {
                        value
                    } else {
                        return Err(Error::CronValueError);
                    };

                    Ok(CronValue::Range(Range { start, end }))
                } else if value == "*" {
                    Ok(CronValue::Any)
                } else {
                    Err(Error::CronValueError)
                }
            }
        }
    }

    /// Indicates the cron task should run at the specified time.
    pub fn matches(&self, time: i64) -> bool {
        match self {
            Self::Exact(value) => *value == time,
            Self::Every(value) => time % value == 0,
            Self::Range(value) => value.contains(&time),
            Self::Any => true,
        }
    }
}

/// UNIX cron syntax.
#[derive(Clone, Debug)]
pub struct Cron {
    second: CronValue,
    minute: CronValue,
    hour: CronValue,
    dom: CronValue,
    month: CronValue,
    dow: CronValue,
}

impl Cron {
    /// Parse the UNIX cron syntax.
    ///
    /// # Example
    ///
    /// ```
    /// # use rwf::job::Cron;
    /// let cron = Cron::parse("* * * * *").unwrap();
    /// ```
    pub fn parse(value: &str) -> Result<Self, Error> {
        let parts = value.split(" ").collect::<Vec<_>>();

        match parts.len() {
            // Second is specified
            6 => Ok(Self {
                second: CronValue::parse(parts[0])?,
                minute: CronValue::parse(parts[1])?,
                hour: CronValue::parse(parts[2])?,
                dom: CronValue::parse(parts[3])?,
                month: CronValue::parse(parts[4])?,
                dow: CronValue::parse(parts[5])?,
            }),

            // Second is omitted.
            5 => Ok(Self {
                second: CronValue::Exact(0),
                minute: CronValue::parse(parts[0])?,
                hour: CronValue::parse(parts[1])?,
                dom: CronValue::parse(parts[2])?,
                month: CronValue::parse(parts[3])?,
                dow: CronValue::parse(parts[4])?,
            }),

            _ => return Err(Error::CronValueError),
        }
    }

    /// Should the cron execute at the provided time?
    pub fn should_run(&self, time: &OffsetDateTime) -> bool {
        let second = time.second();
        let minute = time.minute();
        let hour = time.hour();
        let day = time.day();
        let month = time.month();
        let weekday = time.weekday().number_from_sunday();

        self.second.matches(second as i64)
            && self.minute.matches(minute as i64)
            && self.hour.matches(hour as i64)
            && self.dom.matches(day as i64)
            && self.month.matches(month as i64)
            && self.dow.matches(weekday as i64)
    }
}

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

    #[test]
    fn test_cron_parse() {
        let cron = Cron::parse("* * * * * *").unwrap();
        let time = OffsetDateTime::now_utc();

        // Will run on every tick of the clock.
        assert!(cron.should_run(&time));

        let cron = Cron::parse("*/5 * * * * *").unwrap();
        let will_run = time.replace_second(25).unwrap();
        assert!(cron.should_run(&will_run));

        let will_not = will_run.replace_second(7).unwrap();
        assert!(!cron.should_run(&will_not));

        let cron = Cron::parse("5 7-8 * * * *").unwrap();
        let will_run = will_not
            .replace_second(5)
            .unwrap()
            .replace_minute(7)
            .unwrap();

        assert!(cron.should_run(&will_run));

        let will_not = will_run
            .replace_second(25)
            .unwrap()
            .replace_minute(8)
            .unwrap();

        assert!(!cron.should_run(&will_not));

        let cron = Cron::parse("* * * * *").unwrap();
        let time = OffsetDateTime::now_utc().replace_second(0).unwrap();

        assert!(cron.should_run(&time));
    }
}