From 0996a6c98a6c5522a13b7f66db0a10ea10a8028c Mon Sep 17 00:00:00 2001
From: Ed Lewis <edward.richard.lewis@gmail.com>
Date: Tue, 3 Mar 2020 15:18:35 +0000
Subject: [PATCH 01/13] chore(travis): remove old rust versions from build
 matrix

Fixes #70
---
 .travis.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 5590434..004d35f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,8 +6,6 @@ cache:
     - target
 
 rust:
-- 1.16.0
-- 1.17.0
 - stable
 - nightly
 - beta

From 5cd7a565712c29923029bf4c509f4e9a379bed80 Mon Sep 17 00:00:00 2001
From: Kevin Butler <kb@honeypot.io>
Date: Sun, 12 Aug 2018 14:57:28 +0200
Subject: [PATCH 02/13] fix(template): allow rendering boolean values as leafs

Fixes #60.
---
 src/template.rs   |  5 +++++
 tests/template.rs | 45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+)

diff --git a/src/template.rs b/src/template.rs
index 1d6825e..daf325b 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -220,6 +220,11 @@ impl<'a> RenderContext<'a> {
                         try!(self.render(wr, stack, &tokens));
                     }
 
+                    Data::Bool(val) => {
+                        let s = if val { "true" } else { "false" };
+                        try!(self.write_tracking_newlines(wr, s));
+                    }
+
                     ref value => {
                         bug!("render_utag: unexpected value {:?}", value);
                     }
diff --git a/tests/template.rs b/tests/template.rs
index fad2292..8c6a472 100644
--- a/tests/template.rs
+++ b/tests/template.rs
@@ -216,6 +216,51 @@ mod context_search {
         assert_eq!(rendered, expected);
     }
 
