Add optional support for lax rendering and parsing

crates/core/src/runtime/expression.rs

@@ -57,7 +57,13 @@ impl Expression {
             Expression::Literal(ref x) => ValueCow::Borrowed(x),
             Expression::Variable(ref x) => {
                 let path = x.evaluate(runtime)?;
-                runtime.get(&path)?
+
+                match runtime.render_mode() {
+                    super::RenderingMode::Lax => {
+                        runtime.try_get(&path).unwrap_or_else(|| Value::Nil.into())
+                    }
+                    _ => runtime.get(&path)?,
+                }
             }
         };
         Ok(val)
@@ -72,3 +78,32 @@ impl fmt::Display for Expression {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::model::Object;
+    use crate::model::Value;
+    use crate::runtime::RenderingMode;
+    use crate::runtime::RuntimeBuilder;
+    use crate::runtime::StackFrame;
+
+    #[test]
+    fn test_rendering_mode() {
+        let globals = Object::new();
+        let expression = Expression::Variable(Variable::with_literal("test"));
+
+        let runtime = RuntimeBuilder::new()
+            .set_render_mode(RenderingMode::Strict)
+            .build();
+        let runtime = StackFrame::new(&runtime, &globals);
+        assert_eq!(expression.evaluate(&runtime).is_err(), true);
+
+        let runtime = RuntimeBuilder::new()
+            .set_render_mode(RenderingMode::Lax)
+            .build();
+        let runtime = StackFrame::new(&runtime, &globals);
+        assert_eq!(expression.evaluate(&runtime).unwrap(), Value::Nil);
+    }
+}

crates/core/src/runtime/runtime.rs

@@ -7,6 +7,14 @@ use crate::model::{Object, ObjectView, Scalar, ScalarCow, Value, ValueCow, Value
 use super::PartialStore;
 use super::Renderable;
 
+/// What mode to use when rendering.
+pub enum RenderingMode {
+    /// Returns an error when a variable is not defined.
+    Strict,
+    /// Replaces missing variables with an empty string.
+    Lax,
+}
+
 /// State for rendering a template
 pub trait Runtime {
     /// Partial templates for inclusion.
@@ -36,6 +44,9 @@ pub trait Runtime {
 
     /// Unnamed state for plugins during rendering
     fn registers(&self) -> &Registers;
+
+    /// Used to set the mode when rendering
+    fn render_mode(&self) -> &RenderingMode;
 }
 
 impl<'r, R: Runtime + ?Sized> Runtime for &'r R {
@@ -78,12 +89,17 @@ impl<'r, R: Runtime + ?Sized> Runtime for &'r R {
     fn registers(&self) -> &super::Registers {
         <R as Runtime>::registers(self)
     }
+
+    fn render_mode(&self) -> &RenderingMode {
+        <R as Runtime>::render_mode(self)
+    }
 }
 
 /// Create processing runtime for a template.
 pub struct RuntimeBuilder<'g, 'p> {
     globals: Option<&'g dyn ObjectView>,
     partials: Option<&'p dyn PartialStore>,
+    render_mode: RenderingMode,
 }
 
 impl<'c, 'g: 'c, 'p: 'c> RuntimeBuilder<'g, 'p> {
@@ -92,6 +108,7 @@ impl<'c, 'g: 'c, 'p: 'c> RuntimeBuilder<'g, 'p> {
         Self {
             globals: None,
             partials: None,
+            render_mode: RenderingMode::Strict,
         }
     }
 
@@ -100,6 +117,7 @@ impl<'c, 'g: 'c, 'p: 'c> RuntimeBuilder<'g, 'p> {
         RuntimeBuilder {
             globals: Some(values),
             partials: self.partials,
+            render_mode: self.render_mode,
         }
     }
 
@@ -108,6 +126,16 @@ impl<'c, 'g: 'c, 'p: 'c> RuntimeBuilder<'g, 'p> {
         RuntimeBuilder {
             globals: self.globals,
             partials: Some(values),
+            render_mode: self.render_mode,
+        }
+    }
+
+    /// Initialize with the provided rendering mode.
+    pub fn set_render_mode(self, mode: RenderingMode) -> RuntimeBuilder<'g, 'p> {
+        RuntimeBuilder {
+            globals: self.globals,
+            partials: self.partials,
+            render_mode: mode,
         }
     }
 
@@ -116,6 +144,7 @@ impl<'c, 'g: 'c, 'p: 'c> RuntimeBuilder<'g, 'p> {
         let partials = self.partials.unwrap_or(&NullPartials);
         let runtime = RuntimeCore {
             partials,
+            render_mode: self.render_mode,
             ..Default::default()
         };
         let runtime = super::IndexFrame::new(runtime);
