rattlebeaver 0.1.1

Manage rolling backups
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

use anyhow::{Context, Result};
use chrono::{DateTime, Datelike, Duration, Local, NaiveDateTime, Timelike};
use chronoutil::RelativeDuration;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Timestamp(pub DateTime<Local>);

impl AsRef<DateTime<Local>> for Timestamp {
    fn as_ref(&self) -> &DateTime<Local> {
        &self.0
    }
}

impl Timestamp {
    #[must_use]
    pub fn now() -> Self {
        Self(Local::now())
    }

    pub fn parse_from_str(s: &str, format: &str) -> Result<Self> {
        let timestamp = NaiveDateTime::parse_from_str(s, format)
            .context("invalid timestamp format")?
            .and_local_timezone(Local)
            .single()
            .context("failed to convert to local timezone")?;
        Ok(Self(timestamp))
    }

    #[must_use]
    pub fn shift(&self, range: Range, amount: i32) -> Self {
        let timestamp = match range {
            Range::Minute => self.0 + Duration::minutes(amount.into()),
            Range::Hour => self.0 + Duration::hours(amount.into()),
            Range::Day => self.0 + Duration::days(amount.into()),
            Range::Month => self.0 + RelativeDuration::months(amount),
            Range::Year => self.0 + RelativeDuration::years(amount),
        };
        Self(timestamp)
    }

    #[must_use]
    #[allow(clippy::missing_panics_doc)]
    pub fn floor(&self, range: Range) -> Self {
        let minute = self
            .0
            .with_second(0)
            .expect("second 0")
            .with_nanosecond(0)
            .expect("nanosecond 0");
        let hour = minute.with_minute(0).expect("minute 0");
        let day = hour.with_hour(0).expect("hour 0");
        let month = day.with_day(1).expect("day 1");
        let year = month.with_month(1).expect("month 1");
        match range {
            Range::Minute => Self(minute),
            Range::Hour => Self(hour),
            Range::Day => Self(day),
            Range::Month => Self(month),
            Range::Year => Self(year),
        }
    }

    #[must_use]
    pub fn humanized(&self) -> String {
        self.0.format("%Y-%m-%d %H:%M:%S").to_string()
    }
}

impl std::fmt::Display for Timestamp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0.format("%Y-%m-%d_%H-%M-%S"))
    }
}

#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, PartialOrd, Ord)]
pub enum Range {
    Minute = 1,
    Hour = 2,
    Day = 3,
    Month = 4,
    Year = 5,
}