use-weekday 0.0.1

Primitive weekday helpers
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

#![forbid(unsafe_code)]
//! Primitive weekday helpers.
//!
//! The helpers here compute weekdays deterministically from Gregorian dates.
//!
//! # Examples
//!
//! ```rust
//! use use_weekday::{Weekday, is_weekend, weekday_for_date};
//!
//! let weekday = weekday_for_date(2024, 5, 17).unwrap();
//!
//! assert_eq!(weekday, Weekday::Friday);
//! assert_eq!(weekday.number_from_monday(), 5);
//! assert!(!is_weekend(weekday));
//! ```

use use_date::{days_between, CalendarDate};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Weekday {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WeekdayError {
    InvalidDate,
}

impl Weekday {
    #[must_use]
    pub fn number_from_monday(&self) -> u8 {
        match self {
            Self::Monday => 1,
            Self::Tuesday => 2,
            Self::Wednesday => 3,
            Self::Thursday => 4,
            Self::Friday => 5,
            Self::Saturday => 6,
            Self::Sunday => 7,
        }
    }

    #[must_use]
    pub fn number_from_sunday(&self) -> u8 {
        match self {
            Self::Sunday => 1,
            Self::Monday => 2,
            Self::Tuesday => 3,
            Self::Wednesday => 4,
            Self::Thursday => 5,
            Self::Friday => 6,
            Self::Saturday => 7,
        }
    }

    #[must_use]
    pub fn is_weekend(&self) -> bool {
        matches!(self, Self::Saturday | Self::Sunday)
    }

    #[must_use]
    pub fn is_weekday(&self) -> bool {
        !self.is_weekend()
    }
}

pub fn weekday_for_date(year: i32, month: u8, day: u8) -> Result<Weekday, WeekdayError> {
    let epoch = CalendarDate::new(1970, 1, 1).unwrap();
    let date = CalendarDate::new(year, month, day).map_err(|_| WeekdayError::InvalidDate)?;
    let offset = days_between(epoch, date).rem_euclid(7);

    Ok(match offset {
        0 => Weekday::Thursday,
        1 => Weekday::Friday,
        2 => Weekday::Saturday,
        3 => Weekday::Sunday,
        4 => Weekday::Monday,
        5 => Weekday::Tuesday,
        _ => Weekday::Wednesday,
    })
}

#[must_use]
pub fn is_weekend(weekday: Weekday) -> bool {
    weekday.is_weekend()
}

#[must_use]
pub fn is_weekday(weekday: Weekday) -> bool {
    weekday.is_weekday()
}

#[cfg(test)]
mod tests {
    use super::{is_weekday, is_weekend, weekday_for_date, Weekday, WeekdayError};

    #[test]
    fn calculates_known_weekdays() {
        assert_eq!(weekday_for_date(1970, 1, 1).unwrap(), Weekday::Thursday);
        assert_eq!(weekday_for_date(2024, 2, 29).unwrap(), Weekday::Thursday);
        assert_eq!(weekday_for_date(2024, 5, 17).unwrap(), Weekday::Friday);
    }

    #[test]
    fn checks_weekend_helpers() {
        assert_eq!(Weekday::Monday.number_from_monday(), 1);
        assert_eq!(Weekday::Sunday.number_from_sunday(), 1);
        assert!(Weekday::Saturday.is_weekend());
        assert!(Weekday::Tuesday.is_weekday());
        assert!(is_weekday(Weekday::Friday));
        assert!(is_weekend(Weekday::Sunday));
    }

    #[test]
    fn rejects_invalid_weekday_dates() {
        assert_eq!(
            weekday_for_date(2024, 2, 30),
            Err(WeekdayError::InvalidDate)
        );
    }
}