give i access to outside context

Author: ModProg

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Changed
+- **Breaking Changed**: `format` and `write` take `Context` trait, this breaks type inference
+- `i` allows access to outer variables
+
 ## [0.4.0] - 2023-03-01
 ### Changed
 - **Breaking Change**: Made error enums `non_exhaustive`

README.md

@@ -14,11 +14,12 @@ Takes a string and a context, containing `Formattable` values, returns a
 string.
 
 ```rs
+use std::collections::HashMap;
 use template::{format, Formattable};
 
 let formatted = format(
     "{value:+05}", // could be dynamic
-    &[("value", Formattable::display(&12))].into_iter().collect(),
+    &[("value", Formattable::display(&12))].into_iter().collect::<HashMap<_,_>>(),
 )
 .unwrap();
 
@@ -32,13 +33,14 @@ Takes a mutable `Write` e.g. `&mut String`, a format string and a context,
 containing `Formattable` values.
 
 ```rs
+use std::collections::HashMap;
 use template::{write, Formattable};
 
 let mut buf = String::new();
 write(
     &mut buf,
     "{value:+05}", // could be dynamic
-    &[("value", Formattable::display(&12))].into_iter().collect(),
+    &[("value", Formattable::display(&12))].into_iter().collect::<HashMap<_,_>>(),
 )
 .unwrap();
 

src/hard_coded/iter.rs

@@ -6,6 +6,7 @@ fn write_iter(
     range: Option<Range>,
     format: Option<&str>,
     join: Option<&str>,
+    context: &impl Context,
 ) -> Result {
     if value.is_empty() {
         return Ok(());
@@ -23,17 +24,13 @@ fn write_iter(
     if rhs > lhs {
         if let Some(format) = format {
             for value in &value[lhs..rhs - 1] {
-                let mut context = HashMap::new();
-                context.insert("", value);
-                write(out, format, &context)?;
+                write(out, format, &IterContext::new(context, *value))?;
                 if let Some(join) = join {
-                    write!(out, "{join}").map_err(|e| Error::Fmt(e, 0))?;
+                    write(out, join, context)?;
                 }
             }
             if let Some(value) = value[..rhs].last() {
-                let mut context = HashMap::new();
-                context.insert("", value);
-                write(out, format, &context)?;
+                write(out, format, &IterContext::new(context, *value))?;
             }
         } else {
             for value in &value[lhs..rhs] {
@@ -64,20 +61,21 @@ pub(crate) fn iter(
     range: Option<Range>,
     format: Option<&str>,
     join: Option<&str>,
+    context: &impl Context,
 ) -> 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)?;
+                write_iter(&mut buf, value, range, format, join, context)?;
                 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)
+                write_iter(out, value, range, format, join, context)
             }
         }
         _ => Err(ParseError::Iter(0).into()),
@@ -115,4 +113,11 @@ mod test {
         assert_eq!(format("{h:i1..}", context).unwrap(), "5");
         assert_eq!(format("{h:i..=-1}", context).unwrap(), "15");
     }
+    #[test]
+    fn outside_context() {
+        let list = &[&"hi", &"ho"].map(Formattable::display);
+        let context = &hash!("list" => Formattable::iter(list), "x" => Formattable::display(&"?!"));
+        assert_eq!(format("{list:i({}{x})}", context).unwrap(), "hi?!ho?!");
+        assert_eq!(format("{list:i({})({x})}", context).unwrap(), "hi?!ho");
+    }
 }

src/hard_coded/mod.rs

@@ -45,7 +45,7 @@ macro_rules! call_format_value {
         $zero:ident,
         $trait_:ident,
         $idx:ident {
-            $($Trait:ident$(($($fields:tt)*))? => $fn:ident($getter:ident $(, $feature:literal)?) $($ret:ident)?,)*
+            $($Trait:ident$(($($fields:tt)*))? => $fn:ident($getter:ident $(, $feature:literal)? $(, $args:ident)*) $($ret:ident)?,)*
         }
     ) => {
         match $trait_ {
@@ -54,7 +54,7 @@ macro_rules! call_format_value {
                     Ok(v) => v,
                     Err(e) => return Err(Error::MissingTraitImpl(e, $idx))
                 };
-                branch!(($idx $($ret)?),$fn::$fn($out, value, $width, $precision, $alignment, $sign, $hash, $zero, $($($fields)*)?))
+                branch!(($idx $($ret)?),$fn::$fn($out, value, $width, $precision, $alignment, $sign, $hash, $zero, $($($fields)*)? $(, $args)*))
             },)*
             TraitSpec::Phantom(_) => unreachable!()
         }