+    #[test]
+    fn renders_bool() {
+        let template = compile_str(
+"{{bool}}
+#map{{#outer}}
+    {{#bool}}
+        #bool
+        #vec{{#inner}}{{{.}}}{{/inner}}/vec
+    {{/bool}}\n\
+    {{^not_ok}}
+        ^not_ok
+        #vec{{#inner}}{{{.}}}{{/inner}}/vec
+    {{/not_ok}}\n\
+{{/outer}}
+/map
+{{ok}}");
+        let ctx = MapBuilder::new()
+            .insert_bool("bool", false)
+            .insert_bool("not_ok", false)
+            .insert_map("outer", |map| {
+                map.insert_bool("bool", true)
+                    .insert_vec("inner", |vec| {
+                        vec.push_bool(false)
+                            .push_bool(true)
+                            .push_bool(false)
+                    })
+            })
+            .insert_bool("ok", true)
+            .build();
+
+        let expected = "false
+#map
+        #bool
+        #vecfalsetruefalse/vec
+
+        ^not_ok
+        #vecfalsetruefalse/vec
+
+/map
+true";
+        let rendered = render_data(&template, &ctx);
+        println!("{}\n----\n{}", rendered, expected);
+        assert_eq!(rendered, expected);
+    }
+
     #[test]
     fn from_base() {
         let template = "\

From 4dbc137bd06d1b471a735dbf4b213a3713eb79d8 Mon Sep 17 00:00:00 2001
From: Bastien Orivel <eijebong@bananium.fr>
Date: Fri, 24 May 2019 19:09:58 +0200
Subject: [PATCH 03/13] chore(log): update log to 0.4

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4586cea..ca75359 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,7 @@ license = "MIT/Apache-2.0"
 unstable = []
 
 [dependencies]
-log = "0.3.5"
+log = "0.4"
 serde = "1.0.0"
 
 [dev-dependencies]

From af5ec8c2f6eb7acd9ad7600be9330e083c96d2c9 Mon Sep 17 00:00:00 2001
From: Bastien Orivel <eijebong@bananium.fr>
Date: Fri, 24 May 2019 19:15:30 +0200
Subject: [PATCH 04/13] chore(*): switch from tempdir to tempfile

tempdir is deprecated
---
 Cargo.toml        | 2 +-
 tests/template.rs | 4 ++--
 tests/test.rs     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ca75359..d46f3d3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ serde = "1.0.0"
 [dev-dependencies]
 serde_derive = "1.0.0"
 serde_json = "1.0.0"
-tempdir = "0.3.4"
+tempfile = "3"
 
 [[test]]
 name = "test"
diff --git a/tests/template.rs b/tests/template.rs
index 8c6a472..de82d78 100644
--- a/tests/template.rs
+++ b/tests/template.rs
@@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use tempdir::TempDir;
+use tempfile::Builder;
 use std::fmt::Debug;
 use std::fs::File;
 use std::io::Write;
@@ -538,7 +538,7 @@ fn run_test(test: serde_json::Map<String, Json>, data: Data) {
 
     // Make a temporary dir where we'll store our partials. This is to
     // avoid a race on filenames.
-    let tmpdir = TempDir::new("").expect("Failed to make tempdir");
+    let tmpdir = Builder::new().tempdir().expect("Failed to make tempdir");
 
     if let Some(value) = test.get("partials") {
         write_partials(tmpdir.path(), value)
diff --git a/tests/test.rs b/tests/test.rs
index a1c5017..bdfd0e0 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,7 +1,7 @@
 extern crate mustache;
 extern crate serde;
 extern crate serde_json;
-extern crate tempdir;
+extern crate tempfile;
 
 #[macro_use] extern crate serde_derive;
 

From 222303308c1f00f0d5fd3cc5b63560deb226dd23 Mon Sep 17 00:00:00 2001
From: Bastien Orivel <eijebong@bananium.fr>
Date: Fri, 24 May 2019 19:16:01 +0200
Subject: [PATCH 05/13] feat(version): 0.9.1

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index d46f3d3..d15c8b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@ name = "mustache"
 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"
+version = "0.9.1"
 authors = ["erick.tryzelaar@gmail.com"]
 license = "MIT/Apache-2.0"
 

From 11eb0ea72b30cf827d044af273933517ee699b1d Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Sat, 3 Apr 2021 17:02:59 -0400
Subject: [PATCH 06/13] 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.
---
 src/compiler.rs   |  6 ++--
 src/context.rs    |  8 ++---
 src/data.rs       | 12 +++++--
 src/encoder.rs    | 14 ++++----
 src/error.rs      |  6 ++--
 src/macros.rs     |  4 +--
 src/parser.rs     | 33 ++++++++---------
 src/template.rs   | 92 +++++++++++++++++++++--------------------------
 tests/template.rs | 11 +++---
 9 files changed, 89 insertions(+), 97 deletions(-)

diff --git a/src/compiler.rs b/src/compiler.rs
index dcd6eae..b40e558 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 e95aef6..16ef0db 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 b71c79f..dbb7b20 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -2,13 +2,16 @@ 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>>),
+    Fun(RefCell<Box<dyn FnMut(String) -> String + Send>>),
 }
 
 impl PartialEq for Data {
@@ -20,7 +23,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,
         }
     }
@@ -37,4 +43,4 @@ impl fmt::Debug for Data {
             Data::Fun(_) => write!(f, "Fun(...)"),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/encoder.rs b/src/encoder.rs
index 947c836..9ae5f40 100644
--- a/src/encoder.rs
+++ b/src/encoder.rs
@@ -35,8 +35,7 @@ pub type Result<T> = result::Result<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use std::error::Error;
-        self.description().fmt(f)
+        self.to_string().fmt(f)
     }
 }
 
@@ -328,7 +327,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 +361,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 f9a1161..0aa7657 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,4 +1,3 @@
-use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as StdIoError;
 use std::result;
@@ -14,6 +13,7 @@ use encoder;
 pub enum Error {
     InvalidStr,
     NoFilename,
+    IncompleteSection,
     Io(StdIoError),
     Parser(parser::Error),
     Encoder(encoder::Error),
@@ -26,10 +26,11 @@ pub type Result<T> = result::Result<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
+        self.to_string().fmt(f)
     }
 }
 
+/*
 impl StdError for Error {
     fn description(&self) -> &str {
         match *self {
@@ -42,6 +43,7 @@ impl StdError for Error {
         }
     }
 }
+*/
 
 impl From<StdIoError> for Error {
     fn from(err: StdIoError) -> Error {
diff --git a/src/macros.rs b/src/macros.rs
index 50e9d6d..5662948 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 ecbf3d6..7d7274f 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 {
@@ -64,7 +67,7 @@ impl fmt::Display for Error {
             Error::EarlySectionClose(ref name) => {
                 write!(f, "found a closing tag for an unopened section {:?}", name)
             },
-            _ => write!(f, "{}", self.description()),
+            _ => write!(f, "{}", self.to_string()),
         }
     }
 }
@@ -213,7 +216,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 +227,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 +365,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 +375,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 +390,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 +461,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 +493,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 +531,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 +561,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 1d6825e..49be26a 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)
     }
 }
 
