Iter formatter (#7)

Author: ModProg

Cargo.toml

@@ -12,12 +12,14 @@ documentation = "https://docs.rs/interpolator"
 include = ["src/**/*", "LICENSE-*", "README.md", "CHANGELOG.md"]
 
 [features]
-# default = ["debug", "number", "pointer"]
+default = ["debug", "number", "pointer", "iter"]
 debug = []
 number = []
 pointer = []
+iter = []
 
 [dev-dependencies]
+collection_literals = "1.0.1"
 derive_more = "0.99.17"
 proptest = "1.1.0"
 proptest-derive = "0.3.0"

src/error.rs

@@ -0,0 +1,173 @@
+use super::*;
+
+#[derive(Debug, PartialEq, Clone)]
+/// Error returned by [`format()`].
+pub enum Error {
+    /// Value was formatted with unimplemented trait.
+    /// - `.0` the trait
+    /// - `.1` the byte index of the format argument
+    MissingTraitImpl(Trait, usize),
+    /// Error occurred while calling `::fmt`
+    /// - `.0` the error
+    /// - `.1` the byte index of the format argument
+    Fmt(FmtError, usize),
+    /// Error occurred  while parsing format string
+    Parse(ParseError),
+    /// Tried to format value that was not in context
+    /// - `.0` the ident of the value
+    /// - `.1` the byte index of the format argument
+    MissingValue(String, usize),
+    /// Unsupported Option was used.
+    /// - `.0` is the option
+    /// - `.1` the feature that needs to be enabled to use it
+    /// - `.2` the byte index of the format argument
+    UnsupportedOption(&'static str, &'static str, usize),
+}
+
+impl Error {
+    pub(crate) fn add_idx(self, idx: usize) -> Self {
+        use Error::*;
+        match self {
+            MissingTraitImpl(t, i) => MissingTraitImpl(t, i + idx),
+            Fmt(e, i) => Fmt(e, i),
+            Parse(e) => Parse(e.add_idx(idx)),
+            MissingValue(v, i) => MissingValue(v, i + idx),
+            UnsupportedOption(o, f, i) => UnsupportedOption(o, f, i + idx),
+        }
+    }
+}
+
+impl From<ParseError> for Error {
+    fn from(value: ParseError) -> Self {
+        Self::Parse(value)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::MissingTraitImpl(t, idx) => write!(
+                f,
+                "trait `{t:?}` not implemented, used by format argument at {idx}"
+            ),
+            Error::Fmt(e, idx) => write!(f, "error while formatting at {idx}: {e}"),
+            Error::Parse(e) => write!(f, "error while parsing input: {e}"),
+            Error::MissingValue(ident, idx) => {
+                write!(f, "specified value not in context `{ident}` at {idx}")
+            }
+            Error::UnsupportedOption(option, feature, idx) => write!(
+                f,
+                "option `{option}` is not supported without feature `{feature}` at {idx}"
+            ),
+        }
+    }
+}
+
+impl StdError for Error {}
+
+#[derive(Debug, PartialEq, Clone)]
+#[non_exhaustive]
+/// The trait used to format.
+pub enum Trait {
+    /// [`Binary`]
+    #[cfg(feature = "number")]
+    Binary,
+    /// [`Debug`]
+    #[cfg(feature = "debug")]
+    Debug,
+    /// [`Display`]
+    Display,
+    /// [`LowerExp`]
+    #[cfg(feature = "number")]
+    LowerExp,
+    /// [`LowerHex`]
+    #[cfg(feature = "number")]
+    LowerHex,
+    /// [`Octal`]
+    #[cfg(feature = "number")]
+    Octal,
+    /// [`Pointer`]
+    #[cfg(feature = "pointer")]
+    Pointer,
+    /// [`UpperExp`]
+    #[cfg(feature = "number")]
+    UpperExp,
+    /// [`UpperHex`]
+    #[cfg(feature = "number")]
+    UpperHex,
+    #[cfg(feature = "iter")]
+    /// Custom "trait" that allows iterating over lists i.e. `&[Formattable]`
+    Iter,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+/// Error caused by invalid format string
+pub enum ParseError {
+    /// Format spec at byte index is nether closed with a `}`
+    FormatSpecUnclosed(usize),
+    /// Expected sequence at byte index
+    Expected(&'static str, usize),
+    /// Unable to parse specified width as usize
+    InvalidWidth(ParseIntError, usize),
+    /// Unable to parse specified precision as usize
+    InvalidPrecision(ParseIntError, usize),
+    /// Fill is not supported due to [rust-lang/rfcs#3394](https://github.com/rust-lang/rfcs/pull/3394).
+    Fill(usize),
+    /// Width, precision, `-`, `+` and `#` are not supported for `i`
+    Iter(usize),
+    /// Unable to parse specified range bound as isize
+    RangeBound(ParseIntError, usize),
+}
+
+impl ParseError {
+    pub(crate) fn add_idx(self, idx: usize) -> ParseError {
+        use ParseError::*;
+        match self {
+            FormatSpecUnclosed(i) => FormatSpecUnclosed(i + idx),
+            Expected(c, i) => Expected(c, i + idx),
+            InvalidWidth(e, i) => InvalidWidth(e, i + idx),
+            InvalidPrecision(e, i) => InvalidPrecision(e, i + idx),
+            Fill(i) => Fill(i + idx),
+            Iter(i) => Iter(i + idx),
+            RangeBound(e, i) => RangeBound(e, i + idx),
+        }
+    }
+}
+
+impl Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::FormatSpecUnclosed(idx) => {
+                write!(f, "Format spec at {idx} is nether closed with a `}}`")
+            }
+            ParseError::Expected(c, idx) => write!(f, "Expected `{c}` at {idx}"),
+            ParseError::InvalidWidth(e, idx) => {
+                write!(f, "Unable to parse width at {idx} as usize: {e}")
+            }
+            ParseError::InvalidPrecision(e, idx) => {
+                write!(f, "Unable to parse precision at {idx} as usize: {e}")
+            }
+            ParseError::Fill(idx) => write!(
+                f,
+                "Fill is not supported due to https://github.com/rust-lang/rfcs/pull/3394 at {idx}"
+            ),
+            ParseError::Iter(idx) => write!(
+                f,
+                "Width, precision, `-`, `+` and `#` are not supported for `i` at {idx}"
+            ),
+            ParseError::RangeBound(e, idx) => {
+                write!(f, "Unable to parse range bound at {idx} as isize: {e}")
+            }
+        }
+    }
+}
+
+impl StdError for ParseError {}
+
+macro_rules! ensure {
+    ($condition:expr, $error:expr) => {
+        if !$condition {
+            return Err($error.into());
+        }
+    };
+}

