feat: macros

Author: ModProg

.github/workflows/test.yaml

@@ -59,6 +59,7 @@ jobs:
         run:
           cargo test ${{ matrix.features }} --all-targets --no-fail-fast --workspace
       - name: Doc Test
+        if: "matrix.features == '--all-features'"
         run:
           cargo test ${{ matrix.features }} --doc --no-fail-fast --workspace
       - name: Build Docs

.gitignore

@@ -1,2 +1,2 @@
-/target
-/Cargo.lock
+target
+Cargo.lock

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Breaking Changed**: `format` and `write` take `Context` trait, this breaks type inference
 - `i` allows access to outer variables
 
+### Added
+- `set_{trait}` functions on `Formattable`
+- Macros for format, write and print
+
 ## [0.4.0] - 2023-03-01
 ### Changed
 - **Breaking Change**: Made error enums `non_exhaustive`

Cargo.toml

@@ -19,6 +19,7 @@ pointer = []
 iter = []
 
 [dev-dependencies]
+assert-dbg = { path = "assert-dbg" }
 collection_literals = "1.0.1"
 derive_more = "0.99.17"
 proptest = "1.1.0"

assert-dbg/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "assert-dbg"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

assert-dbg/src/lib.rs

@@ -0,0 +1,6 @@
+#[macro_export]
+macro_rules! assert_dbg {
+    ($lhs:expr, $rhs:expr $(, $($fmt:tt)*)?) => {
+        ::std::assert_eq!(::std::format!("{:?}", $lhs), $rhs$(, $($fmt)*)?);
+    };
+}

src/fmt/mod.rs