@@ -78,7 +79,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(())
@@ -105,13 +106,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,
@@ -123,7 +125,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(())
@@ -153,10 +155,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)?;
             }
         }
 
@@ -166,28 +168,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])?,
             }
         }
 
@@ -198,7 +188,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
@@ -210,14 +200,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 => {
@@ -263,33 +253,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)?;
                     }
                 }
             }
@@ -304,12 +292,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);
             }
         };
@@ -321,7 +309,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());
 
@@ -331,7 +319,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 fad2292..f6053a9 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 40bc999665eb8ef0e99e737a8fae2a9713ca1313 Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Sun, 4 Apr 2021 14:51:30 -0400
Subject: [PATCH 07/13] 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".
---
 .travis.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 5590434..02b7561 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

From 5ec95d03396e1015a608bce809da51763011a46d Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Sun, 4 Apr 2021 15:18:36 -0400
Subject: [PATCH 08/13] Prevent possible infinite recursion

`cargo clippy` warned of infinite recursion, so let's heed the warning
---
 src/encoder.rs | 18 +++++++-----------
 src/error.rs   | 27 ++++++++++-----------------
 src/parser.rs  | 38 ++++++++++----------------------------
 3 files changed, 27 insertions(+), 56 deletions(-)

diff --git a/src/encoder.rs b/src/encoder.rs
index 9ae5f40..c333b34 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,17 +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 {
-        self.to_string().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",
@@ -49,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;
 
diff --git a/src/error.rs b/src/error.rs
index 0aa7657..054c545 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,6 @@
 use std::fmt;
 use std::io::Error as StdIoError;
-use std::result;
+use std::result::Result as StdResult;
 
 use parser;
 use encoder;
@@ -22,28 +22,21 @@ 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.to_string().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!(),
-        }
+        })
     }
 }
-*/
 
 impl From<StdIoError> for Error {
     fn from(err: StdIoError) -> Error {
diff --git a/src/parser.rs b/src/parser.rs
index 7d7274f..991316c 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -35,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.to_string()),
+            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!(),
         }
     }
 }

From 94afdba91605b7ab9265e0b1b35e7019e1c5f94d Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Sun, 4 Apr 2021 15:41:14 -0400
Subject: [PATCH 09/13] Eliminate most of the clippy warnings

---
 src/builder.rs  | 24 ++++++++++++------------
 src/compiler.rs | 12 +++---------
 src/encoder.rs  |  5 +----
 src/error.rs    |  5 +----
 src/lib.rs      |  2 +-
 src/parser.rs   | 13 +++++--------
 src/template.rs | 21 +++++++--------------
 7 files changed, 30 insertions(+), 52 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 83c5ca4..d1b48dc 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -37,7 +37,7 @@ impl MapBuilder {
         let MapBuilder { mut data } = self;
         let value = to_data(value)?;
         data.insert(key.into(), value);
-        Ok(MapBuilder { data: data })
+        Ok(MapBuilder { data })
     }
 
     /// Add a `String` to the `MapBuilder`.
