code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/error-stack-0.8.0/src/ext/tuple.rs

@@ -0,0 +1,218 @@
+use crate::Report;
+
+/// Extends tuples with error-handling capabilities.
+///
+/// This trait provides a method to collect a tuple of `Result`s into a single `Result`
+/// containing a tuple of the successful values, or an error if any of the results failed.
+///
+/// The trait is implemented for tuples of up to 16 elements.
+///
+/// # Stability
+///
+/// This trait is only available behind the `unstable` feature flag and is not covered by
+/// semver guarantees. It may change or be removed in future versions without notice.
+pub trait TryReportTupleExt<C> {
+    /// The type of the successful output, typically a tuple of the inner types of the `Result`s.
+    type Output;
+
+    /// Attempts to collect all `Result`s in the tuple into a single `Result`.
+    ///
+    /// # Errors
+    ///
+    /// If any element is `Err`, returns the first encountered `Err`, with subsequent errors
+    /// appended to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use error_stack::{Report, TryReportTupleExt};
+    ///
+    /// #[derive(Debug)]
+    /// struct CustomError;
+    ///
+    /// impl core::fmt::Display for CustomError {
+    ///     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    ///         write!(f, "Custom error")
+    ///     }
+    /// }
+    ///
+    /// impl core::error::Error for CustomError {}
+    ///
+    /// let result1: Result<i32, Report<CustomError>> = Ok(1);
+    /// let result2: Result<&'static str, Report<CustomError>> = Ok("success");
+    /// let result3: Result<bool, Report<CustomError>> = Ok(true);
+    ///
+    /// let combined = (result1, result2, result3).try_collect();
+    /// assert_eq!(combined.unwrap(), (1, "success", true));
+    ///
+    /// let result1: Result<i32, Report<CustomError>> = Ok(1);
+    /// let result2: Result<&'static str, Report<CustomError>> = Err(Report::new(CustomError));
+    /// let result3: Result<bool, Report<CustomError>> = Err(Report::new(CustomError));
+    /// let combined_with_error = (result1, result2, result3).try_collect();
+    /// assert!(combined_with_error.is_err());
+    /// ```
+    fn try_collect(self) -> Result<Self::Output, Report<[C]>>;
+}
+
+impl<T, R, C> TryReportTupleExt<C> for (core::result::Result<T, R>,)
+where
+    R: Into<Report<[C]>>,
+{
+    type Output = (T,);
+
+    fn try_collect(self) -> Result<Self::Output, Report<[C]>> {
+        let (result,) = self;
+
+        match result {
+            Ok(value) => Ok((value,)),
+            Err(report) => Err(report.into()),
+        }
+    }
+}
+
+#[rustfmt::skip]
+macro_rules! all_the_tuples {
+    ($macro:ident) => {
+        $macro!([A, AO]);
+        $macro!([A, AO], [B, BO]);
+        $macro!([A, AO], [B, BO], [C, CO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO], [O, OO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO], [O, OO], [P, PO]);
+    };
+}
+
+macro_rules! impl_ext {
+    ($([$type:ident, $output:ident]),+) => {
+        impl<$($type, $output),*, T, R, Context> TryReportTupleExt<Context> for ($($type),*, core::result::Result<T, R>)
+        where
+            R: Into<Report<[Context]>>,
+            ($($type,)*): TryReportTupleExt<Context, Output = ($($output,)*)>,
+        {
+            type Output = ($($output),*, T);
+
+            #[expect(non_snake_case, clippy::min_ident_chars)]
+            fn try_collect(self) -> Result<Self::Output, Report<[Context]>> {
+                let ($($type),*, result) = self;
+                let prefix = ($($type,)*).try_collect();
+
+                match (prefix, result) {
+                    (Ok(($($type,)*)), Ok(value)) => Ok(($($type),*, value)),
+                    (Err(report), Ok(_)) => Err(report),
+                    (Ok(_), Err(report)) => Err(report.into()),
+                    (Err(mut report), Err(error)) => {
+                        report.append(error.into());
+                        Err(report)
+                    }
+                }
+            }
+        }
+    };
+}
+
+all_the_tuples!(impl_ext);
+
+#[cfg(test)]
+mod test {
+    use alloc::{borrow::ToOwned as _, collections::BTreeSet, string::String};
+    use core::{error::Error, fmt::Display};
+
+    use super::TryReportTupleExt as _;
+    use crate::Report;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    struct TestError(usize);
+
+    impl Display for TestError {
+        fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            fmt.write_str("TestError")
+        }
+    }
+
+    impl Error for TestError {}
+
+    #[test]
+    fn single_error() {
+        let result1: Result<i32, Report<TestError>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Err(Report::new(TestError(0)));
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 1);
+        assert!(contexts.contains(&TestError(0)));
+    }
+
+    #[test]
+    fn no_error() {
+        let result1: Result<i32, Report<TestError>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Ok(true);
+
+        let combined = (result1, result2, result3).try_collect();
+        let (ok1, ok2, ok3) = combined.expect("should have no error");
+
+        assert_eq!(ok1, 1);
+        assert_eq!(ok2, "test");
+        assert!(ok3);
+    }
+
+    #[test]
+    fn expanded_error() {
+        let result1: Result<i32, Report<[TestError]>> = Ok(1);
+        let result2: Result<String, Report<[TestError]>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<[TestError]>> = Err(Report::new(TestError(0)).expand());
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 1);
+        assert!(contexts.contains(&TestError(0)));
+    }
+
+    #[test]
+    fn single_and_expanded_mixed() {
+        let result1: Result<i32, Report<[TestError]>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Err(Report::new(TestError(0)));
+        let result3: Result<bool, Report<[TestError]>> = Err(Report::new(TestError(1)).expand());
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&TestError(0)));
+        assert!(contexts.contains(&TestError(1)));
+    }
+
+    #[test]
+    fn multiple_errors() {
+        let result1: Result<i32, Report<TestError>> = Err(Report::new(TestError(0)));
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Err(Report::new(TestError(1)));
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&TestError(0)));
+        assert!(contexts.contains(&TestError(1)));
+    }
+}