@@ -208,6 +237,8 @@ pub struct RuntimeCore<'g> {
     partials: &'g dyn PartialStore,
 
     registers: Registers,
+
+    render_mode: RenderingMode,
 }
 
 impl<'g> RuntimeCore<'g> {
@@ -268,13 +299,18 @@ impl<'g> Runtime for RuntimeCore<'g> {
     fn registers(&self) -> &Registers {
         &self.registers
     }
+
+    fn render_mode(&self) -> &RenderingMode {
+        &self.render_mode
+    }
 }
 
 impl<'g> Default for RuntimeCore<'g> {
     fn default() -> Self {
         Self {
             partials: &NullPartials,
             registers: Default::default(),
+            render_mode: RenderingMode::Strict,
         }
     }
 }

crates/core/src/runtime/stack.rs

@@ -87,6 +87,10 @@ impl<P: super::Runtime, O: ObjectView> super::Runtime for StackFrame<P, O> {
     fn registers(&self) -> &super::Registers {
         self.parent.registers()
     }
+
+    fn render_mode(&self) -> &super::RenderingMode {
+        self.parent.render_mode()
+    }
 }
 
 pub(crate) struct GlobalFrame<P> {
@@ -162,6 +166,10 @@ impl<P: super::Runtime> super::Runtime for GlobalFrame<P> {
     fn registers(&self) -> &super::Registers {
         self.parent.registers()
     }
+
+    fn render_mode(&self) -> &super::RenderingMode {
+        self.parent.render_mode()
+    }
 }
 
 pub(crate) struct IndexFrame<P> {
@@ -237,4 +245,8 @@ impl<P: super::Runtime> super::Runtime for IndexFrame<P> {
     fn registers(&self) -> &super::Registers {
         self.parent.registers()
     }
+
+    fn render_mode(&self) -> &super::RenderingMode {
+        self.parent.render_mode()
+    }
 }

src/template.rs

@@ -5,6 +5,7 @@ use liquid_core::error::Result;
 use liquid_core::runtime;
 use liquid_core::runtime::PartialStore;
 use liquid_core::runtime::Renderable;
+use liquid_core::runtime::RenderingMode;
 
 pub struct Template {
     pub(crate) template: runtime::Template,
@@ -14,16 +15,51 @@ pub struct Template {
 impl Template {
     /// Renders an instance of the Template, using the given globals.
     pub fn render(&self, globals: &dyn crate::ObjectView) -> Result<String> {
+        self.render_with_mode(globals, RenderingMode::Strict)
+    }
+
+    /// Renders an instance of the Template, using the given globals.
+    pub fn render_to(&self, writer: &mut dyn Write, globals: &dyn crate::ObjectView) -> Result<()> {
+        self.render_to_with_mode(writer, globals, RenderingMode::Strict)
+    }
+
+    /// Renders an instance of the Template, using the given globals in lax mode.
+    pub fn render_lax(&self, globals: &dyn crate::ObjectView) -> Result<String> {
+        self.render_with_mode(globals, RenderingMode::Lax)
+    }
+
+    /// Renders an instance of the Template, using the given globals in lax mode.
+    pub fn render_to_lax(
+        &self,
+        writer: &mut dyn Write,
+        globals: &dyn crate::ObjectView,
+    ) -> Result<()> {
+        self.render_to_with_mode(writer, globals, RenderingMode::Lax)
+    }
+
+    /// Renders an instance of the Template, using the given globals with the provided rendering mode.
+    fn render_with_mode(
+        &self,
+        globals: &dyn crate::ObjectView,
+        mode: RenderingMode,
+    ) -> Result<String> {
         const BEST_GUESS: usize = 10_000;
         let mut data = Vec::with_capacity(BEST_GUESS);
-        self.render_to(&mut data, globals)?;
+        self.render_to_with_mode(&mut data, globals, mode)?;
 
         Ok(convert_buffer(data))
     }
 
-    /// Renders an instance of the Template, using the given globals.
-    pub fn render_to(&self, writer: &mut dyn Write, globals: &dyn crate::ObjectView) -> Result<()> {
-        let runtime = runtime::RuntimeBuilder::new().set_globals(globals);
+    /// Renders an instance of the Template, using the given globals with the provided rendering mode.
+    fn render_to_with_mode(
+        &self,
+        writer: &mut dyn Write,
+        globals: &dyn crate::ObjectView,
+        mode: RenderingMode,
+    ) -> Result<()> {
+        let runtime = runtime::RuntimeBuilder::new()
+            .set_globals(globals)
+            .set_render_mode(mode);
         let runtime = match self.partials {
             Some(ref partials) => runtime.set_partials(partials.as_ref()),
             None => runtime,