libmrot 0.1.1

Library for recording and planning meals
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

//! Functions to convert between various formats of dates.

use crate::{Error, Result};
use chrono::{DateTime, Days, NaiveDate, NaiveDateTime, TimeDelta};
use tracing::{instrument, Span};

/// Parses a given string into a vector of naive dates.
/// Implicit or explicit time ranges (see two_timer's [literal range](https://docs.rs/two_timer/latest/two_timer/)) may result in multiple dates,
/// if the range is longer than one full day.
/// See the [parse date feature file](https://github.com/fleetingbytes/mrot/tree/master/crates/libmrot/tests/features/parse_date.feature)
/// for detailed examples.
///
/// The result is guaranteed to contain at least one [`NaiveDate`].
///
/// Example:
/// ```
/// use libmrot::parse_date;
/// use chrono::NaiveDate;
///
/// let date: NaiveDate = parse_date("April 6th, 2025").unwrap().pop().unwrap();
/// let expected_date = NaiveDate::from_ymd_opt(2025, 4, 6).unwrap();
///
/// assert_eq!(date, expected_date);
///
/// let dates = parse_date("one day before and after March 1st, 2024").unwrap();
/// let expected_dates = vec![
///     NaiveDate::from_ymd_opt(2024, 2, 29).unwrap(),
///     NaiveDate::from_ymd_opt(2024, 3, 1).unwrap(),
///     NaiveDate::from_ymd_opt(2024, 3, 2).unwrap(),
/// ];
///
/// assert_eq!(dates, expected_dates);
/// ```
///
/// Error:
///
/// Returns an error if the date cannot be parsed.
/// ```
/// use libmrot::{parse_date, Error};
///
/// let error_result = parse_date("Christmas Eve 2025").unwrap_err();
/// assert!(matches!(error_result, Error::TwoTimer(_)));
/// ```
#[instrument]
pub fn parse_date(date: &str) -> Result<Vec<NaiveDate>> {
    let (start_datetime, end_datetime, range_is_explicit) = two_timer::parse(date, None)?;
    let mut result = Vec::new();

    add_date(start_datetime, &mut result);
    let (number_of_full_days, rest) = get_full_days_and_rest(start_datetime, end_datetime);
    add_end_dates_of_fully_included_day_periods(&mut result, start_datetime, number_of_full_days);
    if rest.is_zero()
        && ((range_is_explicit && number_of_full_days > 0)
            || (!range_is_explicit && number_of_full_days == 1))
    {
        remove_last_date(&mut result);
    }
    Ok(result)
}

#[instrument]
fn add_date(datetime: NaiveDateTime, vec: &mut Vec<NaiveDate>) {
    let date = datetime.date();
    vec.push(date);
}

#[instrument]
fn get_full_days_and_rest(start: NaiveDateTime, end: NaiveDateTime) -> (u64, TimeDelta) {
    let timedelta = end - start;
    let number_of_full_days = timedelta.num_days() as u64;
    let offset_start = start
        .checked_add_days(Days::new(number_of_full_days))
        .unwrap();
    let rest = end - offset_start;
    (number_of_full_days, rest)
}

#[instrument]
fn add_end_dates_of_fully_included_day_periods(
    vec: &mut Vec<NaiveDate>,
    start: NaiveDateTime,
    number_of_fully_included_days: u64,
) {
    for n in 1..number_of_fully_included_days + 1 {
        let datetime = generate_date_offset_by_n_days(start, n);
        add_date(datetime, vec);
    }
}

#[instrument]
fn generate_date_offset_by_n_days(start: NaiveDateTime, n: u64) -> NaiveDateTime {
    let n_days = Days::new(n);
    start.checked_add_days(n_days).unwrap()
}

#[instrument]
fn remove_last_date(vec: &mut Vec<NaiveDate>) {
    _ = vec.pop();
}

/// Convert multiple human-readable date strings to timestamps. The result vector is guaranteed to contain
/// at least one timestamp per string in the input vector.
///
/// Example:
/// ```
/// use libmrot::convert_to_timestamps;
///
/// let timestamps = convert_to_timestamps(
///     &vec![
///         "April 6th, 2025".to_string(),
///         "one day before and after March 1st, 2024".to_string(),
///     ]
/// ).unwrap();
/// let expected_timestamps = vec![
///     1743897600,
///     1709164800,
///     1709251200,
///     1709337600,
/// ];
///
/// assert_eq!(timestamps, expected_timestamps);
/// ```
///
/// Error:
///
/// Returns an error if a date cannot be parsed.
/// ```
/// use libmrot::{convert_to_timestamps, Error};
///
/// let error_result = convert_to_timestamps(
///     &vec!["Christmas Eve 2025".to_string()]
/// ).unwrap_err();
/// assert!(matches!(error_result, Error::TwoTimer(_)));
/// ```
#[instrument]
pub fn convert_to_timestamps(dates: &Vec<String>) -> Result<Vec<i64>> {
    dates
        .iter()
        .map(|date| {
            parse_date(date).map(|naive_dates| {
                naive_dates
                    .iter()
                    .map(|naive_date| convert_date_to_timestamp(naive_date))
                    .collect::<Vec<i64>>()
            })
        })
        .collect::<Result<Vec<Vec<i64>>>>()
        .map(|nested| nested.into_iter().flatten().collect())
}

/// Converts a NaiveDate to Unix timestamp
#[instrument(level = "debug", fields(result))]
pub(crate) fn convert_date_to_timestamp(date: &NaiveDate) -> i64 {
    let timestamp = date
        .and_hms_opt(0, 0, 0)
        .expect("invalid hour, minute, or second")
        .and_utc()
        .timestamp();
    Span::current().record("result", &timestamp);
    timestamp
}

pub(crate) fn convert_to_naive_date(i: i64) -> Result<NaiveDate> {
    let dt = DateTime::from_timestamp(i, 0).ok_or(Error::InvalidTimestamp(i))?;
    Ok(dt.date_naive())
}