data/ext/cargo-vendor/error-stack-0.8.0/src/fmt/charset.rs

@@ -0,0 +1,114 @@
+use crate::{
+    Report,
+    fmt::r#override::{AtomicOverride, AtomicPreference},
+};
+
+/// The available supported charsets.
+///
+/// Can be accessed through [`crate::fmt::HookContext::charset`], and set via
+/// [`Report::set_charset`].
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
+pub enum Charset {
+    /// Terminal of the user supports UTF-8.
+    ///
+    /// This is the default if no charset has been explicitly set.
+    // we assume that most fonts and terminals nowadays support Utf8, which is why this is
+    // the default
+    #[default]
+    Utf8,
+
+    /// Terminal of the user supports ASCII.
+    Ascii,
+}
+
+impl Charset {
+    pub(super) fn load() -> Self {
+        CHARSET_OVERRIDE.load()
+    }
+}
+
+/// Value layout:
+///
+/// - `0x00`: `Charset::Ascii`
+/// - `0x01`: `Charset::Utf8`
+/// - all others: default to [`Self::default`]
+impl AtomicPreference for Charset {
+    fn from_u8(value: u8) -> Self {
+        match value {
+            0x00 => Self::Ascii,
+            0x01 => Self::Utf8,
+            _ => Self::default(),
+        }
+    }
+
+    fn into_u8(self) -> u8 {
+        match self {
+            Self::Ascii => 0x00,
+            Self::Utf8 => 0x01,
+        }
+    }
+}
+
+static CHARSET_OVERRIDE: AtomicOverride<Charset> = AtomicOverride::new();
+
+impl Report<()> {
+    /// Sets the charset preference.
+    ///
+    /// The value defaults to [`Charset::Utf8`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # // we only test the snapshot on nightly, therefore report is unused (so is render)
+    /// # #![cfg_attr(not(nightly), allow(dead_code, unused_variables, unused_imports))]
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// use error_stack::{Report, IntoReport};
+    /// use error_stack::fmt::{Charset};
+    ///
+    /// struct Suggestion(&'static str);
+    ///
+    /// Report::install_debug_hook::<Suggestion>(|Suggestion(value), context| {
+    ///     match context.charset() {
+    ///         Charset::Utf8 => context.push_body(format!("📝 {value}")),
+    ///         Charset::Ascii => context.push_body(format!("suggestion: {value}"))
+    ///     };
+    /// });
+    ///
+    /// let report =
+    ///     Error::from(ErrorKind::InvalidInput).into_report().attach_opaque(Suggestion("oh no, try again"));
+    ///
+    /// # fn render(value: String) -> String {
+    /// #     let backtrace = regex::Regex::new(r"backtrace no\. (\d+)\n(?:  .*\n)*  .*").unwrap();
+    /// #     let backtrace_info = regex::Regex::new(r"backtrace( with (\d+) frames)? \((\d+)\)").unwrap();
+    /// #
+    /// #     let value = backtrace.replace_all(&value, "backtrace no. $1\n  [redacted]");
+    /// #     let value = backtrace_info.replace_all(value.as_ref(), "backtrace ($3)");
+    /// #
+    /// #     ansi_to_html::convert(value.as_ref()).unwrap()
+    /// # }
+    /// #
+    /// Report::set_charset(Charset::Utf8);
+    /// println!("{report:?}");
+    /// # #[cfg(nightly)]
+    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap")].assert_eq(&render(format!("{report:?}")));
+    ///
+    /// Report::set_charset(Charset::Ascii);
+    /// println!("{report:?}");
+    /// # #[cfg(nightly)]
+    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap")].assert_eq(&render(format!("{report:?}")));
+    /// ```
+    ///
+    /// Which will result in something like:
+    ///
+    /// <pre>
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap")))]
+    /// </pre>
+    ///
+    /// <pre>
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap")))]
+    /// </pre>
+    pub fn set_charset(charset: Charset) {
+        CHARSET_OVERRIDE.store(charset);
+    }
+}

