Quelle  smart_display.rs

//! Definition of [`SmartDisplay`] and its related items.
//!
//! [`SmartDisplay`] is a trait that allows authors to provide additional information to both the
//! formatter and other users. This information is provided in the form of a metadata type. The only
//! required piece of metadata is the width of the value. This is _before_ it is passed to the
//! formatter (i.e. it does not include any padding added by the formatter). Other information
//! can be stored in a custom metadata type as needed. This information may be made available to
//! downstream users, but it is not required.
//!
//! This module contains the [`SmartDisplay`] and associated items.
//!
//! # Example
//!
//! ```rust
//! use std::fmt;
//!
//! use powerfmt::ext::FormatterExt as _;
//! use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
//!
//! #[derive(Debug)]
//! struct User {
//!     id: usize,
//! }
//!
//! // If you try to use `UserMetadata` in the `SmartDisplay` implementation, you will get a
//! // compiler error about a private type being used publicly. To avoid this, use this attribute to
//! // declare a private metadata type. You shouldn't need to worry about how this works, but be
//! // aware that any public fields or methods remain usable by downstream users.
//! #[smart_display::private_metadata]
//! struct UserMetadata {
//!     username: String,
//!     legal_name: String,
//! }
//!
//! // This attribute can be applied to `SmartDisplay` implementations. It will generate an
//! // implementation of `Display` that delegates to `SmartDisplay`, avoiding the need to write
//! // boilerplate.
//! #[smart_display::delegate]
//! impl SmartDisplay for User {
//!     type Metadata = UserMetadata;
//!
//!     fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
//!         // This could be obtained from a database, for example.
//!         let legal_name = "John Doe".to_owned();
//!         let username = "jdoe".to_owned();
//!
//!         // Note that this must be kept in sync with the implementation of `fmt_with_metadata`.
//!         let width = smart_display::padded_width_of!(username, " (", legal_name, ")",);
//!
//!         Metadata::new(
//!             width,
//!             self,
//!             UserMetadata {
//!                 username,
//!                 legal_name,
//!             },
//!         )
//!     }
//!
//!     // Use the now-generated metadata to format the value. Here we use the `pad_with_width`
//!     // method to use the alignment and desired width from the formatter.
//!     fn fmt_with_metadata(
//!         &self,
//!         f: &mut fmt::Formatter<'_>,
//!         metadata: Metadata<Self>,
//!     ) -> fmt::Result {
//!         f.pad_with_width(
//!             metadata.unpadded_width(),
//!             format_args!("{} ({})", metadata.username, metadata.legal_name),
//!         )
//!     }
//! }
//!
//! let user = User { id: 42 };
//! assert_eq!(user.to_string(), "jdoe (John Doe)");
//! assert_eq!(format!("{user:>20}"), "     jdoe (John Doe)");
//! ```

use core::cmp;
use core::convert::Infallible;
use core::fmt::{Alignment, Debug, Display, Formatter, Result};
use core::marker::PhantomData;
use core::mem::MaybeUninit;
use core::ops::Deref;

/// Compute the width of multiple items while optionally declaring the options for each item.
///
/// ```rust
/// # use powerfmt::smart_display;
/// let alpha = 0;
/// let beta = 1;
/// let gamma = 100;
///
/// let width = smart_display::padded_width_of!(
///     alpha, // use the default options
///     beta => width(2), // use the specified options
///     gamma => width(2) sign_plus(true), // use multiple options
/// );
/// assert_eq!(width, 7);
///
/// let formatted = format!("{alpha}{beta:2}{gamma:+2}");
/// assert_eq!(formatted.len(), width);
/// ```
///
/// Supported options are:
///
/// Option                      | Method called
/// ---                         | ---
/// `fill(char)`                | [`FormatterOptions::with_fill`]
/// `sign_plus(bool)`           | [`FormatterOptions::with_sign_plus`]
/// `sign_minus(bool)`          | [`FormatterOptions::with_sign_minus`]
/// `align(Alignment)`          | [`FormatterOptions::with_align`]
/// `width(usize)`              | [`FormatterOptions::with_width`]
/// `precision(usize)`          | [`FormatterOptions::with_precision`]
/// `alternate(bool)`           | [`FormatterOptions::with_alternate`]
/// `sign_aware_zero_pad(bool)` | [`FormatterOptions::with_sign_aware_zero_pad`]
///
/// If there are future additions to [`FormatterOptions`], they will be added to this macro as well.
///
/// Options may be provided in any order and will be called in the order they are provided. The
/// ordering matters if providing both `sign_plus` and `sign_minus`.
#[cfg(doc)]
#[doc(hidden)] // Don't show at crate root.
#[macro_export]
macro_rules! padded_width_of {
    ($($t:tt)*) => {};
}

