compact-calendar-cli 0.2.0

A compact calendar CLI with TOML-based date details
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

use crate::models::{DateDetail, DateRange};
use chrono::NaiveDate;
use serde::Deserialize;
use std::collections::HashMap;

#[derive(Debug, Deserialize)]
pub struct CalendarConfig {
    #[serde(default)]
    pub dates: HashMap<String, RawDateDetail>,
    #[serde(default)]
    pub ranges: Vec<RawDateRange>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct RawDateDetail {
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub color: Option<String>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct RawDateRange {
    pub start: String,
    pub end: String,
    pub color: String,
    #[serde(default)]
    pub description: Option<String>,
}

impl CalendarConfig {
    pub fn parse_dates(&self) -> HashMap<NaiveDate, DateDetail> {
        self.dates
            .iter()
            .filter_map(|(date_str, detail)| {
                NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
                    .ok()
                    .map(|date| {
                        (
                            date,
                            DateDetail {
                                description: detail.description.clone(),
                                color: detail.color.clone(),
                            },
                        )
                    })
            })
            .collect()
    }

    pub fn parse_dates_for_year(&self, year: i32) -> HashMap<NaiveDate, DateDetail> {
        self.dates
            .iter()
            .flat_map(|(date_str, detail)| {
                if let Ok(date) = NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
                    return vec![(
                        date,
                        DateDetail {
                            description: detail.description.clone(),
                            color: detail.color.clone(),
                        },
                    )];
                }
                if let Ok(md) =
                    chrono::NaiveDate::parse_from_str(&format!("{}-{}", year, date_str), "%Y-%m-%d")
                {
                    return vec![(
                        md,
                        DateDetail {
                            description: detail.description.clone(),
                            color: detail.color.clone(),
                        },
                    )];
                }

                vec![]
            })
            .collect()
    }

    pub fn parse_ranges(&self) -> Vec<DateRange> {
        self.ranges
            .iter()
            .filter_map(|range| {
                let start = NaiveDate::parse_from_str(&range.start, "%Y-%m-%d").ok()?;
                let end = NaiveDate::parse_from_str(&range.end, "%Y-%m-%d").ok()?;
                Some(DateRange {
                    start,
                    end,
                    color: range.color.clone(),
                    description: range.description.clone(),
                })
            })
            .collect()
    }

    pub fn parse_ranges_for_year(&self, year: i32) -> Vec<DateRange> {
        self.ranges
            .iter()
            .filter_map(|range| {
                if let (Ok(start), Ok(end)) = (
                    NaiveDate::parse_from_str(&range.start, "%Y-%m-%d"),
                    NaiveDate::parse_from_str(&range.end, "%Y-%m-%d"),
                ) {
                    return Some(DateRange {
                        start,
                        end,
                        color: range.color.clone(),
                        description: range.description.clone(),
                    });
                }
                if let (Ok(start), Ok(end)) = (
                    NaiveDate::parse_from_str(&format!("{}-{}", year, &range.start), "%Y-%m-%d"),
                    NaiveDate::parse_from_str(&format!("{}-{}", year, &range.end), "%Y-%m-%d"),
                ) {
                    return Some(DateRange {
                        start,
                        end,
                        color: range.color.clone(),
                        description: range.description.clone(),
                    });
                }

                None
            })
            .collect()
    }
}