splashboard 1.1.1

A customizable terminal splash screen with plugin-based data sources
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

//! `clock_state` — temporal boolean states (business-hours / weekend / night) as `Shape::Badge`.
//! `Ok` when active, `Warn` when not.

use chrono::{DateTime, Datelike, FixedOffset, Timelike, Weekday};
use serde::Deserialize;

use crate::fetcher::{FetchContext, RealtimeFetcher, Safety};
use crate::payload::{BadgeData, Body, Payload, Status};
use crate::render::Shape;
use crate::samples;

use super::common;

const SHAPES: &[Shape] = &[Shape::Badge];

pub struct ClockStateFetcher;

#[derive(Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Options {
    #[serde(default)]
    pub timezone: Option<String>,
    #[serde(default)]
    pub kind: Option<Kind>,
}

#[derive(Debug, Clone, Copy, Default, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Kind {
    #[default]
    BusinessHours,
    Weekend,
    Night,
}

impl RealtimeFetcher for ClockStateFetcher {
    fn name(&self) -> &str {
        "clock_state"
    }
    fn safety(&self) -> Safety {
        Safety::Safe
    }
    fn description(&self) -> &'static str {
        "Whether the current moment falls inside a named temporal window (business hours, weekend, night), rendered as a status badge that flips between `Ok` and `Warn`. Pick `kind` to choose which window."
    }
    fn shapes(&self) -> &[Shape] {
        SHAPES
    }
    fn sample_body(&self, shape: Shape) -> Option<Body> {
        match shape {
            Shape::Badge => Some(samples::badge(Status::Ok, "open")),
            _ => None,
        }
    }
    fn compute(&self, ctx: &FetchContext) -> Payload {
        let opts: Options = match common::parse_options(ctx.options.as_ref()) {
            Ok(o) => o,
            Err(msg) => return common::placeholder(&msg),
        };
        let now = common::now_in(opts.timezone.as_deref());
        let (active, label) = match opts.kind.unwrap_or(Kind::BusinessHours) {
            Kind::BusinessHours => business_hours(&now),
            Kind::Weekend => weekend(&now),
            Kind::Night => night(&now),
        };
        Payload {
            icon: None,
            status: None,
            format: None,
            body: Body::Badge(BadgeData {
                status: if active { Status::Ok } else { Status::Warn },
                label: label.into(),
            }),
        }
    }
}

fn business_hours(now: &DateTime<FixedOffset>) -> (bool, &'static str) {
    let weekday = !matches!(now.weekday(), Weekday::Sat | Weekday::Sun);
    let in_hours = (9..17).contains(&now.hour());
    let active = weekday && in_hours;
    (active, if active { "open" } else { "closed" })
}

fn weekend(now: &DateTime<FixedOffset>) -> (bool, &'static str) {
    let active = matches!(now.weekday(), Weekday::Sat | Weekday::Sun);
    (active, if active { "weekend" } else { "weekday" })
}

fn night(now: &DateTime<FixedOffset>) -> (bool, &'static str) {
    let active = !(6..22).contains(&now.hour());
    (active, if active { "night" } else { "day" })
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use chrono::{TimeZone, Utc};

    use super::*;

    fn at(y: i32, mo: u32, d: u32, h: u32) -> DateTime<FixedOffset> {
        Utc.with_ymd_and_hms(y, mo, d, h, 0, 0)
            .unwrap()
            .fixed_offset()
    }

    fn ctx(options: &str) -> FetchContext {
        FetchContext {
            widget_id: "s".into(),
            timeout: Duration::from_secs(1),
            shape: Some(Shape::Badge),
            options: Some(toml::from_str(options).unwrap()),
            ..Default::default()
        }
    }

    #[test]
    fn business_hours_active_on_weekday_afternoon() {
        // 2026-04-22 is a Wednesday.
        assert!(business_hours(&at(2026, 4, 22, 14)).0);
    }

    #[test]
    fn weekend_active_on_sunday() {
        assert!(weekend(&at(2026, 4, 26, 12)).0);
    }

    #[test]
    fn night_active_at_23h() {
        assert!(night(&at(2026, 4, 22, 23)).0);
    }

    #[test]
    fn emits_badge_body() {
        let p = ClockStateFetcher.compute(&ctx(""));
        assert!(matches!(p.body, Body::Badge(_)));
    }
}