#[cfg(not(doc))]
#[allow(missing_docs)] // This is done with `#[cfg(doc)]` to avoid showing the various rules.
#[macro_export]
macro_rules! __not_public_at_root__padded_width_of {
    // Base case
    (@inner [] [$($output:tt)+]) => { $($output)+ };
    (@inner [$e:expr $(, $($remaining:tt)*)?] [$($expansion:tt)+]) => {
        $crate::smart_display::padded_width_of!(@inner [$($($remaining)*)?] [
            $($expansion)+ + $crate::smart_display::Metadata::padded_width_of(
                &$e,
                $crate::smart_display::padded_width_of!(@options)
            )
        ])
    };
    (@inner
        [$e:expr => $($call:ident($call_expr:expr))+ $(, $($remaining:tt)*)?]
        [$($expansion:tt)+]
    ) => {
        $crate::smart_display::padded_width_of!(@inner [$($($remaining)*)?] [
            $($expansion)+ + $crate::smart_display::Metadata::padded_width_of(
                &$e,
                *$crate::smart_display::padded_width_of!(@options $($call($call_expr))+)
            )
        ])
    };

    // Options base case
    (@options_inner [] [$($output:tt)+]) => { $($output)+ };
    (@options_inner [fill($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_fill($e)
        ])
    };
    (@options_inner [sign_plus($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_sign_plus($e)
        ])
    };
    (@options_inner [sign_minus($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_sign_minus($e)
        ])
    };
    (@options_inner [align($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_align(Some($e))
        ])
    };
    (@options_inner [width($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_width(Some($e))
        ])
    };
    (@options_inner [precision($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_precision(Some($e))
        ])
    };
    (@options_inner [alternate($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_width($e)
        ])
    };
    (@options_inner [sign_aware_zero_pad($e:expr) $($remaining:tt)*] [$($expansion:tt)*]) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($remaining)*] [
            $($expansion)*.with_sign_aware_zero_pad($e)
        ])
    };
    // Options entry point
    (@options $($e:tt)*) => {
        $crate::smart_display::padded_width_of!(@options_inner [$($e)*] [
            $crate::smart_display::FormatterOptions::default()
        ])
    };

    // Entry point
    ($($t:tt)*) => {
        $crate::smart_display::padded_width_of!(
            @inner [$($t)*] [0]
        )
    };
}

#[cfg(not(doc))]
pub use __not_public_at_root__padded_width_of as padded_width_of;
#[cfg(doc)]
#[doc(inline)] // Show in this module.
pub use padded_width_of;
/// Implement [`Display`] for a type by using its implementation of [`SmartDisplay`].
///
/// This attribute is applied to the `SmartDisplay` implementation.
///
/// ```rust,no_run
/// # use powerfmt::smart_display::{self, SmartDisplay, Metadata, FormatterOptions};
/// # struct Foo;
/// #[smart_display::delegate]
/// impl SmartDisplay for Foo {
/// #   type Metadata = ();
/// #   fn metadata(&self, f: FormatterOptions) -> Metadata<Self> {
/// #       todo!()
/// #   }
///     // ...
/// }
/// ```
#[cfg(feature = "macros")]
pub use powerfmt_macros::smart_display_delegate as delegate;
/// Declare a private metadata type for `SmartDisplay`.
///
/// Use this attribute if you want to provide metadata for a type that is not public. Doing
/// this will avoid a compiler error about a private type being used publicly. Keep in mind
/// that any public fields, public methods, and trait implementations _will_ be able to be used
/// by downstream users.
///
/// To avoid accidentally exposing details, such as when all fields are public or if the type
/// is a unit struct, the type is annotated with `#[non_exhaustive]` automatically.
///
/// ```rust,no_run
/// # use powerfmt::smart_display;
/// /// Metadata for `Foo`
/// #[smart_display::private_metadata]
/// #[derive(Debug)]
/// pub(crate) struct FooMetadata {
///     pub(crate) expensive_to_calculate: usize,
/// }
/// ```
#[cfg(feature = "macros")]
pub use powerfmt_macros::smart_display_private_metadata as private_metadata;

#[derive(Debug)]
enum FlagBit {
    SignPlus,
    SignMinus,
    Alternate,
    SignAwareZeroPad,
    WidthIsInitialized,
    PrecisionIsInitialized,
}