@@ -97,6 +97,8 @@ pub(crate) fn format_value(
     zero: bool,
     trait_: TraitSpec,
     idx: usize,
+    #[allow(unused)]
+    context: &impl Context,
 ) -> Result<()> {
     call_format_value! {
         match out, value, width, precision, alignment, sign, hash, zero, trait_, idx {
@@ -111,7 +113,7 @@ pub(crate) fn format_value(
             LowerExp => lower_exp(get_lower_exp, "number"),
             UpperExp => upper_exp(get_upper_exp, "number"),
             Pointer => pointer(get_pointer, "pointer"),
-            Iter(range, format, join) => iter(get_iter, "iter") return,
+            Iter(range, format, join) => iter(get_iter, "iter", context) return,
         }
     }
     .map_err(|e| Error::Fmt(e, idx))

src/lib.rs

@@ -9,11 +9,14 @@
 //! [features](#features).
 //!
 //! ```
+//! # use std::collections::HashMap;
 //! use interpolator::{format, Formattable};
 //!
 //! let formatted = format(
 //!     "{value:+05}", // could be dynamic
-//!     &[("value", Formattable::display(&12))].into_iter().collect(),
+//!     &[("value", Formattable::display(&12))]
+//!         .into_iter()
+//!         .collect::<HashMap<_, _>>(),
 //! )?;
 //!
 //! assert_eq!(formatted, format!("{:+05}", 12));
@@ -55,10 +58,10 @@ use interpolator::{format, Formattable};
 // reference
 let items = [&"hello", &"hi", &"hey"].map(Formattable::display);
 let items = Formattable::iter(&items);
-let format_str = "Greetings: {items:i..-1(`{}`)(, )} and `{items:i-1}`";
+let format_str = "Greetings: {items:i..-1(`{}{outside}`)(, )} and `{items:i-1}{outside}`";
 assert_eq!(
-    format(format_str, &hash!("items" => items))?,
-    "Greetings: `hello`, `hi` and `hey`"
+    format(format_str, &hash!("items" => items, "outside" => Formattable::display(&'!')))?,
+    "Greetings: `hello!`, `hi!` and `hey!`"
 );
 # return Ok::<(), interpolator::Error>(())
 ```"#
@@ -112,11 +115,14 @@ type Result<T = (), E = Error> = std::result::Result<T, E>;
 /// string.
 ///
 /// ```
+/// # use std::collections::HashMap;
 /// use interpolator::{format, Formattable};
 ///
 /// let formatted = format(
 ///     "{value:+05}", // could be dynamic
-///     &[("value", Formattable::display(&12))].into_iter().collect(),
+///     &[("value", Formattable::display(&12))]
+///         .into_iter()
+///         .collect::<HashMap<_, _>>(),
 /// )
 /// .unwrap();
 ///
@@ -130,28 +136,64 @@ type Result<T = (), E = Error> = std::result::Result<T, E>;
 /// failed.
 ///
 /// For more details have a look at [`Error`] and [`ParseError`].
-pub fn format<K: Borrow<str> + Eq + Hash>(
-    format: &str,
-    context: &HashMap<K, Formattable>,
-) -> Result<String> {
+pub fn format(format: &str, context: &impl Context) -> Result<String> {
     let mut out = String::with_capacity(format.len());
     write(&mut out, format, context)?;
     Ok(out)
 }
 
+/// Context for `format` and `write`
+pub trait Context {
+    /// Returns the [`Formattable`] for the requested key
+    fn get(&self, key: &str) -> Option<Formattable>;
+}
+
+impl<K: Borrow<str> + Eq + Hash> Context for HashMap<K, Formattable<'_>> {
+    fn get(&self, key: &str) -> Option<Formattable> {
+        HashMap::get(self, key).copied()
+    }
+}
+
+#[cfg(feature = "iter")]
+struct IterContext<'a> {
+    outer: &'a dyn Context,
+    inner: Formattable<'a>,
+}
+
+#[cfg(feature = "iter")]
+impl<'a> IterContext<'a> {
+    fn new(outer: &'a impl Context, inner: Formattable<'a>) -> Self {
+        Self { outer, inner }
+    }
+}
+
+#[cfg(feature = "iter")]
+impl<'a> Context for IterContext<'a> {
+    fn get(&self, key: &str) -> Option<Formattable> {
+        if key.is_empty() {
+            Some(self.inner)
+        } else {
+            self.outer.get(key)
+        }
+    }
+}
+
 /// Runtime version of [`write!`].
 ///
 /// Takes a mutable [`Write`] e.g. `&mut String`, a format string and a context,
 /// containing [`Formattable`] values.
 ///
 /// ```
+/// # use std::collections::HashMap;
 /// use interpolator::{write, Formattable};
 ///
 /// let mut buf = String::new();
 /// write(
 ///     &mut buf,
 ///     "{value:+05}", // could be dynamic
-///     &[("value", Formattable::display(&12))].into_iter().collect(),
+///     &[("value", Formattable::display(&12))]
+///         .into_iter()
+///         .collect::<HashMap<_, _>>(),
 /// )
 /// .unwrap();
 ///
@@ -165,11 +207,7 @@ pub fn format<K: Borrow<str> + Eq + Hash>(
 /// failed.
 ///
 /// For more details have a look at [`Error`] and [`ParseError`].
-pub fn write<'a, K: Borrow<str> + Eq + Hash, F: Borrow<Formattable<'a>>>(
-    out: &mut impl Write,
-    mut format: &str,
-    context: &'a HashMap<K, F>,
-) -> Result {
+pub fn write(out: &mut impl Write, mut format: &str, context: &impl Context) -> Result {
     let format = &mut format;
     let idx = &mut 0;
     while !format.is_empty() {
@@ -206,6 +244,7 @@ pub fn write<'a, K: Borrow<str> + Eq + Hash, F: Borrow<Formattable<'a>>>(
                 zero,
                 trait_,
                 *idx,
+                context,
             )?;
             ensure!(format.starts_with('}'), ParseError::Expected("}", *idx));
             step(1, format, idx);

tests/test.rs

@@ -120,13 +120,16 @@ fn test(
     t.pass_inline(
         &converter.to_token_stream().to_string(),
         &quote! {
-            use interpolator::{{format, Formattable, write}};
-            use std::thread;
             use std::fmt::Write;
+            use std::thread;
+
+            use collection_literals::hash;
+            use interpolator::{{format, Formattable, write}};
+
             fn main() {
                 // This stack overflows without the thread on windows + nightly
                 thread::spawn(move ||{
-                    let value = &[("ident", Formattable::#converter(&#value))].into_iter().collect();
+                    let value = &hash!("ident" => Formattable::#converter(&#value));
                     #(
                         assert_eq!(
                             format(#format_args, value).unwrap(),