sem-cli 0.8.0

Semantic version control CLI. Shows what entities changed (functions, classes, methods) instead of lines.
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

use std::time::Instant;

pub struct Timings {
    command: &'static str,
    enabled: bool,
    json: bool,
    start: Instant,
    last: Instant,
    entries: Vec<TimingEntry>,
}

struct TimingEntry {
    name: &'static str,
    duration_ms: f64,
}

impl Timings {
    pub fn from_env(command: &'static str) -> Self {
        let value = std::env::var("SEM_TIMINGS").unwrap_or_default();
        let enabled = !matches!(value.as_str(), "" | "0" | "false" | "off");
        let now = Instant::now();
        Self {
            command,
            enabled,
            json: value == "json",
            start: now,
            last: now,
            entries: Vec::new(),
        }
    }

    pub fn disabled(command: &'static str) -> Self {
        let now = Instant::now();
        Self {
            command,
            enabled: false,
            json: false,
            start: now,
            last: now,
            entries: Vec::new(),
        }
    }

    pub fn mark(&mut self, name: &'static str) {
        if !self.enabled {
            return;
        }
        let now = Instant::now();
        self.entries.push(TimingEntry {
            name,
            duration_ms: elapsed_ms(now.duration_since(self.last)),
        });
        self.last = now;
    }

    pub fn finish(&self) {
        if !self.enabled {
            return;
        }
        let total_ms = elapsed_ms(self.start.elapsed());
        if self.json {
            let phases = self
                .entries
                .iter()
                .map(|entry| {
                    serde_json::json!({
                        "name": entry.name,
                        "durationMs": entry.duration_ms,
                    })
                })
                .collect::<Vec<_>>();
            let output = serde_json::json!({
                "command": self.command,
                "phases": phases,
                "totalMs": total_ms,
            });
            eprintln!("{}", serde_json::to_string(&output).unwrap());
        } else {
            eprintln!("sem timings ({})", self.command);
            for entry in &self.entries {
                eprintln!("  {:<32} {:>8.3} ms", entry.name, entry.duration_ms);
            }
            eprintln!("  {:<32} {:>8.3} ms", "total", total_ms);
        }
    }
}

fn elapsed_ms(duration: std::time::Duration) -> f64 {
    duration.as_secs_f64() * 1000.0
}