@@ -56,7 +56,7 @@ impl MapBuilder {
     {
         let MapBuilder { mut data } = self;
         data.insert(key.into(), Data::String(value.into()));
-        MapBuilder { data: data }
+        MapBuilder { data }
     }
 
     /// Add a `bool` to the `MapBuilder`.
@@ -74,7 +74,7 @@ impl MapBuilder {
     {
         let MapBuilder { mut data } = self;
         data.insert(key.into(), Data::Bool(value));
-        MapBuilder { data: data }
+        MapBuilder { data }
     }
 
     /// Add a `Vec` to the `MapBuilder`.
@@ -97,7 +97,7 @@ impl MapBuilder {
         let MapBuilder { mut data } = self;
         let builder = f(VecBuilder::new());
         data.insert(key.into(), builder.build());
-        MapBuilder { data: data }
+        MapBuilder { data }
     }
 
     /// Add a `Map` to the `MapBuilder`.
@@ -126,7 +126,7 @@ impl MapBuilder {
         let MapBuilder { mut data } = self;
         let builder = f(MapBuilder::new());
         data.insert(key.into(), builder.build());
-        MapBuilder { data: data }
+        MapBuilder { data }
     }
 
     /// Add a function to the `MapBuilder`.
@@ -147,7 +147,7 @@ impl MapBuilder {
     {
         let MapBuilder { mut data } = self;
         data.insert(key.to_string(), Data::Fun(RefCell::new(Box::new(f))));
-        MapBuilder { data: data }
+        MapBuilder { data }
     }
 
     /// Return the built `Data`.
@@ -183,7 +183,7 @@ impl VecBuilder {
         let VecBuilder { mut data } = self;
         let value = to_data(value)?;
         data.push(value);
-        Ok(VecBuilder { data: data })
+        Ok(VecBuilder { data })
     }
 
     /// Add a `String` to the `VecBuilder`.
@@ -199,7 +199,7 @@ impl VecBuilder {
     pub fn push_str<T: ToString>(self, value: T) -> VecBuilder {
         let VecBuilder { mut data } = self;
         data.push(Data::String(value.to_string()));
-        VecBuilder { data: data }
+        VecBuilder { data }
     }
 
     /// Add a `bool` to the `VecBuilder`.
@@ -215,7 +215,7 @@ impl VecBuilder {
     pub fn push_bool(self, value: bool) -> VecBuilder {
         let VecBuilder { mut data } = self;
         data.push(Data::Bool(value));
-        VecBuilder { data: data }
+        VecBuilder { data }
     }
 
     /// Add a `Vec` to the `MapBuilder`.
@@ -237,7 +237,7 @@ impl VecBuilder {
         let VecBuilder { mut data } = self;
         let builder = f(VecBuilder::new());
         data.push(builder.build());
-        VecBuilder { data: data }
+        VecBuilder { data }
     }
 
     /// Add a `Map` to the `VecBuilder`.
@@ -264,7 +264,7 @@ impl VecBuilder {
         let VecBuilder { mut data } = self;
         let builder = f(MapBuilder::new());
         data.push(builder.build());
-        VecBuilder { data: data }
+        VecBuilder { data }
     }
 
     /// Add a function to the `VecBuilder`.
@@ -285,7 +285,7 @@ impl VecBuilder {
     {
         let VecBuilder { mut data } = self;
         data.push(Data::Fun(RefCell::new(Box::new(f))));
-        VecBuilder { data: data }
+        VecBuilder { data }
     }
 
     #[inline]
diff --git a/src/compiler.rs b/src/compiler.rs
index b40e558..8c18684 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -23,8 +23,8 @@ impl<T: Iterator<Item = char>> Compiler<T> {
     /// Construct a default compiler.
     pub fn new(ctx: Context, reader: T) -> Compiler<T> {
         Compiler {
-            ctx: ctx,
-            reader: reader,
+            ctx,
+            reader,
             partials: HashMap::new(),
             otag: "{{".to_string(),
             ctag: "}}".to_string(),
@@ -38,13 +38,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
                     otag: String,
                     ctag: String)
                     -> Compiler<T> {
-        Compiler {
-            ctx: ctx,
-            reader: reader,
-            partials: partials,
-            otag: otag,
-            ctag: ctag,
-        }
+        Compiler { ctx, reader, partials, otag, ctag }
     }
 
     /// Compiles a template into a series of tokens.
diff --git a/src/encoder.rs b/src/encoder.rs
index c333b34..0c7cf1b 100644
--- a/src/encoder.rs
+++ b/src/encoder.rs
@@ -12,6 +12,7 @@ use super::{Data, to_data};
 /// This type is not intended to be matched exhaustively as new variants
 /// may be added in future without a version bump.
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum Error {
     NestedOptions,
     UnsupportedType,
@@ -19,9 +20,6 @@ pub enum Error {
     KeyIsNotString,
     NoDataToEncode,
     Message(String),
-
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
 impl serde::ser::Error for Error {
@@ -42,7 +40,6 @@ impl fmt::Display for Error {
             Error::KeyIsNotString => "key is not a string",
             Error::NoDataToEncode => "the encodable type created no data",
             Error::Message(ref s) => s,
-            Error::__Nonexhaustive => unreachable!(),
         })
     }
 }
diff --git a/src/error.rs b/src/error.rs
index 054c545..5604fde 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -10,6 +10,7 @@ use encoder;
 /// This type is not intended to be matched exhaustively as new variants
 /// may be added in future without a version bump.
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum Error {
     InvalidStr,
     NoFilename,
@@ -17,9 +18,6 @@ pub enum Error {
     Io(StdIoError),
     Parser(parser::Error),
     Encoder(encoder::Error),
-
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
 pub type Result<T> = StdResult<T, Error>;
@@ -33,7 +31,6 @@ impl fmt::Display for Error {
             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/lib.rs b/src/lib.rs
index 5a5e705..e0b4559 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -49,7 +49,7 @@ pub fn compile_path<U: AsRef<Path>>(path: U) -> Result<Template> {
 
     match path.file_name() {
         Some(filename) => {
-            let template_dir = path.parent().unwrap_or(Path::new("."));
+            let template_dir = path.parent().unwrap_or_else(|| Path::new("."));
             // FIXME: Should work with OsStrings, this will not use provided extension if
             // the extension is not utf8 :(
             let extension = path.extension().and_then(|ext| ext.to_str()).unwrap_or("mustache");
diff --git a/src/parser.rs b/src/parser.rs
index 991316c..da7d09a 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -21,6 +21,7 @@ pub enum Token {
 /// This type is not intended to be matched exhaustively as new variants
 /// may be added in future without a version bump.
 #[derive(Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Error {
     BadClosingTag(char, char),
     UnclosedTag,
@@ -30,9 +31,6 @@ pub enum Error {
     EarlySectionClose(String),
     MissingSetDelimeterClosingTag,
     InvalidSetDelimeterSyntax,
-
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
 impl StdError for Error { }
@@ -49,7 +47,6 @@ impl fmt::Display for Error {
             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!(),
         }
     }
 }
@@ -88,7 +85,7 @@ enum ParserState {
 impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
     pub fn new(reader: &'a mut T, opening_tag: &str, closing_tag: &str) -> Parser<'a, T> {
         let mut parser = Parser {
-            reader: reader,
+            reader,
             ch: None,
             lookahead: None,
             line: 1,
@@ -172,7 +169,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                             curly_brace_tag = false;
                             self.state = ParserState::Tag;
                         } else {
-                            self.tag_position = self.tag_position + 1;
+                            self.tag_position += 1;
                         }
                     } else {
                         // We don't have a tag, so add all the tag parts we've seen
@@ -523,7 +520,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
 
     fn not_otag(&mut self) {
         for (i, ch) in self.opening_tag_chars.iter().enumerate() {
-            if !(i < self.tag_position) {
+            if i >= self.tag_position {
                 break;
             }
             self.content.push(*ch);
@@ -532,7 +529,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
 
     fn not_ctag(&mut self) {
         for (i, ch) in self.closing_tag_chars.iter().enumerate() {
-            if !(i < self.tag_position) {
+            if i >= self.tag_position {
                 break;
             }
             self.content.push(*ch);
diff --git a/src/template.rs b/src/template.rs
index 49be26a..a9dd2b8 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -22,11 +22,7 @@ pub struct Template {
 /// Construct a `Template`. This is not part of the impl of Template so it is
 /// not exported outside of mustache.
 pub fn new(ctx: Context, tokens: Vec<Token>, partials: HashMap<String, Vec<Token>>) -> Template {
-    Template {
-        ctx: ctx,
-        tokens: tokens,
-        partials: partials,
-    }
+    Template { ctx, tokens, partials }
 }
 
 impl Template {
@@ -71,8 +67,8 @@ struct RenderContext<'a> {
 impl<'a> RenderContext<'a> {
     fn new(template: &'a Template) -> RenderContext<'a> {
         RenderContext {
-            template: template,
-            indent: "".to_string(),
+            template,
+            indent: String::new(),
             line_start: true,
         }
     }
@@ -340,14 +336,11 @@ impl<'a> RenderContext<'a> {
         let mut value = None;
 
         for data in stack.iter().rev() {
-            match **data {
-                Data::Map(ref m) => {
-                    if let Some(v) = m.get(&path[0]) {
-                        value = Some(v);
-                        break;
-                    }
+            if let Data::Map(m) = *data {
+                if let Some(v) = m.get(&path[0]) {
+                    value = Some(v);
+                    break;
                 }
-                _ => { /* continue searching the stack */ },
             }
         }
 

From 3a8db85519b0b64f9ef4ae1e365c8ddcf7caf4bf Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Tue, 6 Apr 2021 17:38:59 -0400
Subject: [PATCH 10/13] impl std::error::Error

---
 src/error.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/error.rs b/src/error.rs
index 5604fde..41efb05 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,7 @@
 use std::fmt;
 use std::io::Error as StdIoError;
 use std::result::Result as StdResult;
+use std::error::Error as StdError;
 
 use parser;
 use encoder;
@@ -52,3 +53,5 @@ impl From<encoder::Error> for Error {
         Error::Encoder(err)
     }
 }
+
+impl StdError for Error { }

From 7ca6bd31fcef8573c1b7cbb67c631f3bb5eee152 Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Tue, 6 Apr 2021 22:56:25 -0400
Subject: [PATCH 11/13] Revert "impl std::error::Error"

This reverts commit 3a8db85519b0b64f9ef4ae1e365c8ddcf7caf4bf.  It was
applied to the wrong branch by accident.
---
 src/error.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/error.rs b/src/error.rs
index 41efb05..5604fde 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,7 +1,6 @@
 use std::fmt;
 use std::io::Error as StdIoError;
 use std::result::Result as StdResult;
-use std::error::Error as StdError;
 
 use parser;
 use encoder;
@@ -53,5 +52,3 @@ impl From<encoder::Error> for Error {
         Error::Encoder(err)
     }
 }
-
-impl StdError for Error { }

From 06a73550ba83e96ad8116cbf62fd755fac8cc7f7 Mon Sep 17 00:00:00 2001
From: Erik Funder Carstensen <fundererik@fastmail.com>
Date: Fri, 14 May 2021 13:16:48 +0200
Subject: [PATCH 12/13] Document the correct return type for compile_path

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

diff --git a/src/lib.rs b/src/lib.rs
index 5a5e705..1cc240f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -43,7 +43,7 @@ pub fn compile_iter<T: Iterator<Item = char>>(iter: T) -> Result<Template> {
 }
 
 /// Compiles a template from a path.
-/// returns None if the file cannot be read OR the file is not UTF-8 encoded
+/// returns [Error] if the file cannot be read OR the file is not UTF-8 encoded
 pub fn compile_path<U: AsRef<Path>>(path: U) -> Result<Template> {
     let path = path.as_ref();
 

From 545aac25040cbb166fc22bcbaaa360bcb6a8b673 Mon Sep 17 00:00:00 2001
From: Ben Stern <bstern@fortian.com>
Date: Wed, 23 Jun 2021 10:32:55 -0400
Subject: [PATCH 13/13] Clean up the lint from the 0.9.1 PR

---
 src/compiler.rs | 3 +++
 src/data.rs     | 2 +-
 src/parser.rs   | 2 +-
 src/template.rs | 5 +++--
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/compiler.rs b/src/compiler.rs
index 8c18684..de3805b 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -53,6 +53,9 @@ impl<T: Iterator<Item = char>> Compiler<T> {
             let path =
                 self.ctx.template_path.join(&(name.clone() + "." + &self.ctx.template_extension));
 
+            // This is too complicated to just be
+            // self.partials.entry(&name).or_insert(...)
+            #[allow(clippy::map_entry)]
             if !self.partials.contains_key(&name) {
                 // Insert a placeholder so we don't recurse off to infinity.
                 self.partials.insert(name.to_string(), Vec::new());
diff --git a/src/data.rs b/src/data.rs
index dbb7b20..e13567d 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -3,7 +3,7 @@ use std::cell::RefCell;
 use std::fmt;
 
 // for bug!
-use log::{log, error};
+use log::error;
 
 pub enum Data {
     Null,
diff --git a/src/parser.rs b/src/parser.rs
index da7d09a..65da80b 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -3,7 +3,7 @@ use std::mem;
 use std::fmt;
 
 // for bug!
-use log::{log, error};
+use log::error;
 
 /// `Token` is a section of a compiled mustache string.
 #[derive(Clone, Debug, PartialEq)]
diff --git a/src/template.rs b/src/template.rs
index de921dd..48a0ddb 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -5,7 +5,7 @@ use std::str;
 
 use compiler::Compiler;
 // for bug!
-use log::{log, error};
+use log::error;
 use parser::Token;
 use serde::Serialize;
 
@@ -208,7 +208,7 @@ impl<'a> RenderContext<'a> {
 
                     Data::Bool(val) => {
                         let s = if val { "true" } else { "false" };
-                        try!(self.write_tracking_newlines(wr, s));
+                        self.write_tracking_newlines(wr, s)?;
                     }
 
                     ref value => {
@@ -239,6 +239,7 @@ impl<'a> RenderContext<'a> {
         self.render(wr, stack, children)
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn render_section<W: Write>(&mut self,
                                 wr: &mut W,
                                 stack: &mut Vec<&Data>,