millisecond 0.8.2

Format milliseconds into a human-readable and relative timestamp formats. This package has no-std dependency.
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

use crate::weekday::duration::Weekday::{
    Friday, Monday, Saturday, Sunday, Thursday, Tuesday, Wednesday,
};
use crate::weekday::formatter::WeekdayConversion;
use core::fmt::{Display, Formatter};
use core::time::Duration;

impl WeekdayConversion for Duration {
    fn weekday(&self) -> Weekday {
        Weekday::from(*self)
    }
}

/// A Strongly Typed definition for day of week
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Weekday {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
}

impl Weekday {
    pub fn to_str(&self) -> &'static str {
        match self {
            Sunday => "Sunday",
            Monday => "Monday",
            Tuesday => "Tuesday",
            Wednesday => "Wednesday",
            Thursday => "Thursday",
            Friday => "Friday",
            Saturday => "Saturday",
        }
    }
}

impl Display for Weekday {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.to_str())
    }
}

impl From<Weekday> for u8 {
    fn from(value: Weekday) -> Self {
        match value {
            Sunday => 0,
            Monday => 1,
            Tuesday => 2,
            Wednesday => 3,
            Thursday => 4,
            Friday => 5,
            Saturday => 6,
        }
    }
}

impl From<Duration> for Weekday {
    /// Converts a duration into corresponding weekday.
    ///
    /// ## Note
    /// This function assumes the duration is from Linux Epoch, which starts at (Thursday, January 1, 1970)
    ///
    /// ### Link
    /// I've posted it on [StackOverflow](https://stackoverflow.com/questions/66181608/how-can-i-get-the-current-weekday-in-rust-using-the-chrono-crate/79461838#79461838)
    fn from(value: Duration) -> Self {
        match (value.as_secs() / 86400) % 7 {
            0 => Thursday, // zero is Thursday
            1 => Friday,
            2 => Saturday,
            3 => Sunday,
            4 => Monday,
            5 => Tuesday,
            6 => Wednesday,
            _ => panic!("Invalid duration - never happens"),
        }
    }
}

/// Duration parsing errors
pub enum DurationError {
    /// The is not a valid week day
    InvalidConversion,
}

impl TryFrom<u8> for Weekday {
    type Error = DurationError;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Sunday),
            1 => Ok(Monday),
            2 => Ok(Tuesday),
            3 => Ok(Wednesday),
            4 => Ok(Thursday),
            5 => Ok(Friday),
            6 => Ok(Saturday),
            _ => Err(DurationError::InvalidConversion),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloc::format;
    use alloc::string::ToString;
    use core::time::Duration;

    #[test]
    fn should_convert_to_epoch() {
        let dur: Weekday = Duration::from_secs(0).into();
        assert_eq!(dur.to_str(), "Thursday");
    }

    #[test]
    fn should_convert_to_string() {
        let dur: Weekday = Duration::from_secs(0).into();
        assert_eq!(dur.to_string(), "Thursday");
        assert_eq!(format!("{dur}"), "Thursday");
    }

    #[test]
    fn should_convert_duration_to_weekday() {
        let dur = Duration::from_secs(0);
        assert_eq!(dur.weekday().to_str(), "Thursday");
        assert_eq!(dur.weekday_str(), "Thursday");
    }

    #[test]
    fn should_convert_to_weekday() {
        let dur: Weekday = Duration::from_secs(0).into();
        assert_eq!(dur.to_str(), "Thursday");
        let dur: Weekday = Duration::from_secs(24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Friday");
        let dur: Weekday = Duration::from_secs(2 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Saturday");
        let dur: Weekday = Duration::from_secs(3 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Sunday");
        let dur: Weekday = Duration::from_secs(4 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Monday");
        let dur: Weekday = Duration::from_secs(5 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Tuesday");
        let dur: Weekday = Duration::from_secs(6 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Wednesday");
        let dur: Weekday = Duration::from_secs(7 * 24 * 60 * 60).into();
        assert_eq!(dur.to_str(), "Thursday");
    }
}