data/ext/cargo-vendor/error-stack-0.8.0/src/fmt/color.rs

@@ -0,0 +1,330 @@
+use core::fmt::{self, Display, Formatter};
+
+use crate::{
+    Report,
+    fmt::r#override::{AtomicOverride, AtomicPreference},
+};
+
+/// The available modes of color support.
+///
+/// Can be accessed through [`crate::fmt::HookContext::color_mode`], and set via
+/// [`Report::set_color_mode`].
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
+pub enum ColorMode {
+    /// User preference to disable all colors.
+    None,
+
+    /// User preference to enable colors.
+    Color,
+
+    /// User preference to enable styles, but discourage colors.
+    ///
+    /// This is the same as [`ColorMode::Color`], but signals to the user that while colors are
+    /// supported, the user prefers instead the use of emphasis, like bold and italic text.
+    // The default is `ColorMode::Emphasis`, because colors are hard. ANSI colors are not
+    // standardized, and some colors may not show at all.
+    #[default]
+    Emphasis,
+}
+
+impl ColorMode {
+    pub(super) fn load() -> Self {
+        COLOR_OVERRIDE.load()
+    }
+}
+
+/// Value layout:
+///
+/// - `0x00`: `ColorMode::None`
+/// - `0x01`: `ColorMode::Color`
+/// - `0x02`: `ColorMode::Emphasis`
+/// - all others: [`Self::default`]
+impl AtomicPreference for ColorMode {
+    fn from_u8(value: u8) -> Self {
+        match value {
+            0x00 => Self::None,
+            0x01 => Self::Color,
+            0x02 => Self::Emphasis,
+            _ => Self::default(),
+        }
+    }
+
+    fn into_u8(self) -> u8 {
+        match self {
+            Self::None => 0x00,
+            Self::Color => 0x01,
+            Self::Emphasis => 0x02,
+        }
+    }
+}
+
+static COLOR_OVERRIDE: AtomicOverride<ColorMode> = AtomicOverride::new();
+
+impl Report<()> {
+    /// Sets the color mode preference.
+    ///
+    /// If no [`ColorMode`] is set, it defaults to [`ColorMode::Emphasis`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # // we only test the snapshot on nightly, therefore report is unused (so is render)
+    /// # #![cfg_attr(not(nightly), allow(dead_code, unused_variables, unused_imports))]
+    /// use std::io::{Error, ErrorKind};
+    /// use owo_colors::OwoColorize;
+    ///
+    /// use error_stack::{Report, IntoReport};
+    /// use error_stack::fmt::ColorMode;
+    ///
+    /// struct Suggestion(&'static str);
+    ///
+    /// Report::install_debug_hook::<Suggestion>(|Suggestion(value), context| {
+    ///     let body = format!("suggestion: {value}");
+    ///     match context.color_mode() {
+    ///         ColorMode::Color => context.push_body(body.green().to_string()),
+    ///         ColorMode::Emphasis => context.push_body(body.italic().to_string()),
+    ///         ColorMode::None => context.push_body(body)
+    ///     };
+    /// });
+    ///
+    /// let report =
+    ///     Error::from(ErrorKind::InvalidInput).into_report().attach_opaque(Suggestion("oh no, try again"));
+    ///
+    /// # fn render(value: String) -> String {
+    /// #     let backtrace = regex::Regex::new(r"backtrace no\. (\d+)\n(?:  .*\n)*  .*").unwrap();
+    /// #     let backtrace_info = regex::Regex::new(r"backtrace( with (\d+) frames)? \((\d+)\)").unwrap();
+    /// #
+    /// #     let value = backtrace.replace_all(&value, "backtrace no. $1\n  [redacted]");
+    /// #     let value = backtrace_info.replace_all(value.as_ref(), "backtrace ($3)");
+    /// #
+    /// #     ansi_to_html::convert(value.as_ref()).unwrap()
+    /// # }
+    /// #
+    /// Report::set_color_mode(ColorMode::None);
+    /// println!("{report:?}");
+    /// # #[cfg(nightly)]
+    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_none.snap")].assert_eq(&render(format!("{report:?}")));
+    ///
+    /// Report::set_color_mode(ColorMode::Emphasis);
+    /// println!("{report:?}");
+    /// # #[cfg(nightly)]
+    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_emphasis.snap")].assert_eq(&render(format!("{report:?}")));
+    ///
+    /// Report::set_color_mode(ColorMode::Color);
+    /// println!("{report:?}");
+    /// # #[cfg(nightly)]
+    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_color.snap")].assert_eq(&render(format!("{report:?}")));
+    /// ```
+    ///
+    /// Which will result in something like:
+    ///
+    /// <pre>
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_none.snap")))]
+    /// </pre>
+    ///
+    /// <pre>
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_emphasis.snap")))]
+    /// </pre>
+    ///
+    /// <pre>
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_color.snap")))]
+    /// </pre>
+    pub fn set_color_mode(mode: ColorMode) {
+        COLOR_OVERRIDE.store(mode);
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum Color {
+    Black,
+    Red,
+}
+
+impl Color {
+    const fn digit(self) -> u8 {
+        match self {
+            Self::Black => b'0',
+            Self::Red => b'1',
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Foreground {
+    color: Color,
+    bright: bool,
+}
+
+impl Foreground {
+    fn start_ansi(self, sequence: &mut ControlSequence) -> fmt::Result {
+        let Self { color, bright } = self;
+
+        let buffer = &[if bright { b'9' } else { b'3' }, color.digit()];
+        // This should never fail because both are valid ASCII
+        let control = core::str::from_utf8(buffer).expect("should be valid utf-8 buffer");
+
+        sequence.push_control(control)
+    }
+
+    fn end_ansi(sequence: &mut ControlSequence) -> fmt::Result {
+        sequence.push_control("39")
+    }
+}
+
+struct ControlSequence<'a, 'b> {
+    fmt: &'a mut Formatter<'b>,
+    empty: bool,
+}
+
+impl<'a, 'b> ControlSequence<'a, 'b> {
+    const fn new(fmt: &'a mut Formatter<'b>) -> Self {
+        Self { fmt, empty: true }
+    }
+
+    fn finish(self) -> Result<&'a mut Formatter<'b>, fmt::Error> {
+        if !self.empty {
+            // we wrote a specific formatting character, therefore we need to end
+            self.fmt.write_str("m")?;
+        }
+
+        Ok(self.fmt)
+    }
+}
+
+impl ControlSequence<'_, '_> {
+    fn push_control(&mut self, control: &str) -> fmt::Result {
+        if self.empty {
+            self.fmt.write_str("\u{1b}[")?;
+        } else {
+            self.fmt.write_str(";")?;
+        }
+
+        self.fmt.write_str(control)?;
+        self.empty = false;
+
+        Ok(())
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) struct DisplayStyle {
+    bold: bool,
+    italic: bool,
+}
+
+impl DisplayStyle {
+    pub(crate) const fn new() -> Self {
+        Self {
+            bold: false,
+            italic: false,
+        }
+    }
+
+    pub(crate) const fn set_bold(&mut self, value: bool) {
+        self.bold = value;
+    }
+
+    pub(crate) const fn with_bold(mut self, value: bool) -> Self {
+        self.set_bold(value);
+        self
+    }
+
+    pub(crate) const fn set_italic(&mut self, value: bool) {
+        self.italic = value;
+    }
+
+    pub(crate) const fn with_italic(mut self, value: bool) -> Self {
+        self.set_italic(value);
+        self
+    }
+}
+
+impl DisplayStyle {
+    fn start_ansi(self, sequence: &mut ControlSequence) -> fmt::Result {
+        if self.bold {
+            sequence.push_control("1")?;
+        }
+
+        if self.italic {
+            sequence.push_control("3")?;
+        }
+
+        Ok(())
+    }
+
+    fn end_ansi(self, sequence: &mut ControlSequence) -> fmt::Result {
+        if self.bold {
+            sequence.push_control("22")?;
+        }
+
+        if self.italic {
+            sequence.push_control("23")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) struct Style {
+    display: Option<DisplayStyle>,
+    foreground: Option<Foreground>,
+}
+
+impl Style {
+    pub(crate) const fn new() -> Self {
+        Self {
+            display: None,
+            foreground: None,
+        }
+    }
+
+    pub(crate) const fn apply<T: Display>(self, value: &T) -> StyleDisplay<'_, T> {
+        StyleDisplay { style: self, value }
+    }
+
+    pub(crate) const fn set_foreground(&mut self, color: Color, bright: bool) {
+        self.foreground = Some(Foreground { color, bright });
+    }
+
+    pub(crate) const fn set_display(&mut self, style: DisplayStyle) {
+        self.display = Some(style);
+    }
+}
+
+pub(crate) struct StyleDisplay<'a, T: Display> {
+    style: Style,
+    value: &'a T,
+}
+
+impl<T: Display> Display for StyleDisplay<'_, T> {
+    fn fmt(&self, mut fmt: &mut Formatter<'_>) -> fmt::Result {
+        let mut sequence = ControlSequence::new(fmt);
+
+        if let Some(display) = self.style.display {
+            display.start_ansi(&mut sequence)?;
+        }
+
+        if let Some(foreground) = self.style.foreground {
+            foreground.start_ansi(&mut sequence)?;
+        }
+
+        fmt = sequence.finish()?;
+
+        Display::fmt(&self.value, fmt)?;
+
+        let mut sequence = ControlSequence::new(fmt);
+
+        if let Some(display) = self.style.display {
+            display.end_ansi(&mut sequence)?;
+        }
+
+        if self.style.foreground.is_some() {
+            Foreground::end_ansi(&mut sequence)?;
+        }
+
+        sequence.finish()?;
+
+        Ok(())
+    }
+}