@@ -97,8 +97,7 @@ pub(crate) fn format_value(
     zero: bool,
     trait_: TraitSpec,
     idx: usize,
-    #[allow(unused)]
-    context: &impl Context,
+    #[allow(unused)] context: &impl Context,
 ) -> Result<()> {
     call_format_value! {
         match out, value, width, precision, alignment, sign, hash, zero, trait_, idx {

src/formattable.rs

@@ -25,8 +25,46 @@ pub struct Formattable<'a> {
     iter: Option<&'a [Formattable<'a>]>,
 }
 
+struct PlainString(&'static str);
+
+impl Debug for PlainString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+macro_rules! formattable_debug {
+    ($($field:ident $(: $feature:literal)?),+ $(,)?) => {
+        impl Debug for Formattable<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let mut tuple = f.debug_tuple("Formattable");
+                $(
+                    $(#[cfg(feature = $feature)])?
+                    if self.$field.is_some() {
+                        tuple.field(&PlainString(stringify!($field)));
+                    }
+                )*
+                tuple.finish()
+            }
+        }
+    };
+}
+
+formattable_debug! {
+    debug: "debug",
+    display,
+    binary: "number",
+    lower_exp: "number",
+    lower_hex: "number",
+    octal: "number",
+    upper_exp: "number",
+    upper_hex: "number",
+    pointer: "pointer",
+    iter: "iter"
+}
+
 macro_rules! formattable_fn {
-    (($($cfg:tt)*), ($doc:expr), $name:ident, $builder:ident<$($traits:ident),*> $($fields:ident),+) => {
+    (($($cfg:tt)*), ($doc:expr), $name:ident, $builder:ident, $setter:ident <$($traits:ident),*> $($fields:ident),+) => {
         /// Creates a [`Formattable`] from a value implementing
         #[doc = $doc]
         $($cfg)* pub fn $name<T: $($traits+)*>(value: &'a T) -> Self {
@@ -42,36 +80,41 @@ macro_rules! formattable_fn {
             $(self.$fields = Some(value);)*
             self
         }
+        /// Sets implementation for
+        #[doc = $doc]
+        $($cfg)* pub fn $setter<T: $($traits+)*>(&mut self, value: &'a T) {
+            $(self.$fields = Some(value);)*
+        }
     };
-    (($($cfg:tt)*), (), $name:ident, $builder:ident, $getter:ident<$trait:ident>) => {
-        formattable_fn!(($($cfg)*), (concat!("[`",stringify!($trait),"`]")), $name, $builder<$trait> $name);
+    (($($cfg:tt)*), (), $name:ident, $builder:ident, $setter:ident, $getter:ident<$trait:ident>) => {
+        formattable_fn!(($($cfg)*), (concat!("[`",stringify!($trait),"`]")), $name, $builder, $setter<$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),*;)*] => {
+    [$($($cfg:literal, $($doc:literal,)?)? $name:ident, $builder:ident, $setter:ident $(, $getter:ident)?<$($traits:ident),*> $($fields:ident),*;)*] => {
         impl<'a> Formattable<'a> {
-            $(formattable_fn!(($(#[cfg(feature=$cfg)])?), ($($($doc)?)?), $name, $builder$(, $getter)?<$($traits),*> $($fields),*);)*
+            $(formattable_fn!(($(#[cfg(feature=$cfg)])?), ($($($doc)?)?), $name, $builder, $setter $(, $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>
+    "debug", "[`Debug`] and [`Display`]", debug_display, and_debug_display, set_debug_display<Debug, Display> debug, display;
+    "debug", debug, and_debug, set_debug, get_debug<Debug>;
+    display, and_display, set_display, get_display<Display>;
+    "number", "[`Debug`], [`Display`], [`Octal`], [`LowerHex`], [`UpperHex`], [`Binary`], [`LowerExp`] and [`UpperExp`]", integer, and_integer, set_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>
+    "number", "[`Debug`], [`Display`], [`LowerExp`] and [`UpperExp`]", float, and_float, set_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>;
+    "number", binary, and_binary, set_binary, get_binary<Binary>;
+    "number", lower_exp, and_lower_exp, set_lower_exp, get_lower_exp<LowerExp>;
+    "number", lower_hex, and_lower_hex, set_lower_hex, get_lower_hex<LowerHex>;
+    "number", octal, and_octal, set_octal, get_octal<Octal>;
+    "number", upper_exp, and_upper_exp, set_upper_exp, get_upper_exp<UpperExp>;
+    "number", upper_hex, and_upper_hex, set_upper_hex, get_upper_hex<UpperHex>;
 ];
 
 #[cfg(feature = "pointer")]
@@ -87,6 +130,11 @@ impl<'a> Formattable<'a> {
         self
     }
 
+    /// Sets implementation for [`Pointer`]
+    pub fn set_pointer<T: Pointer>(&mut self, value: &'a T) {
+        self.pointer = Some(PointerWrapper(value));
+    }
+
     pub(crate) fn get_pointer(&self) -> Result<PointerWrapper, Trait> {
         self.pointer.ok_or(Trait::Pointer)
     }
@@ -105,6 +153,11 @@ impl<'a> Formattable<'a> {
         self
     }
 
+    /// Sets implementation for mapping operations
+    pub fn set_iter(&mut self, value: &'a [Formattable<'a>]) {
+        self.iter = Some(value);
+    }
+
     pub(crate) fn get_iter(&self) -> Result<&'a [Formattable<'a>], Trait> {
         self.iter.ok_or(Trait::Iter)
     }

src/lib.rs

@@ -1,4 +1,4 @@
-//! Runtime implementation of [`format!`].
+//! Runtime implementation of [`format!`](std::format).
 //!
 //! # `std::fmt` compatible formatting
 //!
@@ -67,7 +67,26 @@ assert_eq!(
 ```"#
 )]
 
-//! See [`format`](format()) and [`write`](write()) for details.
+//! See [`format()`] and [`write()`] for details.
+//!
+//! # Macros
+//!
+//! To simplify creating contexts, some macros are provided.
+//!
+//! - [`context!`] creates a [`HashMap<&str, Formattable>`](HashMap) to be used
+//!   with [`format()`].
+#![cfg_attr(
+    feature = "iter",
+    doc = r"- [`list!`] creates a [`Formattable`] implementing supporting [iter](`i`-iter-format)."
+)]
+//! - [`iformat!`] and [`iwrite!`] macros matching the behaviour of [`format()`]
+//!   and [`write()`] but allowing to specify context directly.
+//! - Most of std's formatting macros are supported with an `i` prefix:
+//!   - [`iwriteln!`]
+//!   - [`iprint!`]
+//!   - [`iprintln!`]
+//!   - [`ieprint!`]
+//!   - [`ieprintln!`]
 //!
 //! # Features
 //! By default only [`Display`] is supported, the rest of the
@@ -106,6 +125,7 @@ mod formattable;
 pub use formattable::*;
 mod parser;
 use parser::*;
+mod macros;
 
 type Result<T = (), E = Error> = std::result::Result<T, E>;