cargo-semver-checks 0.40.0

Scan your Rust crate for semver violations.
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

use std::collections::BTreeMap;

use crate::GlobalConfig;

pub(crate) struct Callbacks<'a> {
    config: &'a mut GlobalConfig,

    // (crate_name, version, is_baseline) keys
    generate_starts: BTreeMap<(&'a str, &'a str, bool), std::time::Instant>,
    parse_starts: BTreeMap<(&'a str, &'a str, bool), std::time::Instant>,
}

impl<'a> Callbacks<'a> {
    pub(crate) fn new(config: &'a mut GlobalConfig) -> Self {
        Self {
            config,
            generate_starts: Default::default(),
            parse_starts: Default::default(),
        }
    }
}

impl<'a> crate::data_generation::ProgressCallbacks<'a> for Callbacks<'a> {
    fn generate_rustdoc_start(&mut self, crate_name: &'a str, version: &'a str, is_baseline: bool) {
        let kind = if is_baseline { "baseline" } else { "current" };

        // Ignore terminal printing failures.
        let _ = self.config.shell_status(
            "Building",
            format_args!("{crate_name} v{version} ({kind})",),
        );

        self.generate_starts.insert(
            (crate_name, version, is_baseline),
            std::time::Instant::now(),
        );
    }

    fn generate_rustdoc_success(
        &mut self,
        crate_name: &'a str,
        version: &'a str,
        is_baseline: bool,
    ) {
        let kind = if is_baseline { "baseline" } else { "current" };
        let start = self
            .generate_starts
            .remove(&(crate_name, version, is_baseline))
            .expect("success on generation task that never started");

        // Ignore terminal printing failures.
        let _ = self.config.shell_status(
            "Built",
            format_args!("[{:>8.3}s] ({kind})", start.elapsed().as_secs_f32()),
        );
    }

    fn parse_rustdoc_start(
        &mut self,
        cached: bool,
        crate_name: &'a str,
        version: &'a str,
        is_baseline: bool,
    ) {
        let kind = if is_baseline { "baseline" } else { "current" };
        let cached = if cached { ", cached" } else { "" };

        // Ignore terminal printing failures.
        let _ = self.config.shell_status(
            "Parsing",
            format_args!("{crate_name} v{version} ({kind}{cached})",),
        );

        self.parse_starts.insert(
            (crate_name, version, is_baseline),
            std::time::Instant::now(),
        );
    }

    fn parse_rustdoc_success(
        &mut self,
        _cached: bool,
        crate_name: &'a str,
        version: &'a str,
        is_baseline: bool,
    ) {
        let kind = if is_baseline { "baseline" } else { "current" };
        let start = self
            .parse_starts
            .remove(&(crate_name, version, is_baseline))
            .expect("success on parse task that never started");

        // Ignore terminal printing failures.
        let _ = self.config.shell_status(
            "Parsed",
            format_args!("[{:>8.3}s] ({kind})", start.elapsed().as_secs_f32()),
        );
    }

    fn non_fatal_error(
        &mut self,
        crate_name: &'a str,
        version: &'a str,
        is_baseline: bool,
        error: anyhow::Error,
    ) {
        let kind = if is_baseline { "baseline" } else { "current" };

        // Ignore terminal printing failures.
        let _ = self.config.log_info(|config| {
            config.shell_warn(format!(
                "encountered non-fatal error while working on crate \
                {crate_name} v{version} ({kind}): {error} (root cause: {})",
                error.root_cause()
            ))?;
            Ok(())
        });
    }
}