src/formattable.rs

@@ -0,0 +1,128 @@
+use super::*;
+/// Utility struct holding references to the trait implementation of a value to
+/// enable runtime verification and execution of them
+#[derive(Default)]
+#[must_use]
+pub struct Formattable<'a> {
+    #[cfg(any(feature = "debug", feature = "number"))]
+    debug: Option<&'a dyn Debug>,
+    display: Option<&'a dyn Display>,
+    #[cfg(feature = "number")]
+    binary: Option<&'a dyn Binary>,
+    #[cfg(feature = "number")]
+    lower_exp: Option<&'a dyn LowerExp>,
+    #[cfg(feature = "number")]
+    lower_hex: Option<&'a dyn LowerHex>,
+    #[cfg(feature = "number")]
+    octal: Option<&'a dyn Octal>,
+    #[cfg(feature = "number")]
+    upper_exp: Option<&'a dyn UpperExp>,
+    #[cfg(feature = "number")]
+    upper_hex: Option<&'a dyn UpperHex>,
+    #[cfg(feature = "pointer")]
+    pointer: Option<PointerWrapper<'a>>,
+    #[cfg(feature = "iter")]
+    iter: Option<&'a [Formattable<'a>]>,
+}
+
+macro_rules! formattable_fn {
+    (($($cfg:tt)*), ($doc:expr), $name:ident, $builder:ident<$($traits:ident),*> $($fields:ident),+) => {
+        /// Creates a [`Formattable`] from a value implementing
+        #[doc = $doc]
+        $($cfg)* pub fn $name<T: $($traits+)*>(value: &'a T) -> Self {
+            #[allow(clippy::needless_update)]
+            Self {
+                $($fields: Some(value),)*
+                ..Default::default()
+            }
+        }
+        /// Adds implementation for
+        #[doc = $doc]
+        $($cfg)* pub fn $builder<T: $($traits+)*>(mut self, value: &'a T) -> Self {
+            $(self.$fields = Some(value);)*
+            self
+        }
+    };
+    (($($cfg:tt)*), (), $name:ident, $builder:ident, $getter:ident<$trait:ident>) => {
+        formattable_fn!(($($cfg)*), (concat!("[`",stringify!($trait),"`]")), $name, $builder<$trait> $name);
+        $($cfg)* pub(crate) fn $getter(&self) -> Result<&dyn $trait, Trait> {
+            self.$name.ok_or(Trait::$trait)
+        }
+    };
+}
+macro_rules! formattable {
+    [$($($cfg:literal, $($doc:literal,)?)? $name:ident, $builder:ident$(, $getter:ident)?<$($traits:ident),*> $($fields:ident),*;)*] => {
+        impl<'a> Formattable<'a> {
+            $(formattable_fn!(($(#[cfg(feature=$cfg)])?), ($($($doc)?)?), $name, $builder$(, $getter)?<$($traits),*> $($fields),*);)*
+        }
+    };
+}
+
+formattable![
+    "debug", "[`Debug`] and [`Display`]", debug_display, and_debug_display<Debug, Display> debug, display;
+    "debug", debug, and_debug, get_debug<Debug>;
+    display, and_display, get_display<Display>;
+    "number", "[`Debug`], [`Display`], [`Octal`], [`LowerHex`], [`UpperHex`], [`Binary`], [`LowerExp`] and [`UpperExp`]", integer, and_integer<Binary, Debug, Display, LowerExp, LowerHex, Octal, UpperExp, UpperHex>
+        binary, debug, display, lower_exp, lower_hex, octal, upper_exp, upper_hex;
+    "number", "[`Debug`], [`Display`], [`LowerExp`] and [`UpperExp`]", float, and_float<Debug, Display, LowerExp, UpperExp>
+        debug, display, lower_exp, upper_exp;
+    "number", binary, and_binary, get_binary<Binary>;
+    "number", lower_exp, and_lower_exp, get_lower_exp<LowerExp>;
+    "number", lower_hex, and_lower_hex, get_lower_hex<LowerHex>;
+    "number", octal, and_octal, get_octal<Octal>;
+    "number", upper_exp, and_upper_exp, get_upper_exp<UpperExp>;
+    "number", upper_hex, and_upper_hex, get_upper_hex<UpperHex>;
+];
+
+#[cfg(feature = "pointer")]
+impl<'a> Formattable<'a> {
+    /// Creates a [`Formattable`] from a value implementing [`Pointer`].
+    pub fn pointer<T: Pointer>(value: &'a T) -> Self {
+        Self::default().and_pointer(value)
+    }
+
+    /// Adds implementation for [`Pointer`]
+    pub fn and_pointer<T: Pointer>(mut self, value: &'a T) -> Self {
+        self.pointer = Some(PointerWrapper(value));
+        self
+    }
+
+    pub(crate) fn get_pointer(&self) -> Result<PointerWrapper, Trait> {
+        self.pointer.ok_or(Trait::Pointer)
+    }
+}
+
+impl<'a> Formattable<'a> {
+    /// Creates a [`Formattable`] from a list of values
+    pub fn iter(value: &'a [Formattable<'a>]) -> Self {
+        Self::default().and_iter(value)
+    }
+
+    /// Adds implementation for mapping operations
+    pub fn and_iter(mut self, value: &'a [Formattable<'a>]) -> Self {
+        self.iter = Some(value);
+        self
+    }
+
+    pub(crate) fn get_iter(&self) -> Result<&'a [Formattable<'a>], Trait> {
+        self.iter.ok_or(Trait::Iter)
+    }
+}
+
+#[cfg(feature = "pointer")]
+#[derive(Clone, Copy)]
+pub(crate) struct PointerWrapper<'a>(&'a dyn Pointer);
+
+#[cfg(feature = "pointer")]
+impl Pointer for PointerWrapper<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Pointer::fmt(self.0, f)
+    }
+}
+
+#[cfg(all(feature = "display", feature = "debug"))]
+impl<'a, T: Display + Debug> From<&'a T> for Formattable<'a> {
+    fn from(value: &'a T) -> Self {
+        Self::debug_display(value)
+    }
+}

