perf(render): Use a Write

`render_to` uses an `io::Write`.  This is hopefully better than string
concatenation, especially if you can write directly to file. `render` is
still available for convinience (though it no longer returns an
`Option`).

Fixes #187

BREAKING CHANGES: Changed focus to `io::Write`
- `Renderable`s must implement `render_to`.
- `render` no longer returns an `Option`.

Author: epage

src/compiler/parser.rs

@@ -404,6 +404,9 @@ mod test_expect {
 
 #[cfg(test)]
 mod test_split_block {
+    use std::collections::HashMap;
+    use std::io::Write;
+
     use super::super::split_block;
     use super::super::tokenize;
     use super::super::BoxedBlockParser;
@@ -412,14 +415,13 @@ mod test_split_block {
     use interpreter;
     use interpreter::Context;
     use interpreter::Renderable;
-    use std::collections::HashMap;
 
     #[derive(Debug)]
     struct NullBlock;
 
     impl Renderable for NullBlock {
-        fn render(&self, _context: &mut Context) -> Result<Option<String>> {
-            Ok(None)
+        fn render_to(&self, _writer: &mut Write, _context: &mut Context) -> Result<()> {
+            Ok(())
         }
     }
 

src/interpreter/output.rs

@@ -1,4 +1,5 @@
 use std::fmt;
+use std::io::Write;
 
 use itertools;
 
@@ -53,9 +54,10 @@ impl fmt::Display for Output {
 }
 
 impl Renderable for Output {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()> {
         let entry = self.apply_filters(context)?;
-        Ok(Some(entry.to_string()))
+        write!(writer, "{}", entry).chain("Failed to render")?;
+        Ok(())
     }
 }
 

src/interpreter/renderable.rs

@@ -1,14 +1,18 @@
 use std::fmt::Debug;
+use std::io::Write;
 
 use error::Result;
-
 use super::Context;
 
 /// Any object (tag/block) that can be rendered by liquid must implement this trait.
 pub trait Renderable: Send + Sync + Debug {
     /// Renders the Renderable instance given a Liquid context.
-    /// The Result that is returned signals if there was an error rendering,
-    /// the Option<String> that is wrapped by the Result will be None if
-    /// the render has run successfully but there is no content to render.
-    fn render(&self, context: &mut Context) -> Result<Option<String>>;
+    fn render(&self, context: &mut Context) -> Result<String> {
+        let mut data = Vec::new();
+        self.render_to(&mut data, context)?;
+        Ok(String::from_utf8(data).expect("render only writes UTF-8"))
+    }
+
+    /// Renders the Renderable instance given a Liquid context.
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()>;
 }

src/interpreter/template.rs

@@ -1,5 +1,6 @@
-use error::Result;
+use std::io::Write;
 
+use error::Result;
 use super::Context;
 use super::Renderable;
 
@@ -9,12 +10,9 @@ pub struct Template {
 }
 
 impl Renderable for Template {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
-        let mut buf = String::new();
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()> {
         for el in &self.elements {
-            if let Some(ref x) = el.render(context)? {
-                buf = buf + x;
-            }
+            el.render_to(writer, context)?;
 
             // Did the last element we processed set an interrupt? If so, we
             // need to abandon the rest of our child elements and just
@@ -24,7 +22,7 @@ impl Renderable for Template {
                 break;
             }
         }
-        Ok(Some(buf))
+        Ok(())
     }
 }
 

src/interpreter/text.rs

@@ -1,5 +1,6 @@
-use error::Result;
+use std::io::Write;
 
+use error::{Result, ResultLiquidChainExt};
 use super::Context;
 use super::Renderable;
 
@@ -9,8 +10,9 @@ pub struct Text {
 }
 
 impl Renderable for Text {
-    fn render(&self, _context: &mut Context) -> Result<Option<String>> {
-        Ok(Some(self.text.to_owned()))
+    fn render_to(&self, writer: &mut Write, _context: &mut Context) -> Result<()> {
+        write!(writer, "{}", &self.text).chain("Failed to render")?;
+        Ok(())
     }
 }
 

src/interpreter/variable.rs

@@ -1,8 +1,9 @@
 use std::fmt;
+use std::io::Write;
 
 use itertools;
 
-use error::Result;
+use error::{Result, ResultLiquidChainExt};
 use value::Index;
 
 use super::Context;
@@ -38,9 +39,10 @@ impl fmt::Display for Variable {
 }
 
 impl Renderable for Variable {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()> {
         let value = context.get_val_by_index(self.indexes.iter())?;
-        Ok(Some(value.to_string()))
+        write!(writer, "{}", value).chain("Failed to render")?;
+        Ok(())
     }
 }
 

src/tags/assign_tag.rs

@@ -1,5 +1,6 @@
-use error::Result;
+use std::io::Write;
 
+use error::Result;
 use compiler::LiquidOptions;
 use compiler::ResultLiquidExt;
 use compiler::Token;
@@ -21,12 +22,12 @@ impl Assign {
 }
 
 impl Renderable for Assign {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
+    fn render_to(&self, _writer: &mut Write, context: &mut Context) -> Result<()> {
         let value = self.src
             .apply_filters(context)
             .trace_with(|| self.trace().into())?;
         context.set_global_val(self.dst.to_owned(), value);
-        Ok(None)
+        Ok(())
     }
 }
 
@@ -101,7 +102,7 @@ mod test {
 
             let output = template.render(&mut context).unwrap();
             assert_eq!(context.get_val("freestyle"), Some(&Value::scalar(false)));
-            assert_eq!(output, Some("".to_string()));
+            assert_eq!(output, "");
         }
 
         // test two: matching value in `tags`
@@ -119,7 +120,7 @@ mod test {
 
             let output = template.render(&mut context).unwrap();
             assert_eq!(context.get_val("freestyle"), Some(&Value::scalar(true)));
-            assert_eq!(output, Some("<p>Freestyle!</p>".to_string()));
+            assert_eq!(output, "<p>Freestyle!</p>");
         }
     }
 }

src/tags/capture_block.rs

@@ -1,5 +1,6 @@
-use error::{Result, ResultLiquidExt};
+use std::io::Write;
 
+use error::{Result, ResultLiquidExt};
 use compiler::Element;
 use compiler::LiquidOptions;
 use compiler::Token;
@@ -22,14 +23,15 @@ impl Capture {
 }
 
 impl Renderable for Capture {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
-        let output = self.template
-            .render(context)
-            .trace_with(|| self.trace().into())?
-            .unwrap_or_else(|| "".to_owned());
+    fn render_to(&self, _writer: &mut Write, context: &mut Context) -> Result<()> {
+        let mut captured = Vec::new();
+        self.template
+            .render_to(&mut captured, context)
+            .trace_with(|| self.trace().into())?;
 
+        let output = String::from_utf8(captured).expect("render only writes UTF-8");
         context.set_global_val(self.id.to_owned(), Value::scalar(output));
-        Ok(None)
+        Ok(())
     }
 }
 
@@ -93,7 +95,7 @@ mod test {
             ctx.get_val("attribute_name"),
             Some(&Value::scalar("potato-42-color"))
         );
-        assert_eq!(output, Some("".to_owned()));
+        assert_eq!(output, "");
     }
 
     #[test]

src/tags/case_block.rs

@@ -1,7 +1,8 @@
+use std::io::Write;
+
 use itertools;
 
 use error::{Error, Result, ResultLiquidExt};
-
 use compiler::Element;
 use compiler::LiquidOptions;
 use compiler::Token;
@@ -52,26 +53,26 @@ impl Case {
 }
 
 impl Renderable for Case {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()> {
         let value = self.target.evaluate(context)?;
         for case in &self.cases {
             if case.evaluate(&value, context)? {
                 return case.template
-                    .render(context)
+                    .render_to(writer, context)
                     .trace_with(|| case.trace().into())
                     .trace_with(|| self.trace().into())
                     .context_with(|| (self.target.to_string().into(), value.to_string()));
             }
         }
 
         if let Some(ref t) = self.else_block {
-            return t.render(context)
+            return t.render_to(writer, context)
                 .trace_with(|| "{{% else %}}".to_owned().into())
                 .trace_with(|| self.trace().into())
                 .context_with(|| (self.target.to_string().into(), value.to_string()));
         }
 
-        Ok(None)
+        Ok(())
     }
 }
 
@@ -211,25 +212,25 @@ mod test {
         context.set_global_val("x", Value::scalar(2f64));
         assert_eq!(
             template.render(&mut context).unwrap(),
-            Some("two".to_owned())
+            "two"
         );
 
         context.set_global_val("x", Value::scalar(3f64));
         assert_eq!(
             template.render(&mut context).unwrap(),
-            Some("three and a half".to_owned())
+            "three and a half"
         );
 
         context.set_global_val("x", Value::scalar(4f64));
         assert_eq!(
             template.render(&mut context).unwrap(),
-            Some("three and a half".to_owned())
+            "three and a half"
         );
 
         context.set_global_val("x", Value::scalar("nope"));
         assert_eq!(
             template.render(&mut context).unwrap(),
-            Some("otherwise".to_owned())
+            "otherwise"
         );
     }
 
@@ -251,7 +252,7 @@ mod test {
 
         let mut context = Context::new();
         context.set_global_val("x", Value::scalar("nope"));
-        assert_eq!(template.render(&mut context).unwrap(), Some("".to_owned()));
+        assert_eq!(template.render(&mut context).unwrap(), "");
     }
 
     #[test]

src/tags/comment_block.rs

@@ -1,5 +1,6 @@
-use error::Result;
+use std::io::Write;
 
+use error::Result;
 use compiler::Element;
 use compiler::LiquidOptions;
 use compiler::Token;
@@ -10,8 +11,8 @@ use interpreter::Renderable;
 struct Comment;
 
 impl Renderable for Comment {
-    fn render(&self, _context: &mut Context) -> Result<Option<String>> {
-        Ok(None)
+    fn render_to(&self, _writer: &mut Write, _context: &mut Context) -> Result<()> {
+        Ok(())
     }
 }
 
@@ -48,7 +49,7 @@ mod test {
         );
         assert_eq!(
             comment.unwrap().render(&mut Default::default()).unwrap(),
-            None
+            ""
         );
     }
 }

src/tags/cycle_tag.rs

@@ -1,7 +1,8 @@
-use itertools;
+use std::io::Write;
 
-use error::{Result, ResultLiquidExt};
+use itertools;
 
+use error::{Result, ResultLiquidChainExt, ResultLiquidExt};
 use compiler::LiquidOptions;
 use compiler::Token;
 use compiler::{consume_value_token, unexpected_token_error, value_token};
@@ -25,11 +26,14 @@ impl Cycle {
 }
 
 impl Renderable for Cycle {
-    fn render(&self, context: &mut Context) -> Result<Option<String>> {
+    fn render_to(&self, writer: &mut Write, context: &mut Context) -> Result<()> {
         let value = context
             .cycle_element(&self.name, &self.values)
             .trace_with(|| self.trace().into())?;
-        Ok(value.map(|v| v.to_string()))
+        if let Some(ref value) = value {
+            write!(writer, "{}", value).chain("Failed to render")?;
+        }
+        Ok(())
     }
 }
 
@@ -137,7 +141,7 @@ mod test {
         let mut context = Context::new();
         let output = template.render(&mut context);
 
-        assert_eq!(output.unwrap(), Some("one\ntwo\none\ntwo\n".to_owned()));
+        assert_eq!(output.unwrap(), "one\ntwo\none\ntwo\n");
     }
 
     #[test]
@@ -156,7 +160,7 @@ mod test {
         let mut context = Context::new();
         let output = template.render(&mut context);
 
-        assert_eq!(output.unwrap(), Some("one\ntwo\nthree\none\n".to_owned()));
+        assert_eq!(output.unwrap(), "one\ntwo\nthree\none\n");
     }
 
     #[test]
@@ -179,7 +183,7 @@ mod test {
 
         let output = template.render(&mut context);
 
-        assert_eq!(output.unwrap(), Some("1\n2\n3\n1\n".to_owned()));
+        assert_eq!(output.unwrap(), "1\n2\n3\n1\n");
     }
 
     #[test]