runic 1.1.0

Stupid string to duration converter
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

use crate::at::At;
use crate::c::{DAY, HOUR_F64, MINUTE_F64};
use crate::parser::{PestRule as Rule, ScriptParser};
use crate::script_timezone::ScriptTimezone;
use anyhow::Result;
use chrono::{FixedOffset, TimeZone, Timelike};
use pest::{iterators::Pair, Parser};

pub struct Describe {
    utc: i64,
    offset: i32,
}

impl Describe {
    pub fn with(script: &str, timestamp: i64, offset: i32) -> Result<u64> {
        let cx = Self {
            utc: timestamp,
            offset,
        };

        let mut duration_total = 0;
        let mut at_total = 0;
        let parsed = ScriptParser::parse(Rule::Input, script)?;

        for expr in parsed {
            match expr.as_rule() {
                Rule::AtTimeExpr => {
                    let at = At::parse(expr)?;
                    at_total += cx.compute_duration_from_target_expr(at);
                }
                Rule::DurationExpr => {
                    duration_total += Self::compute_duration_from_timeout_expr(expr);
                }
                _ => {}
            }
        }

        let total = {
            let total = at_total + duration_total;

            if total.is_negative() {
                0
            } else {
                total
            }
        };

        Ok(total as _)
    }

    fn compute_duration_from_target_expr(&self, at: At) -> i64 {
        let target = {
            let offset = match at.script_timezone {
                ScriptTimezone::Mirror => FixedOffset::east(self.offset),
                ScriptTimezone::Custom(script_offset) => FixedOffset::east(script_offset),
            };

            let target = offset.timestamp(self.utc, 0);
            let target = target.with_hour(at.hours).unwrap();
            let target = target.with_minute(at.minutes).unwrap();
            let target = target.with_second(0).unwrap();
            let target = target.with_nanosecond(0).unwrap();

            target.timestamp()
        };

        let duration = target - self.utc;

        if duration.is_negative() {
            DAY + duration
        } else {
            duration
        }
    }

    fn compute_duration_from_timeout_expr(expr: Pair<Rule>) -> i64 {
        let mut needle: f64 = 0.0;

        for prop in expr.into_inner() {
            match prop.as_rule() {
                Rule::Duration => {
                    needle = prop.as_str().parse().unwrap();
                }
                Rule::Hours => {
                    return (needle * HOUR_F64) as _;
                }
                Rule::Minutes => {
                    return (needle * MINUTE_F64) as _;
                }
                Rule::Seconds => {
                    return needle as _;
                }
                _ => {}
            }
        }

        unreachable!()
    }
}