/// Configuration for formatting.
///
/// This struct is obtained from a [`Formatter`]. It provides the same functionality as that of a
/// reference to a `Formatter`. However, it is not possible to construct a `Formatter`, which is
/// necessary for some use cases of [`SmartDisplay`]. `FormatterOptions` implements [`Default`] and
/// has builder methods to alleviate this.
#[derive(Clone, Copy)]
pub struct FormatterOptions {
    flags: u8,
    fill: char,
    align: Option<Alignment>,
    width: MaybeUninit<usize>,
    precision: MaybeUninit<usize>,
}

impl Debug for FormatterOptions {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.debug_struct("FormatterOptions")
            .field("fill", &self.fill)
            .field("align", &self.align())
            .field("width", &self.width())
            .field("precision", &self.precision())
            .field("sign_plus", &self.sign_plus())
            .field("sign_minus", &self.sign_minus())
            .field("alternate", &self.alternate())
            .field("sign_aware_zero_pad", &self.sign_aware_zero_pad())
            .finish()
    }
}

impl Default for FormatterOptions {
    #[inline]
    fn default() -> Self {
        Self {
            flags: 0,
            fill: ' ',
            align: None,
            width: MaybeUninit::uninit(),
            precision: MaybeUninit::uninit(),
        }
    }
}

impl FormatterOptions {
    /// Sets the fill character to use whenever there is alignment.
    #[inline]
    pub fn with_fill(&mut self, c: char) -> &mut Self {
        self.fill = c;
        self
    }

    /// Set whether the `+` flag is specified.
    #[inline]
    pub fn with_sign_plus(&mut self, b: bool) -> &mut Self {
        if b {
            self.flags |= 1 << FlagBit::SignPlus as u8;
            self.flags &= !(1 << FlagBit::SignMinus as u8);
        } else {
            self.flags &= !(1 << FlagBit::SignPlus as u8);
        }
        self
    }

    /// Set whether the `-` flag is specified.
    #[inline]
    pub fn with_sign_minus(&mut self, b: bool) -> &mut Self {
        if b {
            self.flags |= 1 << FlagBit::SignMinus as u8;
            self.flags &= !(1 << FlagBit::SignPlus as u8);
        } else {
            self.flags &= !(1 << FlagBit::SignMinus as u8);
        }
        self
    }

    /// Set the flag indicating what form of alignment is requested, if any.
    #[inline]
    pub fn with_align(&mut self, align: Option<Alignment>) -> &='color:red'>mut Self {
        self.align = align;
        self
    }

    /// Set the optional integer width that the output should be.
    #[inline]
    pub fn with_width(&mut self, width: Option<usize>) -> &mut Self {
        if let Some(width) = width {
            self.flags |= 1 << FlagBit::WidthIsInitialized as u8;
            self.width = MaybeUninit::new(width);
        } else {
            self.flags &= !(1 << FlagBit::WidthIsInitialized as u8);
        }
        self
    }

    /// Set the optional precision for numeric types. Alternatively, the maximum width for string
    /// types.
    #[inline]
    pub fn with_precision(&mut self, precision: Option<usize>) -> &tyle='color:red'>mut Self {
        if let Some(precision) = precision {
            self.flags |= 1 << FlagBit::PrecisionIsInitialized as u8;
            self.precision = MaybeUninit::new(precision);
        } else {
            self.flags &= !(1 << FlagBit::PrecisionIsInitialized as u8);
        }
        self
    }

    /// Set whether the `#` flag is specified.
    #[inline]
    pub fn with_alternate(&mut self, b: bool) -> &mut Self {
        if b {
            self.flags |= 1 << FlagBit::Alternate as u8;
        } else {
            self.flags &= !(1 << FlagBit::Alternate as u8);
        }
        self
    }

    /// Set whether the `0` flag is specified.
    #[inline]
    pub fn with_sign_aware_zero_pad(&mut self, b: bool) -> &'color:red'>mut Self {
        if b {
            self.flags |= 1 << FlagBit::SignAwareZeroPad as u8;
        } else {
            self.flags &= !(1 << FlagBit::SignAwareZeroPad as u8);
        }
        self
    }
}

impl FormatterOptions {
    /// Character used as 'fill' whenever there is alignment.
    #[inline]
    #[must_use]
    pub const fn fill(&self) -> char {
        self.fill
    }

    /// Flag indicating what form of alignment was requested.
    #[inline]
    #[must_use]
    pub const fn align(&self) -> Option<Alignment> {
        self.align
    }

    /// Optionally specified integer width that the output should be.
    #[inline]
    #[must_use]
    pub const fn width(&self) -> Option<usize> {
        if (self.flags >> FlagBit::WidthIsInitialized as u8) & 1 == 1 {
            // Safety: `width` is initialized if the flag is set.
            Some(unsafe { self.width.assume_init() })
        } else {
            None
        }
    }