src/hard_coded/iter.rs

@@ -0,0 +1,72 @@
+use crate::*;
+
+fn write_iter(
+    out: &mut impl Write,
+    value: &[Formattable<'_>],
+    range: Option<Range>,
+    format: &str,
+    join: Option<&str>,
+) -> Result {
+    if value.is_empty() {
+        return Ok(());
+    }
+    let Range(lhs, inclusive, rhs) = range.unwrap_or(Range(None, false, None));
+    let rhs = rhs.unwrap_or(isize::MAX);
+    let rhs = (usize::try_from(rhs).unwrap_or(value.len().saturating_sub(rhs.unsigned_abs()))
+        + usize::from(inclusive))
+    .min(value.len());
+    let lhs = lhs.unwrap_or(0);
+    let lhs = usize::try_from(lhs)
+        .unwrap_or(value.len().saturating_sub(lhs.unsigned_abs()))
+        .min(rhs);
+
+    if rhs > lhs {
+        for value in &value[lhs..rhs - 1] {
+            let mut context = HashMap::new();
+            context.insert("it", value);
+            write(out, format, &context)?;
+            if let Some(join) = join {
+                write!(out, "{join}").map_err(|e| Error::Fmt(e, 0))?;
+            }
+        }
+        if let Some(value) = value[..rhs].last() {
+            let mut context = HashMap::new();
+            context.insert("it", value);
+            write(out, format, &context)?;
+        }
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn iter(
+    out: &mut impl Write,
+    value: &[Formattable<'_>],
+    width: Option<usize>,
+    precision: Option<usize>,
+    alignment: crate::Alignment,
+    sign: Sign,
+    hash: bool,
+    zero: bool,
+    range: Option<Range>,
+    format: &str,
+    join: Option<&str>,
+) -> Result {
+    match (precision, sign, hash, zero) {
+        (None, Sign::None, false, false) => {
+            if let Some(width) = width {
+                let mut buf = String::new();
+                write_iter(&mut buf, value, range, format, join)?;
+                match alignment {
+                    Alignment::Left | Alignment::None => write!(out, "{buf:<width$}"),
+                    Alignment::Center => write!(out, "{buf:^width$}"),
+                    Alignment::Right => write!(out, "{buf:>width$}"),
+                }
+                .map_err(|e| Error::Fmt(e, 0))
+            } else {
+                write_iter(out, value, range, format, join)
+            }
+        }
+        _ => Err(ParseError::Iter(0).into()),
+    }
+}