holdon 0.4.0

Wait for anything. Know why if it doesn't.
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

#[cfg(feature = "json-output")]
pub(crate) mod json;
mod plain;
mod style;
mod theme;

use std::time::Duration;

use holdon::Target;
use holdon::runner::{Event, Report};

pub(crate) use plain::Plain;

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(crate) enum Format {
    #[default]
    Plain,
    Quiet,
    #[cfg(feature = "json-output")]
    Json,
}

#[derive(Debug)]
pub(crate) enum Printer {
    Plain(Plain),
    Quiet,
    #[cfg(feature = "json-output")]
    Json(json::Json),
}

impl Printer {
    #[cfg(feature = "json-output")]
    pub(crate) const fn is_json(&self) -> bool {
        matches!(self, Self::Json(_))
    }

    pub(crate) fn new(format: Format, color: bool) -> Self {
        match format {
            Format::Plain => Self::Plain(Plain::new(color)),
            Format::Quiet => Self::Quiet,
            #[cfg(feature = "json-output")]
            Format::Json => Self::Json(json::Json::new()),
        }
    }

    pub(crate) fn banner(
        &mut self,
        targets: &[Target],
        names: &[Option<String>],
        exec: Option<&[String]>,
    ) {
        match self {
            Self::Plain(p) => p.banner(targets, names, exec),
            Self::Quiet => {
                let _ = names;
            }
            #[cfg(feature = "json-output")]
            Self::Json(j) => j.banner(targets, names),
        }
    }

    #[allow(clippy::missing_const_for_fn)]
    pub(crate) fn handle(&mut self, ev: &Event) {
        match self {
            Self::Plain(p) => p.handle(ev),
            Self::Quiet => {
                let _ = ev;
            }
            #[cfg(feature = "json-output")]
            Self::Json(j) => j.event(ev),
        }
    }

    pub(crate) fn tick(&mut self) {
        if let Self::Plain(p) = self {
            p.tick();
        }
    }

    pub(crate) const fn tick_interval(&self) -> Duration {
        match self {
            Self::Plain(_) => Plain::tick_interval(),
            Self::Quiet => Duration::from_secs(3600),
            #[cfg(feature = "json-output")]
            Self::Json(_) => Duration::from_secs(3600),
        }
    }

    pub(crate) fn summary(&mut self, report: &Report, exec: Option<&[String]>) {
        match self {
            Self::Plain(p) => p.summary(report, exec),
            Self::Quiet => {}
            #[cfg(feature = "json-output")]
            Self::Json(j) => j.summary(report),
        }
    }
}