vergen-pretty 10.0.0

Output vergen information in a formatted manner
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

// Copyright (c) 2022 vergen developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.

#[cfg(feature = "serde")]
use ::serde::{Deserialize, Serialize};
#[cfg(any(feature = "serde", feature = "rkyv"))]
use {
    crate::{Prefix, Pretty, Suffix},
    bon::Builder,
};

#[cfg(feature = "color")]
pub(crate) mod color;
#[cfg(all(feature = "rkyv", any(feature = "color", feature = "trace")))]
pub(crate) mod rkyv_support;
#[cfg(feature = "serde")]
pub(crate) mod serde;
#[cfg(feature = "trace")]
pub(crate) mod trace;

#[cfg(any(feature = "serde", feature = "rkyv"))]
/// Extension of `Pretty` to support serialization
#[derive(Builder, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
#[cfg_attr(
    feature = "rkyv",
    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
)]
pub struct PrettyExt {
    /// Environment variables from `vergen`
    vars: Vec<(String, String, String)>,
    /// Optional prefix to print before the variables
    prefix: Option<Prefix>,
    /// Optional suffix to print after the variables
    suffix: Option<Suffix>,
}

#[cfg(any(feature = "serde", feature = "rkyv"))]
impl PrettyExt {
    /// Get the environment variables
    #[must_use]
    pub fn vars(&self) -> &Vec<(String, String, String)> {
        &self.vars
    }

    /// Get the optional prefix
    #[must_use]
    pub fn prefix(&self) -> Option<&Prefix> {
        self.prefix.as_ref()
    }

    /// Get the optional suffix
    #[must_use]
    pub fn suffix(&self) -> Option<&Suffix> {
        self.suffix.as_ref()
    }
}

#[cfg(any(feature = "serde", feature = "rkyv"))]
impl From<Pretty> for PrettyExt {
    fn from(pretty: Pretty) -> Self {
        let mut pretty_c = pretty.clone();
        pretty_c.populate_fmt();
        PrettyExt::builder()
            .vars(
                pretty_c
                    .vars
                    .iter()
                    .map(|v| (v.0.clone(), v.1.clone(), v.2.clone()))
                    .collect(),
            )
            .maybe_prefix(pretty_c.prefix)
            .maybe_suffix(pretty_c.suffix)
            .build()
    }
}

#[cfg(all(test, feature = "serde"))]
mod test_serde {
    use crate::{
        Prefix, Pretty, PrettyExt, Suffix, utils::test_utils::TEST_PREFIX_SUFFIX, vergen_pretty_env,
    };
    use anyhow::Result;

    const VARS: &str = r#"vars":"#;
    const PREFIX: &str = r#""prefix":{"lines":["#;
    const SUFFIX: &str = r#""suffix":{"lines":["#;

    #[test]
    fn pretty_serde_works() -> Result<()> {
        let pretty = Pretty::builder().env(vergen_pretty_env!()).build();
        let pretty_ext = PrettyExt::from(pretty);
        let val = serde_json::to_string(&pretty_ext)?;
        assert!(val.contains(VARS));
        Ok(())
    }

    #[test]
    fn pretty_encode_decode_with_prefix_suffix_works() -> Result<()> {
        let prefix = Prefix::builder()
            .lines(TEST_PREFIX_SUFFIX.lines().map(str::to_string).collect())
            .build();
        let suffix = Suffix::builder()
            .lines(TEST_PREFIX_SUFFIX.lines().map(str::to_string).collect())
            .build();
        let pretty = Pretty::builder()
            .env(vergen_pretty_env!())
            .prefix(prefix)
            .suffix(suffix)
            .build();
        let pretty_ext = PrettyExt::from(pretty);
        let val = serde_json::to_string(&pretty_ext)?;
        assert!(val.contains(VARS));
        assert!(val.contains(PREFIX));
        assert!(val.contains(SUFFIX));
        Ok(())
    }
}