muninn_query 0.5.0

Query langugage for muninn logging stack
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
172
173
174
175
176

use crate::{
  ast::Value,
  parser::{
    error::Error,
    utils::{IResult, LocatedSpan, ToRange},
  },
};
use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Timelike};
use nom::{
  branch::alt,
  character::complete::{char, digit1, one_of},
  combinator::{map, map_res, opt, recognize, value},
  sequence::tuple,
};

pub(crate) fn date_time(i: LocatedSpan) -> IResult<Value> {
  map(
    tuple((date, char('T'), time, opt(timezone))),
    |(date, _, time, timezone)| match timezone {
      Some(tz) => Value::DateTime(DateTime::from_utc(NaiveDateTime::new(date, time) - tz, tz)),
      None => Value::NaiveDateTime(NaiveDateTime::new(date, time)),
    },
  )(i)
}

pub(crate) fn date_value(i: LocatedSpan) -> IResult<Value> {
  map(date, Value::Date)(i)
}

fn date(i: LocatedSpan) -> IResult<NaiveDate> {
  map_res(
    recognize(tuple((year, char('-'), month, char('-'), day))),
    |res| {
      NaiveDate::parse_from_str(*res, "%Y-%m-%d").map_err(|err| {
        res
          .extra
          .report_error(Error(res.to_range(), "Invalid date".to_string()));
        err
      })
    },
  )(i)
}

fn time(i: LocatedSpan) -> IResult<NaiveTime> {
  alt((
    time_subsecond_precision,
    time_second_precision,
    time_minute_precision,
  ))(i)
}
fn time_subsecond_precision(i: LocatedSpan) -> IResult<NaiveTime> {
  map_res(
    recognize(tuple((
      hour,
      char(':'),
      minute,
      char(':'),
      second,
      char('.'),
      digit1,
    ))),
    |res| {
      NaiveTime::parse_from_str(*res, "%H:%M:%S%.f").map_err(|err| {
        res
          .extra
          .report_error(Error(res.to_range(), "Invalid time".to_string()));
        err
      })
    },
  )(i)
}
fn time_second_precision(i: LocatedSpan) -> IResult<NaiveTime> {
  map_res(
    recognize(tuple((hour, char(':'), minute, char(':'), second))),
    |res| {
      NaiveTime::parse_from_str(*res, "%H:%M:%S").map_err(|err| {
        res
          .extra
          .report_error(Error(res.to_range(), "Invalid time".to_string()));
        err
      })
    },
  )(i)
}
fn time_minute_precision(i: LocatedSpan) -> IResult<NaiveTime> {
  map_res(recognize(tuple((hour, char(':'), minute))), |res| {
    NaiveTime::parse_from_str(*res, "%H:%M").map_err(|err| {
      res
        .extra
        .report_error(Error(res.to_range(), "Invalid time".to_string()));
      err
    })
  })(i)
}

fn year(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(tuple((dec_digit, dec_digit, dec_digit, dec_digit)))(i)
}
fn month(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(alt((
    tuple((char('1'), one_of("012"))),
    tuple((char('0'), dec_digit)),
  )))(i)
}
fn day(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(alt((
    tuple((char('3'), one_of("01"))),
    tuple((one_of("012"), dec_digit)),
  )))(i)
}
fn hour(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(alt((
    tuple((char('2'), one_of("0123"))),
    tuple((one_of("01"), dec_digit)),
  )))(i)
}
fn minute(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(tuple((one_of("012345"), dec_digit)))(i)
}
fn second(i: LocatedSpan) -> IResult<LocatedSpan> {
  recognize(alt((
    tuple((char('6'), char('0'))),
    tuple((one_of("012345"), dec_digit)),
  )))(i)
}

fn dec_digit(i: LocatedSpan) -> IResult<char> {
  one_of("0123456789")(i)
}

fn timezone(i: LocatedSpan) -> IResult<FixedOffset> {
  alt((timezone_utc, timezone_offset))(i)
}
fn timezone_utc(i: LocatedSpan) -> IResult<FixedOffset> {
  value(FixedOffset::east(0), char('Z'))(i)
}
fn timezone_offset(i: LocatedSpan) -> IResult<FixedOffset> {
  map_res(
    tuple((
      one_of("+-"),
      // TODO: Optional : in timezone
      // recognize(tuple((hour, opt(char(':')), minute))),
      time_minute_precision,
    )),
    |(sign, offset)| match sign {
      '+' => Ok(FixedOffset::east(offset.num_seconds_from_midnight() as i32)),
      '-' => Ok(FixedOffset::west(offset.num_seconds_from_midnight() as i32)),
      _ => Err("Invalid sign"),
    },
  )(i)
}

#[cfg(test)]
mod tests {
  use crate::parser::{
    absolute_time::date,
    utils::{span, unwrap_span},
  };
  use chrono::NaiveDate;

  #[test]

  fn test_date() {
    assert_eq!(
      date(span("2020-01-01")).map(unwrap_span),
      Ok(("", NaiveDate::from_ymd(2020, 01, 01)))
    );

    assert_eq!(
      date(span("2024-02-29")).map(unwrap_span),
      Ok(("", NaiveDate::from_ymd(2024, 02, 29)))
    );

    assert!(date(span("2023-02-29")).is_err());
  }
}