From b75f7ff26ef7085a4c3c0a99a111961b4157d8f2 Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Wed, 19 Feb 2020 23:31:21 +0000
Subject: [PATCH 01/10] add "insert_fn2()" function which inserts 2-arg
 function that has Fn(String)->String as second arg - so you can render the
 inner content inside the function.

---
 src/builder.rs  |  9 +++++++++
 src/data.rs     |  4 +++-
 src/template.rs | 37 +++++++++++++++++++++++++++++++++++++
 3 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/src/builder.rs b/src/builder.rs
index 83c5ca47..9e7f11d4 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -149,6 +149,15 @@ impl MapBuilder {
         data.insert(key.to_string(), Data::Fun(RefCell::new(Box::new(f))));
         MapBuilder { data: data }
     }
+    #[inline]
+    pub fn insert_fn2<K: ToString, F>(self, key: K, f: F) -> MapBuilder
+    where
+        F: FnMut(String, &(FnMut(String) -> String)) -> String + Send + 'static,
+    {
+        let MapBuilder { mut data } = self;
+        data.insert(key.to_string(), Data::Fun2(RefCell::new(Box::new(f))));
+        MapBuilder { data: data }
+    }
 
     /// Return the built `Data`.
     #[inline]
diff --git a/src/data.rs b/src/data.rs
index b71c79f4..f95874b4 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -9,6 +9,7 @@ pub enum Data {
     Vec(Vec<Data>),
     Map(HashMap<String, Data>),
     Fun(RefCell<Box<FnMut(String) -> String + Send>>),
+    Fun2(RefCell<Box<FnMut(String, &(FnMut(String) -> String)) -> String + Send>>),
 }
 
 impl PartialEq for Data {
@@ -35,6 +36,7 @@ impl fmt::Debug for Data {
             Data::Vec(ref v) => write!(f, "VecVal({:?})", v),
             Data::Map(ref v) => write!(f, "Map({:?})", v),
             Data::Fun(_) => write!(f, "Fun(...)"),
+            Data::Fun2(_) => write!(f, "Fun2(...)"),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/template.rs b/src/template.rs
index 1d6825ee..c1d9e112 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -291,6 +291,43 @@ impl<'a> RenderContext<'a> {
                         let tokens = try!(self.render_fun(src, otag, ctag, f));
                         try!(self.render(wr, stack, &tokens));
                     }
+                    Data::Fun2(ref fcell) => {
+                        let f = &mut *fcell.borrow_mut();
+                        let ctx2 = self.template.ctx.clone();
+                        let partials2 = self.template.partials.clone();
+
+                        let f0 = {
+                            |src: String| {
+                                let compiler = Compiler::new_with(
+                                    ctx2.clone(),
+                                    src.chars(),
+                                    partials2.clone(),
+                                    otag.to_string(),
+                                    ctag.to_string(),
+                                );
+                                let mut vw: Vec<u8> = vec![];
+                                match compiler.compile() {
+                                    Ok((tokens, _)) => {
+                                        self.render(&mut vw, stack, &tokens).unwrap_or(())
+                                    }
+                                    _ => (),
+                                }
+                                String::from_utf8_lossy(&vw).to_string()
+                            }
+                        };
+                        let src = f(src.to_string(), &f0);
+
+                        let compiler = Compiler::new_with(
+                            self.template.ctx.clone(),
+                            src.chars(),
+                            self.template.partials.clone(),
+                            otag.to_string(),
+                            ctag.to_string(),
+                        );
+
+                        let (tokens, _) = try!(compiler.compile());
+                        try!(self.render(wr, stack, &tokens));
+                    }
                 }
             }
         };

From d90a8b3fbff95cb0ea4d2be69865ea63dd6a5f6d Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Wed, 19 Feb 2020 23:47:11 +0000
Subject: [PATCH 02/10] make render function reference mutable