    /// Optionally specified precision for numeric types. Alternatively, the maximum width for
    /// string types.
    #[inline]
    #[must_use]
    pub const fn precision(&self) -> Option<usize> {
        if (self.flags >> FlagBit::PrecisionIsInitialized as u8) & 1 == 1 {
            // Safety: `precision` is initialized if the flag is set.
            Some(unsafe { self.precision.assume_init() })
        } else {
            None
        }
    }

    /// Determines if the `+` flag was specified.
    #[inline]
    #[must_use]
    pub const fn sign_plus(&self) -> bool {
        (self.flags >> FlagBit::SignPlus as u8) & 1 == 1
    }

    /// Determines if the `-` flag was specified.
    #[inline]
    #[must_use]
    pub const fn sign_minus(&self) -> bool {
        (self.flags >> FlagBit::SignMinus as u8) & 1 == 1
    }

    /// Determines if the `#` flag was specified.
    #[inline]
    #[must_use]
    pub const fn alternate(&self) -> bool {
        (self.flags >> FlagBit::Alternate as u8) & 1 == 1
    }

    /// Determines if the `0` flag was specified.
    #[inline]
    #[must_use]
    pub const fn sign_aware_zero_pad(&self) -> bool {
        (self.flags >> FlagBit::SignAwareZeroPad as u8) & 1 == 1
    }
}

impl From<&Formatter<'_>> for FormatterOptions {
    fn from(value: &Formatter<'_>) -> Self {
        *Self::default()
            .with_fill(value.fill())
            .with_sign_plus(value.sign_plus())
            .with_sign_minus(value.sign_minus())
            .with_align(value.align())
            .with_width(value.width())
            .with_precision(value.precision())
            .with_alternate(value.alternate())
            .with_sign_aware_zero_pad(value.sign_aware_zero_pad())
    }
}

impl From<&mut Formatter<'_>> for FormatterOptions {
    #[inline]
    fn from(value: &mut Formatter<'_>) -> Self {
        (&*value).into()
    }
}

/// Information used to format a value. This is returned by [`SmartDisplay::metadata`].
///
/// This type is generic over any user-provided type. This allows the author to store any
/// information that is needed. For example, a type's implementation of [`SmartDisplay`] may need
/// to calculate something before knowing its width. This calculation can be performed, with the
/// result being stored in the custom metadata type.
///
/// Note that `Metadata` _always_ contains the width of the type. Authors do not need to store this
/// information in their custom metadata type.
///
/// Generally speaking, a type should be able to be formatted using only its metadata, fields, and
/// the formatter. Any other information should be stored in the metadata type.
pub struct Metadata<'a, T>
where
    T: SmartDisplay + ?Sized,
{
    unpadded_width: usize,
    metadata: T::Metadata,
    _value: PhantomData<&'a T>, // variance
}

// manual impls for bounds
impl<T> Debug for Metadata<'_, T>
where
    T: SmartDisplay,
    T::Metadata: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.debug_struct("Metadata")
            .field("unpadded_width", &self.unpadded_width)
            .field("metadata", &self.metadata)
            .finish()
    }
}

impl<T> Clone for Metadata<'_, T>
where
    T: SmartDisplay,
    T::Metadata: Clone,
{
    fn clone(&self) -> Self {
        Self {
            unpadded_width: self.unpadded_width,
            metadata: self.metadata.clone(),
            _value: self._value,
        }
    }
}

impl<T> Copy for Metadata<'_, T>
where
    T: SmartDisplay,
    T::Metadata: Copy,
{
}

impl<'a, T> Metadata<'a, T>
where
    T: SmartDisplay + ?Sized,
{
    /// Creates a new `Metadata` with the given width and metadata. While the width _should_ be
    /// exact, this is not a requirement for soundness.
    pub const fn new(unpadded_width: usize, _value: &T, metadata: T::Metadata) -> Self {
        Self {
            unpadded_width,
            metadata,
            _value: PhantomData,
        }
    }

    /// Reuse the metadata for another type. This is useful when implementing [`SmartDisplay`] for a
    /// type that wraps another type. Both type's metadata type must be the same.
    pub fn reuse<'b, U>(self) -> Metadata<'b, U>
    where
        'a: 'b,
        U: SmartDisplay<Metadata = T::Metadata> + ?Sized,
    {
        Metadata {
            unpadded_width: self.unpadded_width,
            metadata: self.metadata,
            _value: PhantomData,
        }
    }

    /// Obtain the width of the value before padding.
    pub const fn unpadded_width(&self) -> usize {
        self.unpadded_width
    }

    /// Obtain the width of the value after padding.
    pub fn padded_width(&self, f: FormatterOptions) -> usize {
        match f.width() {
            Some(requested_width) => cmp::max(self.unpadded_width(), requested_width),
            None => self.unpadded_width(),
        }
    }
}

