Skip to main content

vergen_pretty/pretty/feature/
mod.rs

1// Copyright (c) 2022 vergen developers
2//
3// Licensed under the Apache License, Version 2.0
4// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0> or the MIT
5// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
6// option. All files in the project carrying such notice may not be copied,
7// modified, or distributed except according to those terms.
8
9#[cfg(feature = "serde")]
10use ::serde::{Deserialize, Serialize};
11#[cfg(any(feature = "serde", feature = "rkyv"))]
12use {
13    crate::{Prefix, Pretty, Suffix},
14    bon::Builder,
15};
16
17#[cfg(feature = "color")]
18pub(crate) mod color;
19#[cfg(all(feature = "rkyv", any(feature = "color", feature = "trace")))]
20pub(crate) mod rkyv_support;
21#[cfg(feature = "serde")]
22pub(crate) mod serde;
23#[cfg(feature = "trace")]
24pub(crate) mod trace;
25
26#[cfg(any(feature = "serde", feature = "rkyv"))]
27/// Extension of `Pretty` to support serialization
28#[derive(Builder, Clone, Debug, PartialEq)]
29#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
30#[cfg_attr(
31    feature = "rkyv",
32    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
33)]
34pub struct PrettyExt {
35    /// Environment variables from `vergen`
36    vars: Vec<(String, String, String)>,
37    /// Optional prefix to print before the variables
38    prefix: Option<Prefix>,
39    /// Optional suffix to print after the variables
40    suffix: Option<Suffix>,
41}
42
43#[cfg(any(feature = "serde", feature = "rkyv"))]
44impl PrettyExt {
45    /// Get the environment variables
46    #[must_use]
47    pub fn vars(&self) -> &Vec<(String, String, String)> {
48        &self.vars
49    }
50
51    /// Get the optional prefix
52    #[must_use]
53    pub fn prefix(&self) -> Option<&Prefix> {
54        self.prefix.as_ref()
55    }
56
57    /// Get the optional suffix
58    #[must_use]
59    pub fn suffix(&self) -> Option<&Suffix> {
60        self.suffix.as_ref()
61    }
62}
63
64#[cfg(any(feature = "serde", feature = "rkyv"))]
65impl From<Pretty> for PrettyExt {
66    fn from(pretty: Pretty) -> Self {
67        let mut pretty_c = pretty.clone();
68        pretty_c.populate_fmt();
69        PrettyExt::builder()
70            .vars(
71                pretty_c
72                    .vars
73                    .iter()
74                    .map(|v| (v.0.clone(), v.1.clone(), v.2.clone()))
75                    .collect(),
76            )
77            .maybe_prefix(pretty_c.prefix)
78            .maybe_suffix(pretty_c.suffix)
79            .build()
80    }
81}
82
83#[cfg(all(test, feature = "serde"))]
84mod test_serde {
85    use crate::{
86        Prefix, Pretty, PrettyExt, Suffix, utils::test_utils::TEST_PREFIX_SUFFIX, vergen_pretty_env,
87    };
88    use anyhow::Result;
89
90    const VARS: &str = r#"vars":"#;
91    const PREFIX: &str = r#""prefix":{"lines":["#;
92    const SUFFIX: &str = r#""suffix":{"lines":["#;
93
94    #[test]
95    fn pretty_serde_works() -> Result<()> {
96        let pretty = Pretty::builder().env(vergen_pretty_env!()).build();
97        let pretty_ext = PrettyExt::from(pretty);
98        let val = serde_json::to_string(&pretty_ext)?;
99        assert!(val.contains(VARS));
100        Ok(())
101    }
102
103    #[test]
104    fn pretty_encode_decode_with_prefix_suffix_works() -> Result<()> {
105        let prefix = Prefix::builder()
106            .lines(TEST_PREFIX_SUFFIX.lines().map(str::to_string).collect())
107            .build();
108        let suffix = Suffix::builder()
109            .lines(TEST_PREFIX_SUFFIX.lines().map(str::to_string).collect())
110            .build();
111        let pretty = Pretty::builder()
112            .env(vergen_pretty_env!())
113            .prefix(prefix)
114            .suffix(suffix)
115            .build();
116        let pretty_ext = PrettyExt::from(pretty);
117        let val = serde_json::to_string(&pretty_ext)?;
118        assert!(val.contains(VARS));
119        assert!(val.contains(PREFIX));
120        assert!(val.contains(SUFFIX));
121        Ok(())
122    }
123}