---
 src/builder.rs  | 2 +-
 src/data.rs     | 2 +-
 src/template.rs | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 9e7f11d4..2ba84431 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -152,7 +152,7 @@ impl MapBuilder {
     #[inline]
     pub fn insert_fn2<K: ToString, F>(self, key: K, f: F) -> MapBuilder
     where
-        F: FnMut(String, &(FnMut(String) -> String)) -> String + Send + 'static,
+        F: FnMut(String, &mut (FnMut(String) -> String)) -> String + Send + 'static,
     {
         let MapBuilder { mut data } = self;
         data.insert(key.to_string(), Data::Fun2(RefCell::new(Box::new(f))));
diff --git a/src/data.rs b/src/data.rs
index f95874b4..ae518ce1 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -9,7 +9,7 @@ pub enum Data {
     Vec(Vec<Data>),
     Map(HashMap<String, Data>),
     Fun(RefCell<Box<FnMut(String) -> String + Send>>),
-    Fun2(RefCell<Box<FnMut(String, &(FnMut(String) -> String)) -> String + Send>>),
+    Fun2(RefCell<Box<FnMut(String, &mut (FnMut(String) -> String)) -> String + Send>>),
 }
 
 impl PartialEq for Data {
diff --git a/src/template.rs b/src/template.rs
index c1d9e112..b48e1d8a 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -296,7 +296,7 @@ impl<'a> RenderContext<'a> {
                         let ctx2 = self.template.ctx.clone();
                         let partials2 = self.template.partials.clone();
 
-                        let f0 = {
+                        let mut f0 = {
                             |src: String| {
                                 let compiler = Compiler::new_with(
                                     ctx2.clone(),
@@ -315,7 +315,7 @@ impl<'a> RenderContext<'a> {
                                 String::from_utf8_lossy(&vw).to_string()
                             }
                         };
-                        let src = f(src.to_string(), &f0);
+                        let src = f(src.to_string(), &mut f0);
 
                         let compiler = Compiler::new_with(
                             self.template.ctx.clone(),

From 2fbfcdfd9d791082629533be33e065d6f1cd8ab2 Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Thu, 20 Feb 2020 00:06:14 +0000
Subject: [PATCH 03/10] render either the within-fn2 rendered or after it - not
 both

---
 src/template.rs | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/template.rs b/src/template.rs
index b48e1d8a..c012421b 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -65,6 +65,7 @@ struct RenderContext<'a> {
     template: &'a Template,
     indent: String,
     line_start: bool,
+    inner_fn2_rendered: bool,
 }
 
 impl<'a> RenderContext<'a> {
@@ -73,6 +74,7 @@ impl<'a> RenderContext<'a> {
             template: template,
             indent: "".to_string(),
             line_start: true,
+            inner_fn2_rendered: true,
         }
     }
 
@@ -295,6 +297,7 @@ impl<'a> RenderContext<'a> {
                         let f = &mut *fcell.borrow_mut();
                         let ctx2 = self.template.ctx.clone();
                         let partials2 = self.template.partials.clone();
+                        self.inner_fn2_rendered = false;
 
                         let mut f0 = {
                             |src: String| {
@@ -308,6 +311,7 @@ impl<'a> RenderContext<'a> {
                                 let mut vw: Vec<u8> = vec![];
                                 match compiler.compile() {
                                     Ok((tokens, _)) => {
+                                        self.inner_fn2_rendered = true;
                                         self.render(&mut vw, stack, &tokens).unwrap_or(())
                                     }
                                     _ => (),
@@ -316,17 +320,21 @@ impl<'a> RenderContext<'a> {
                             }
                         };
                         let src = f(src.to_string(), &mut f0);
-
-                        let compiler = Compiler::new_with(
-                            self.template.ctx.clone(),
-                            src.chars(),
-                            self.template.partials.clone(),
-                            otag.to_string(),
-                            ctag.to_string(),
-                        );
-
-                        let (tokens, _) = try!(compiler.compile());
-                        try!(self.render(wr, stack, &tokens));
+                        if self.inner_fn2_rendered {
+                            self.inner_fn2_rendered = false;
+                            try!(self.render_text(wr, &src));
+                        } else {
+                            let compiler = Compiler::new_with(
+                                self.template.ctx.clone(),
+                                src.chars(),
+                                self.template.partials.clone(),
+                                otag.to_string(),
+                                ctag.to_string(),
+                            );
+
+                            let (tokens, _) = try!(compiler.compile());
+                            try!(self.render(wr, stack, &tokens));
+                        }
                     }
                 }
             }

From f0349843ec90ea60416b8106f2bb12123fc80ad6 Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Thu, 20 Feb 2020 00:17:42 +0000
Subject: [PATCH 04/10] allow to reset flag within fn2 render callback by
 rendering empty string

---
 src/template.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/template.rs b/src/template.rs
index c012421b..e97b2061 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -311,7 +311,8 @@ impl<'a> RenderContext<'a> {
                                 let mut vw: Vec<u8> = vec![];
                                 match compiler.compile() {
                                     Ok((tokens, _)) => {
-                                        self.inner_fn2_rendered = true;
+                                        /* a trick to reset the flag is to pass an empty string */
+                                        self.inner_fn2_rendered = (src.len() > 0);
                                         self.render(&mut vw, stack, &tokens).unwrap_or(())
                                     }
                                     _ => (),

From b893cc783022a49607efb4c67ee8311f4f3c652d Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@cisco.com>
Date: Thu, 5 Jun 2025 12:08:23 +0200
Subject: [PATCH 05/10] derive Debug for MapBuilder

---
 src/builder.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/builder.rs b/src/builder.rs
index 2ba84431..82f21292 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -7,7 +7,7 @@ use encoder::Error;
 use super::{Data, to_data};
 
 /// `MapBuilder` is a helper type that construct `Data` types.
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct MapBuilder {
     data: HashMap<String, Data>,
 }

From 606ca063fea14fefe3d2ebf556414e5b139898cc Mon Sep 17 00:00:00 2001
From: Erik Funder Carstensen <fundererik@fastmail.com>
Date: Tue, 27 Apr 2021 15:51:41 +0200
Subject: [PATCH 06/10] Fix broken link in readme

The link to mustache documentation was previously broken, now it works.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7c3cb778..89755a32 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ git push --tags origin master
 [1]: http://code.google.com/p/google-ctemplate/
 [2]: http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html
 [3]: https://mustache.github.io/
-[4]: http://mustache.github.com/mustache.5.html
+[4]: https://mustache.github.io/mustache.5.html
 [5]: https://docs.rs/mustache
 
 # License

From 9f1fa00762ea0abcca331eadad29ab03c055ff67 Mon Sep 17 00:00:00 2001
From: Ben Stern <bas-github@bstern.org>
Date: Mon, 21 Jun 2021 22:15:01 -0400
Subject: [PATCH 07/10] Eliminate panics from live code (#73)

* Eliminate panics from live code.

As a library, panicking, even in the face of a bug, is a problem.

Also, a lot of warnings (mostly `try!` vs `?` and `dyn`) were removed,
as part of the edit/rebuild/test cycle.

* Update rust dependencies to rust 1.46

If Slackware thinks Rust 1.46 is stable enough for everyday use (i.e.,
building Mozilla) then it should be stable enough for anyone who doesn't
track "stable".

* Prevent possible infinite recursion

`cargo clippy` warned of infinite recursion, so let's heed the warning

Co-authored-by: Ben Stern <bstern@fortian.com>
---
 .travis.yml       |  3 +-
 src/compiler.rs   |  6 ++--
 src/context.rs    |  8 ++---
 src/data.rs       | 12 +++++--
 src/encoder.rs    | 30 +++++++---------
 src/error.rs      | 27 ++++++--------
 src/macros.rs     |  4 +--
 src/parser.rs     | 69 ++++++++++++++---------------------
 src/template.rs   | 92 +++++++++++++++++++++--------------------------
 tests/template.rs | 11 +++---
 10 files changed, 112 insertions(+), 150 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 55904342..02b75619 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,8 +6,7 @@ cache:
     - target
 
 rust:
-- 1.16.0
-- 1.17.0
+- 1.46.0
 - stable
 - nightly
 - beta
diff --git a/src/compiler.rs b/src/compiler.rs
index dcd6eae2..b40e5581 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -51,7 +51,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
     pub fn compile(mut self) -> Result<(Vec<Token>, PartialsMap)> {
         let (tokens, partials) = {
             let parser = Parser::new(&mut self.reader, &self.otag, &self.ctag);
-            try!(parser.parse())
+            parser.parse()?
         };
 
         // Compile the partials if we haven't done so already.
@@ -66,7 +66,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
                 match File::open(&path) {
                     Ok(mut file) => {
                         let mut string = String::new();
-                        try!(file.read_to_string(&mut string));
+                        file.read_to_string(&mut string)?;
 
                         let compiler = Compiler {
                             ctx: self.ctx.clone(),
@@ -76,7 +76,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
                             ctag: "}}".to_string(),
                         };
 
-                        let (tokens, subpartials) = try!(compiler.compile());
+                        let (tokens, subpartials) = compiler.compile()?;
 
                         // Include subpartials
                         self.partials.extend(subpartials.into_iter());
diff --git a/src/context.rs b/src/context.rs
index e95aef69..16ef0dbc 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -37,7 +37,7 @@ impl Context {
     /// Compiles a template from a string
     pub fn compile<IT: Iterator<Item = char>>(&self, reader: IT) -> Result<Template> {
         let compiler = compiler::Compiler::new(self.clone(), reader);
-        let (tokens, partials) = try!(compiler.compile());
+        let (tokens, partials) = compiler.compile()?;
 
         Ok(template::new(self.clone(), tokens, partials))
     }
@@ -49,8 +49,8 @@ impl Context {
         let mut path = self.template_path.join(path.as_ref());
         path.set_extension(&self.template_extension);
         let mut s = vec![];
-        let mut file = try!(File::open(&path));
-        try!(file.read_to_end(&mut s));
+        let mut file = File::open(&path)?;
+        file.read_to_end(&mut s)?;
 
         // TODO: maybe allow UTF-16 as well?
         let template = match str::from_utf8(&*s) {
@@ -62,4 +62,4 @@ impl Context {
 
         self.compile(template.chars())
     }
-}
\ No newline at end of file
+}
diff --git a/src/data.rs b/src/data.rs
index ae518ce1..faeb171a 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -2,14 +2,17 @@ use std::collections::HashMap;
 use std::cell::RefCell;
 use std::fmt;
 
+// for bug!
+use log::{log, error};
+
 pub enum Data {
     Null,
     String(String),
     Bool(bool),
     Vec(Vec<Data>),
     Map(HashMap<String, Data>),
-    Fun(RefCell<Box<FnMut(String) -> String + Send>>),
-    Fun2(RefCell<Box<FnMut(String, &mut (FnMut(String) -> String)) -> String + Send>>),
+    Fun(RefCell<Box<dyn FnMut(String) -> String + Send>>),
+    Fun2(RefCell<Box<dyn FnMut(String, &mut (dyn FnMut(String) -> String)) -> String + Send>>),
 }
 
 impl PartialEq for Data {
@@ -21,7 +24,10 @@ impl PartialEq for Data {
             (&Data::Bool(ref v0), &Data::Bool(ref v1)) => v0 == v1,
             (&Data::Vec(ref v0), &Data::Vec(ref v1)) => v0 == v1,
             (&Data::Map(ref v0), &Data::Map(ref v1)) => v0 == v1,
-            (&Data::Fun(_), &Data::Fun(_)) => bug!("Cannot compare closures"),
+            (&Data::Fun(_), &Data::Fun(_)) => {
+                bug!("Cannot compare closures");
+                false
+            },
             (_, _) => false,
         }
     }
diff --git a/src/encoder.rs b/src/encoder.rs
index 947c8363..c333b340 100644
--- a/src/encoder.rs
+++ b/src/encoder.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
-use std::error;
+use std::error::Error as StdError;
 use std::fmt::{self, Display};
-use std::result;
+use std::result::Result as StdResult;
 
 use serde::{self, Serialize, ser};
 
@@ -31,18 +31,11 @@ impl serde::ser::Error for Error {
 }
 
 /// Alias for a `Result` with the error type `mustache::encoder::Error`.
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = StdResult<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use std::error::Error;
-        self.description().fmt(f)
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
+        write!(f, "{}", match *self {
             Error::NestedOptions => "nested Option types are not supported",
             Error::UnsupportedType => "unsupported type",
             Error::MissingElements => "no elements in value",
@@ -50,10 +43,12 @@ impl error::Error for Error {
             Error::NoDataToEncode => "the encodable type created no data",
             Error::Message(ref s) => s,
             Error::__Nonexhaustive => unreachable!(),
-        }
+        })
     }
 }
 
+impl StdError for Error { }
+
 #[derive(Default)]
 pub struct Encoder;
 
@@ -328,7 +323,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
         where T: Serialize
     {
-        self.vec.push(try!(to_data(&value)));
+        self.vec.push(to_data(&value)?);
         Ok(())
     }
 
@@ -362,11 +357,10 @@ impl ser::SerializeMap for SerializeMap {
     where
         T: Serialize
     {
-        let key = self.next_key.take();
-        // Panic because this indicates a bug in the program rather than an
-        // expected failure.
-        let key = key.expect("serialize_value called before serialize_key");
-        self.map.insert(key, try!(to_data(&value)));
+        // Taking the key should only fail if this gets called before
+        // serialize_key, which is a bug in the library.
+        let key = self.next_key.take().ok_or(Error::MissingElements)?;
+        self.map.insert(key, to_data(&value)?);
         Ok(())
     }
 
diff --git a/src/error.rs b/src/error.rs
index f9a11610..054c5458 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,7 +1,6 @@
-use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as StdIoError;
-use std::result;
+use std::result::Result as StdResult;
 
 use parser;
 use encoder;
@@ -14,6 +13,7 @@ use encoder;
 pub enum Error {
     InvalidStr,
     NoFilename,
+    IncompleteSection,
     Io(StdIoError),
     Parser(parser::Error),
     Encoder(encoder::Error),
@@ -22,24 +22,19 @@ pub enum Error {
     __Nonexhaustive,
 }
 
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = StdResult<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
-    }
-}
-
-impl StdError for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::InvalidStr => "invalid str",
-            Error::NoFilename => "a filename must be provided",
-            Error::Io(ref err) => err.description(),
-            Error::Parser(ref err) => err.description(),
-            Error::Encoder(ref err) => err.description(),
+        write!(f, "{}", match *self {
+            Error::InvalidStr => "invalid str".to_string(),
+            Error::NoFilename => "a filename must be provided".to_string(),
+            Error::IncompleteSection => "a section wasn't completed".to_string(), // Is there a better way to put this?
+            Error::Io(ref err) => err.to_string(),
+            Error::Parser(ref err) => err.to_string(),
+            Error::Encoder(ref err) => err.to_string(),
             Error::__Nonexhaustive => unreachable!(),
-        }
+        })
     }
 }
 
diff --git a/src/macros.rs b/src/macros.rs
index 50e9d6d6..5662948a 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,11 +1,9 @@
-/// This should be the only place to panic inside non-test code.
-// TODO: ensure no panics elsewhere via clippy
 macro_rules! bug {
     ($msg:expr) => ({
         bug!("{}", $msg)
     });
     ($fmt:expr, $($arg:tt)+) => ({
-        panic!(
+        error!(
             concat!("bug: ",
                     $fmt,
                     ". Please report this issue on GitHub if you find \
diff --git a/src/parser.rs b/src/parser.rs
index ecbf3d65..991316c7 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -2,6 +2,9 @@ use std::error::Error as StdError;
 use std::mem;
 use std::fmt;
 
+// for bug!
+use log::{log, error};
+
 /// `Token` is a section of a compiled mustache string.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Token {
@@ -32,39 +35,21 @@ pub enum Error {
     __Nonexhaustive,
 }
 
-impl StdError for Error {
-    fn description(&self) -> &'static str {
-        match *self {
-            Error::BadClosingTag(..) => "found a malformed closing tag",
-            Error::UnclosedTag => "found an unclosed tag",
-            Error::UnclosedSection(..) => "found an unclosed section",
-            Error::UnbalancedUnescapeTag => "found an unbalanced unescape tag",
-            Error::EmptyTag => "found an empty tag",
-            Error::EarlySectionClose(..) => "found a closing tag for an unopened section",
-            Error::MissingSetDelimeterClosingTag => "missing the new closing tag in set delimeter tag",
-            Error::InvalidSetDelimeterSyntax => "invalid set delimeter tag syntax",
-            Error::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
+impl StdError for Error { }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Provide more information where possible
         match *self {
-            Error::BadClosingTag(actual, expected) => {
-                write!(f,
-                       "character {:?} was unexpected in the closing tag, expected {:?}",
-                       actual,
-                       expected)
-            }
-            Error::UnclosedSection(ref name) => {
-                write!(f, "found an unclosed section: {:?}", name)
-            },
-            Error::EarlySectionClose(ref name) => {
-                write!(f, "found a closing tag for an unopened section {:?}", name)
-            },
-            _ => write!(f, "{}", self.description()),
+            Error::BadClosingTag(actual, expected) => write!(f, "character {:?} was unexpected in the closing tag, expected {:?}", actual, expected),
+            Error::UnclosedSection(ref name) => write!(f, "found an unclosed section: {:?}", name),
+            Error::EarlySectionClose(ref name) => write!(f, "found a closing tag for an unopened section {:?}", name),
+            Error::UnclosedTag => write!(f, "found an unclosed tag"),
+            Error::UnbalancedUnescapeTag => write!(f, "found an unbalanced unescape tag"),
+            Error::EmptyTag => write!(f, "found an empty tag",),
+            Error::MissingSetDelimeterClosingTag => write!(f, "missing the new closing tag in set delimeter tag"),
+            Error::InvalidSetDelimeterSyntax => write!(f, "invalid set delimeter tag syntax"),
+            Error::__Nonexhaustive => unreachable!(),
         }
     }
 }
@@ -213,7 +198,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                             self.state = ParserState::ClosingTag;
                             self.bump();
                         } else {
-                            try!(self.add_tag());
+                            self.add_tag()?;
                             self.state = ParserState::Text;
                         }
                     } else {
@@ -224,7 +209,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                 ParserState::ClosingTag => {
                     if ch == self.closing_tag_chars[self.tag_position] {
                         if self.tag_position == self.closing_tag_chars.len() - 1 {
-                            try!(self.add_tag());
+                            self.add_tag()?;
                             self.state = ParserState::Text;
                         } else {
                             self.state = ParserState::Tag;
@@ -362,7 +347,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
         let mut content = String::new();
         mem::swap(&mut content, &mut self.content);
         let len = content.len();
-        try!(deny_blank(&content));
+        deny_blank(&content)?;
         let content = content;
 
         match content.as_bytes()[0] as char {
@@ -372,13 +357,13 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             }
             '&' => {
                 let name = &content[1..len];
-                let name = try!(get_name_or_implicit(name));
+                let name = get_name_or_implicit(name)?;
                 self.tokens.push(Token::UnescapedTag(name, tag));
             }
             '{' => {
                 if content.ends_with('}') {
                     let name = &content[1..len - 1];
-                    let name = try!(get_name_or_implicit(name));
+                    let name = get_name_or_implicit(name)?;
                     self.tokens.push(Token::UnescapedTag(name, tag));
                 } else {
                     return Err(Error::UnbalancedUnescapeTag)
@@ -387,19 +372,19 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             '#' => {
                 let newlined = self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 self.tokens.push(Token::IncompleteSection(name, false, tag, newlined));
             }
             '^' => {
                 let newlined = self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 self.tokens.push(Token::IncompleteSection(name, true, tag, newlined));
             }
             '/' => {
                 self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 let mut children: Vec<Token> = Vec::new();
 
                 loop {
@@ -458,14 +443,12 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                     }
                 }
             }
-            '>' => {
-                try!(self.add_partial(&content, tag));
-            }
+            '>' => self.add_partial(&content, tag)?,
             '=' => {
                 self.eat_whitespace();
 
                 if len > 2usize && content.ends_with('=') {
-                    let s = try!(deny_blank(&content[1..len - 1]));
+                    let s = deny_blank(&content[1..len - 1])?;
 
                     let pos = s.find(char::is_whitespace);
                     let pos = match pos {
@@ -492,7 +475,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             _ => {
                 // If the name is "." then we want the top element, which we represent with
                 // an empty name.
-                let name = try!(get_name_or_implicit(&content));
+                let name = get_name_or_implicit(&content)?;
                 self.tokens.push(Token::EscapedTag(name, tag));
             }
         };
@@ -530,7 +513,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
         // partial. So instead, we'll cache the partials we used and look them
         // up later.
         let name = &content[1..content.len()];
-        let name = try!(deny_blank(name));
+        let name = deny_blank(name)?;
 
         self.tokens.push(Token::Partial(name.into(), indent, tag));
         self.partials.push(name.into());
@@ -560,7 +543,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
 fn get_name_or_implicit(name: &str) -> Result<Vec<String>, Error> {
     // If the name is "." then we want the top element, which we represent with
     // an empty name.
-    let name = try!(deny_blank(&name));
+    let name = deny_blank(&name)?;
     Ok(if name == "." {
         Vec::new()
     } else {
diff --git a/src/template.rs b/src/template.rs
index e97b2061..a5a7b519 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -1,14 +1,15 @@
-use std::io::Write;
 use std::collections::HashMap;
 use std::mem;
-use std::result;
+use std::io::Write;
 use std::str;
-use serde::Serialize;
 
 use compiler::Compiler;
+// for bug!
+use log::{log, error};
 use parser::Token;
+use serde::Serialize;
 
-use super::{Context, Data, Result, to_data, Error};
+use super::{Context, Data, Error, Result, to_data};
 
 /// `Template` represents a compiled mustache file.
 #[derive(Debug, Clone)]
@@ -47,17 +48,17 @@ impl Template {
     }
 
     /// Renders the template to a `String` with the `Encodable` data.
-    pub fn render_to_string<T: Serialize>(&self, data: &T) -> result::Result<String, Error> {
+    pub fn render_to_string<T: Serialize>(&self, data: &T) -> Result<String> {
         let mut output = Vec::new();
-        try!(self.render(&mut output, data));
-        Ok(String::from_utf8(output).expect("invalid utf-8 in template"))
+        self.render(&mut output, data)?;
+        String::from_utf8(output).map_err(|_| Error::InvalidStr)
     }
 
     /// Renders the template to a `String` with the `Data`.
-    pub fn render_data_to_string(&self, data: &Data) -> result::Result<String, Error> {
+    pub fn render_data_to_string(&self, data: &Data) -> Result<String> {
         let mut output = Vec::new();
-        try!(self.render_data(&mut output, data));
-        Ok(String::from_utf8(output).expect("invalid utf-8 in template"))
+        self.render_data(&mut output, data)?;
+        String::from_utf8(output).map_err(|_| Error::InvalidStr)
     }
 }
 
@@ -80,7 +81,7 @@ impl<'a> RenderContext<'a> {
 
     fn render<W: Write>(&mut self, wr: &mut W, stack: &mut Vec<&Data>, tokens: &[Token]) -> Result<()> {
         for token in tokens.iter() {
-            try!(self.render_token(wr, stack, token));
+            self.render_token(wr, stack, token)?;
         }
 
         Ok(())
@@ -107,13 +108,14 @@ impl<'a> RenderContext<'a> {
                 self.render_partial(wr, stack, name, indent)
             }
             Token::IncompleteSection(..) => {
-                bug!("render_token should not encounter IncompleteSections")
+                bug!("render_token should not encounter IncompleteSections");
+                Err(Error::IncompleteSection)
             }
         }
     }
 
     fn write_tracking_newlines<W: Write>(&mut self, wr: &mut W, value: &str) -> Result<()> {
-        try!(wr.write_all(value.as_bytes()));
+        wr.write_all(value.as_bytes())?;
         self.line_start = match value.chars().last() {
             None => self.line_start, // None == ""
             Some('\n') => true,
@@ -125,7 +127,7 @@ impl<'a> RenderContext<'a> {
 
     fn write_indent<W: Write>(&mut self, wr: &mut W) -> Result<()> {
         if self.line_start {
-            try!(wr.write_all(self.indent.as_bytes()));
+            wr.write_all(self.indent.as_bytes())?;
         }
 
         Ok(())
@@ -155,10 +157,10 @@ impl<'a> RenderContext<'a> {
                 };
 
                 if line.as_bytes()[0] != b'\n' {
-                    try!(self.write_indent(wr));
+                    self.write_indent(wr)?;
                 }
 
-                try!(self.write_tracking_newlines(wr, line));
+                self.write_tracking_newlines(wr, line)?;
             }
         }
 
@@ -168,28 +170,16 @@ impl<'a> RenderContext<'a> {
     fn render_etag<W: Write>(&mut self, wr: &mut W, stack: &mut Vec<&Data>, path: &[String]) -> Result<()> {
         let mut bytes = vec![];
 
-        try!(self.render_utag(&mut bytes, stack, path));
+        self.render_utag(&mut bytes, stack, path)?;
 
         for b in bytes {
             match b {
-                b'<' => {
-                    try!(wr.write_all(b"&lt;"));
-                }
-                b'>' => {
-                    try!(wr.write_all(b"&gt;"));
-                }
-                b'&' => {
-                    try!(wr.write_all(b"&amp;"));
-                }
-                b'"' => {
-                    try!(wr.write_all(b"&quot;"));
-                }
-                b'\'' => {
-                    try!(wr.write_all(b"&#39;"));
-                }
-                _ => {
-                    try!(wr.write_all(&[b]));
-                }
+                b'<' => wr.write_all(b"&lt;")?,
+                b'>' => wr.write_all(b"&gt;")?,
+                b'&' => wr.write_all(b"&amp;")?,
+                b'"' => wr.write_all(b"&quot;")?,
+                b'\'' => wr.write_all(b"&#39;")?,
+                _ => wr.write_all(&[b])?,
             }
         }
 
@@ -200,7 +190,7 @@ impl<'a> RenderContext<'a> {
         match self.find(path, stack) {
             None => {}
             Some(value) => {
-                try!(self.write_indent(wr));
+                self.write_indent(wr)?;
 
                 // Currently this doesn't allow Option<Option<Foo>>, which
                 // would be un-nameable in the view anyway, so I'm unsure if it's
@@ -212,14 +202,14 @@ impl<'a> RenderContext<'a> {
 
                 match *value {
                     Data::String(ref value) => {
-                        try!(self.write_tracking_newlines(wr, value));
+                        self.write_tracking_newlines(wr, value)?;
                     }
 
                     // etags and utags use the default delimiter.
                     Data::Fun(ref fcell) => {
                         let f = &mut *fcell.borrow_mut();
-                        let tokens = try!(self.render_fun("", "{{", "}}", f));
-                        try!(self.render(wr, stack, &tokens));
+                        let tokens = self.render_fun("", "{{", "}}", f)?;
+                        self.render(wr, stack, &tokens)?;
                     }
 
                     ref value => {
@@ -265,33 +255,31 @@ impl<'a> RenderContext<'a> {
                     Data::Null => {
                         // do nothing
                     }
-                    Data::Bool(true) => {
-                        try!(self.render(wr, stack, children));
-                    }
-                    Data::Bool(false) => {}
+                    Data::Bool(true) => self.render(wr, stack, children)?,
+                    Data::Bool(false) => (),
                     Data::String(ref val) => {
                         if !val.is_empty() {
                             stack.push(value);
-                            try!(self.render(wr, stack, children));
+                            self.render(wr, stack, children)?;
                             stack.pop();
                         }
                     }
                     Data::Vec(ref vs) => {
                         for v in vs.iter() {
                             stack.push(v);
-                            try!(self.render(wr, stack, children));
+                            self.render(wr, stack, children)?;
                             stack.pop();
                         }
                     }
                     Data::Map(_) => {
                         stack.push(value);
-                        try!(self.render(wr, stack, children));
+                        self.render(wr, stack, children)?;
                         stack.pop();
                     }
                     Data::Fun(ref fcell) => {
                         let f = &mut *fcell.borrow_mut();
-                        let tokens = try!(self.render_fun(src, otag, ctag, f));
-                        try!(self.render(wr, stack, &tokens));
+                        let tokens = self.render_fun(src, otag, ctag, f)?;
+                        self.render(wr, stack, &tokens)?;
                     }
                     Data::Fun2(ref fcell) => {
                         let f = &mut *fcell.borrow_mut();
@@ -350,12 +338,12 @@ impl<'a> RenderContext<'a> {
                                 name: &str,
                                 indent: &str) -> Result<()> {
         match self.template.partials.get(name) {
-            None => {}
+            None => (),
             Some(ref tokens) => {
                 let mut indent = self.indent.clone() + indent;
 
                 mem::swap(&mut self.indent, &mut indent);
-                try!(self.render(wr, stack, &tokens));
+                self.render(wr, stack, &tokens)?;
                 mem::swap(&mut self.indent, &mut indent);
             }
         };
@@ -367,7 +355,7 @@ impl<'a> RenderContext<'a> {
                   src: &str,
                   otag: &str,
                   ctag: &str,
-                  f: &mut Box<FnMut(String) -> String + Send + 'static>)
+                  f: &mut Box<dyn FnMut(String) -> String + Send + 'static>)
                   -> Result<Vec<Token>> {
         let src = f(src.to_string());
 
@@ -377,7 +365,7 @@ impl<'a> RenderContext<'a> {
                                           otag.to_string(),
                                           ctag.to_string());
 
-        let (tokens, _) = try!(compiler.compile());
+        let (tokens, _) = compiler.compile()?;
         Ok(tokens)
     }
 
diff --git a/tests/template.rs b/tests/template.rs
index fad2292a..f6053a94 100644
--- a/tests/template.rs
+++ b/tests/template.rs
@@ -52,7 +52,7 @@ where T: Serialize
     let template = compile_str(template);
 
     let mut bytes = vec![];
-    try!(template.render(&mut bytes, data));
+    template.render(&mut bytes, data)?;
 
     Ok(String::from_utf8(bytes).expect("Failed to encode String"))
 }
@@ -300,8 +300,6 @@ fn render_data(template: &Template, data: &Data) -> String {
 
 #[test]
 fn test_write_failure() {
-    use std::error::Error;
-
     let mut ctx = HashMap::new();
     ctx.insert("name", "foobar");
 
@@ -317,9 +315,10 @@ fn test_write_failure() {
     ctx.insert("name", "longerthansix");
 
     let mut writer: &mut [u8] = &mut buffer;
-    assert_let!(Err(e) = template.render(&mut writer, &ctx) => {
-        assert_eq!(e.description(), "failed to write whole buffer")
-    })
+    assert!(template.render(&mut writer, &ctx).is_err());
+    //assert_let!(Err(e) = template.render(&mut writer, &ctx) => {
+    //    assert_eq!(format!("{}", e.to_string()), "failed to write whole buffer")
+    //})
 }
 
 #[test]

From 0d19f2d65584a086c3a49987c03d2491e7fe9f8c Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Wed, 1 Apr 2026 21:21:04 +0200
Subject: [PATCH 08/10] fix remaining warnings: add dyn to trait objects, try!
 to ?, remove unnecessary parens

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Change-Id: I2eaffd01f77bb8aec0ee4a3ebf2b404bb0e2ae25
---
 src/builder.rs  | 2 +-
 src/data.rs     | 2 +-
 src/template.rs | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 82f21292..f3f772b2 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -152,7 +152,7 @@ impl MapBuilder {
     #[inline]
     pub fn insert_fn2<K: ToString, F>(self, key: K, f: F) -> MapBuilder
     where
-        F: FnMut(String, &mut (FnMut(String) -> String)) -> String + Send + 'static,
+        F: FnMut(String, &mut dyn FnMut(String) -> String) -> String + Send + 'static,
     {
         let MapBuilder { mut data } = self;
         data.insert(key.to_string(), Data::Fun2(RefCell::new(Box::new(f))));
diff --git a/src/data.rs b/src/data.rs
index faeb171a..d821675f 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -12,7 +12,7 @@ pub enum Data {
     Vec(Vec<Data>),
     Map(HashMap<String, Data>),
     Fun(RefCell<Box<dyn FnMut(String) -> String + Send>>),
-    Fun2(RefCell<Box<dyn FnMut(String, &mut (dyn FnMut(String) -> String)) -> String + Send>>),
+    Fun2(RefCell<Box<dyn FnMut(String, &mut dyn FnMut(String) -> String) -> String + Send>>),
 }
 
 impl PartialEq for Data {
diff --git a/src/template.rs b/src/template.rs
index a5a7b519..1f4ddc34 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -300,7 +300,7 @@ impl<'a> RenderContext<'a> {
                                 match compiler.compile() {
                                     Ok((tokens, _)) => {
                                         /* a trick to reset the flag is to pass an empty string */
-                                        self.inner_fn2_rendered = (src.len() > 0);
+                                        self.inner_fn2_rendered = src.len() > 0;
                                         self.render(&mut vw, stack, &tokens).unwrap_or(())
                                     }
                                     _ => (),
@@ -311,7 +311,7 @@ impl<'a> RenderContext<'a> {
                         let src = f(src.to_string(), &mut f0);
                         if self.inner_fn2_rendered {
                             self.inner_fn2_rendered = false;
-                            try!(self.render_text(wr, &src));
+                            self.render_text(wr, &src)?;
                         } else {
                             let compiler = Compiler::new_with(
                                 self.template.ctx.clone(),
@@ -321,8 +321,8 @@ impl<'a> RenderContext<'a> {
                                 ctag.to_string(),
                             );
 
-                            let (tokens, _) = try!(compiler.compile());
-                            try!(self.render(wr, stack, &tokens));
+                            let (tokens, _) = compiler.compile()?;
+                            self.render(wr, stack, &tokens)?;
                         }
                     }
                 }

From 9fc30736dcbd9d816976fe2ddb39bfd1a0635471 Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Wed, 1 Apr 2026 21:21:41 +0200
Subject: [PATCH 09/10] add autotests = false to suppress Cargo test target
 inference warning

The test files in tests/ (builder.rs, macros.rs, template.rs) are
submodules of test.rs, not standalone test targets.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Change-Id: Ie9b1bfa77d283b64abead5e20aa29394c029b321
---
 Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Cargo.toml b/Cargo.toml
index 4586cea5..44a4dbaa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,6 +4,7 @@ description = "Rust implementation of Mustache"
 repository = "https://github.com/nickel-org/rust-mustache"
 documentation = "http://nickel-org.github.io/rust-mustache"
 version = "0.9.0"
+autotests = false
 authors = ["erick.tryzelaar@gmail.com"]
 license = "MIT/Apache-2.0"
 

From ddf5e7bf97964f240e5d5e046351ea6e6ece86e7 Mon Sep 17 00:00:00 2001
From: Andrew Yourtchenko <ayourtch@gmail.com>
Date: Wed, 1 Apr 2026 21:23:54 +0200
Subject: [PATCH 10/10] set edition = "2021" and update imports to use crate::
 paths

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Change-Id: Ibd3f546cb822bc7e2bfcaff0fde89be69ac0fa8f
---
 Cargo.toml      |  1 +
 src/builder.rs  |  2 +-
 src/compiler.rs | 10 +++++-----
 src/context.rs  |  6 +++---
 src/error.rs    |  4 ++--
 src/template.rs |  4 ++--
 6 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 44a4dbaa..48120590 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,7 @@ repository = "https://github.com/nickel-org/rust-mustache"
 documentation = "http://nickel-org.github.io/rust-mustache"
 version = "0.9.0"
 autotests = false
+edition = "2021"
 authors = ["erick.tryzelaar@gmail.com"]
 license = "MIT/Apache-2.0"
 
diff --git a/src/builder.rs b/src/builder.rs
index f3f772b2..ecdddc29 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -3,7 +3,7 @@ use std::string::ToString;
 use std::collections::HashMap;
 use serde::Serialize;
 
-use encoder::Error;
+use crate::encoder::Error;
 use super::{Data, to_data};
 
 /// `MapBuilder` is a helper type that construct `Data` types.
diff --git a/src/compiler.rs b/src/compiler.rs
index b40e5581..834cfd2a 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -3,10 +3,10 @@ use std::io::ErrorKind::NotFound;
 use std::io::Read;
 use std::fs::File;
 
-use parser::{Parser, Token};
+use crate::parser::{Parser, Token};
 use super::Context;
 
-use Result;
+use crate::Result;
 
 pub type PartialsMap = HashMap<String, Vec<Token>>;
 
@@ -101,9 +101,9 @@ impl<T: Iterator<Item = char>> Compiler<T> {
 mod tests {
     use std::path::PathBuf;
 
-    use parser::Token;
-    use compiler::Compiler;
-    use context::Context;
+    use crate::parser::Token;
+    use crate::compiler::Compiler;
+    use crate::context::Context;
 
     fn compile_str(template: &str) -> Vec<Token> {
         let ctx = Context::new(PathBuf::from("."));
diff --git a/src/context.rs b/src/context.rs
index 16ef0dbc..906ad888 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -1,6 +1,6 @@
-use template::{self, Template};
-use compiler;
-use {Result, Error};
+use crate::template::{self, Template};
+use crate::compiler;
+use crate::{Result, Error};
 
 use std::fmt;
 use std::fs::File;
diff --git a/src/error.rs b/src/error.rs
index 054c5458..cc0eef10 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,8 +2,8 @@ use std::fmt;
 use std::io::Error as StdIoError;
 use std::result::Result as StdResult;
 
-use parser;
-use encoder;
+use crate::parser;
+use crate::encoder;
 
 /// Error type for any error within this library.
 ///
diff --git a/src/template.rs b/src/template.rs
index 1f4ddc34..263abdce 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -3,10 +3,10 @@ use std::mem;
 use std::io::Write;
 use std::str;
 
-use compiler::Compiler;
+use crate::compiler::Compiler;
 // for bug!
 use log::{log, error};
-use parser::Token;
+use crate::parser::Token;
 use serde::Serialize;
 
 use super::{Context, Data, Error, Result, to_data};