impl Metadata<'_, Infallible> {
    /// Obtain the width of the value before padding, given the formatter options.
    pub fn unpadded_width_of<T>(value: T, f: FormatterOptions) -> usize
    where
        T: SmartDisplay,
    {
        value.metadata(f).unpadded_width
    }

    /// Obtain the width of the value after padding, given the formatter options.
    pub fn padded_width_of<T>(value: T, f: FormatterOptions) -> usize
    where
        T: SmartDisplay,
    {
        value.metadata(f).padded_width(f)
    }
}

/// Permit using `Metadata` as a smart pointer to the user-provided metadata.
impl<T> Deref for Metadata<'_, T>
where
    T: SmartDisplay + ?Sized,
{
    type Target = T::Metadata;

    fn deref(&self) -> &T::Metadata {
        &self.metadata
    }
}

/// Format trait that allows authors to provide additional information.
///
/// This trait is similar to [`Display`], but allows the author to provide additional information
/// to the formatter. This information is provided in the form of a custom metadata type.
///
/// The only required piece of metadata is the width of the value. This is _before_ it is passed to
/// the formatter (i.e. it does not include any padding added by the formatter). Other information
/// can be stored in a custom metadata type as needed. This information may be made available to
/// downstream users, but it is not required.
///
/// **Note**: While both `fmt_with_metadata` and `fmt` have default implementations, it is strongly
/// recommended to implement only `fmt_with_metadata`. `fmt` should be implemented if and only if
/// the type does not require any of the calculated metadata. In that situation, `fmt_with_metadata`
/// should be omitted.
#[cfg_attr(__powerfmt_docs, rustc_must_implement_one_of(fmt, fmt_with_metadata))]
pub trait SmartDisplay: Display {
    /// User-provided metadata type.
    type Metadata;

    /// Compute any information needed to format the value. This must, at a minimum, determine the
    /// width of the value before any padding is added by the formatter.
    ///
    /// If the type uses other types that implement `SmartDisplay` verbatim, the inner types should
    /// have their metadata calculated and included in the returned value.
    ///
    /// # Lifetimes
    ///
    /// This method's return type contains a lifetime to `self`. This ensures that the metadata will
    /// neither outlive the value nor be invalidated by a mutation of the value (barring interior
    /// mutability).
    ///
    /// ```rust,compile_fail
    /// # use std::fmt;
    /// # use std::fmt::Write;
    /// # use powerfmt::buf::WriteBuffer;
    /// # use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
    /// #[derive(Debug)]
    /// struct WrappedBuffer(WriteBuffer<128>);
    ///
    /// #[smart_display::delegate]
    /// impl SmartDisplay for WrappedBuffer {
    ///     type Metadata = ();
    ///
    ///     fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
    ///         Metadata::new(self.0.len(), self, ())
    ///     }
    ///
    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    ///         f.pad(self.0.as_str())
    ///     }
    /// }
    ///
    /// let mut buf = WrappedBuffer(WriteBuffer::new());
    /// let metadata = buf.metadata(FormatterOptions::default());
    /// // We cannot mutate the buffer while it is borrowed and use its previous metadata on the
    /// // following line.
    /// write!(buf.0, "Hello, world!")?;
    /// assert_eq!(metadata.width(), 13);
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    fn metadata(&self, f: FormatterOptions) -> Metadata<'_, Self>;

    /// Format the value using the given formatter and metadata. The formatted output should have
    /// the width indicated by the metadata. This is before any padding is added by the
    /// formatter.
    ///
    /// If the metadata is not needed, you should implement the `fmt` method instead.
    fn fmt_with_metadata(&self, f: &mut Formatter<'_>, _metadata: Metadata<'_, Self>) -> Result {
        SmartDisplay::fmt(self, f)
    }

    /// Format the value using the given formatter. This is the same as [`Display::fmt`].
    ///
    /// The default implementation of this method calls `fmt_with_metadata` with the result of
    /// `metadata`. Generally speaking, this method should not be implemented. You should implement
    /// the `fmt_with_metadata` method instead.
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let metadata = self.metadata(f.into());
        self.fmt_with_metadata(f, metadata)
    }
}