Add optional support for lax rendering and parsing

crates/core/src/parser/filter.rs

@@ -254,3 +254,19 @@ where
         Box::new(filter)
     }
 }
+
+/// A filter used internally when parsing is done in lax mode.
+#[derive(Debug, Default)]
+pub struct NoopFilter;
+
+impl Filter for NoopFilter {
+    fn evaluate(&self, input: &dyn ValueView, _runtime: &dyn Runtime) -> Result<Value> {
+        Ok(input.to_value())
+    }
+}
+
+impl Display for NoopFilter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        ::std::write!(f, "{}", "noop")
+    }
+}

crates/core/src/parser/lang.rs

@@ -3,12 +3,25 @@ use super::ParseFilter;
 use super::ParseTag;
 use super::PluginRegistry;
 
+#[derive(Clone)]
+pub enum ParseMode {
+    Strict,
+    Lax,
+}
+
+impl Default for ParseMode {
+    fn default() -> Self {
+        Self::Strict
+    }
+}
+
 #[derive(Clone, Default)]
 #[non_exhaustive]
 pub struct Language {
     pub blocks: PluginRegistry<Box<dyn ParseBlock>>,
     pub tags: PluginRegistry<Box<dyn ParseTag>>,
     pub filters: PluginRegistry<Box<dyn ParseFilter>>,
+    pub mode: ParseMode,
 }
 
 impl Language {

crates/core/src/parser/parser.rs

@@ -9,9 +9,9 @@ use crate::runtime::Expression;
 use crate::runtime::Renderable;
 use crate::runtime::Variable;
 
-use super::Language;
 use super::Text;
 use super::{Filter, FilterArguments, FilterChain};
+use super::{Language, ParseMode};
 
 use pest::Parser;
 
@@ -205,22 +205,38 @@ fn parse_filter(filter: Pair, options: &Language) -> Result<Box<dyn Filter>> {
         keyword: Box::new(keyword_args.into_iter()),
     };
 
-    let f = options.filters.get(name).ok_or_else(|| {
-        let mut available: Vec<_> = options.filters.plugin_names().collect();
-        available.sort_unstable();
-        let available = itertools::join(available, ", ");
-        Error::with_msg("Unknown filter")
-            .context("requested filter", name.to_owned())
-            .context("available filters", available)
-    })?;
-
-    let f = f
-        .parse(args)
-        .trace("Filter parsing error")
-        .context_key("filter")
-        .value_with(|| filter_str.to_string().into())?;
-
-    Ok(f)
+    match options.mode {
+        ParseMode::Strict => {
+            let f = options.filters.get(name).ok_or_else(|| {
+                let mut available: Vec<_> = options.filters.plugin_names().collect();
+                available.sort_unstable();
+                let available = itertools::join(available, ", ");
+                Error::with_msg("Unknown filter")
+                    .context("requested filter", name.to_owned())
+                    .context("available filters", available)
+            })?;
+
+            let f = f
+                .parse(args)
+                .trace("Filter parsing error")
+                .context_key("filter")
+                .value_with(|| filter_str.to_string().into())?;
+
+            Ok(f)
+        }
+        ParseMode::Lax => match options.filters.get(name) {
+            Some(f) => {
+                let f = f
+                    .parse(args)
+                    .trace("Filter parsing error")
+                    .context_key("filter")
+                    .value_with(|| filter_str.to_string().into())?;
+
+                Ok(f)
+            }
+            None => Ok(Box::new(super::NoopFilter {})),
+        },
+    }
 }
 
 /// Parses a `FilterChain` from a `Pair` with a filter chain.
@@ -1172,6 +1188,20 @@ mod test {
         assert_eq!(output, "5");
     }
 
+    #[test]
+    fn test_parse_mode_filters() {
+        let mut options = Language::default();
+        let text = "{{ exp | undefined }}";
+
+        options.mode = ParseMode::Strict;
+        let result = parse(text, &options);
+        assert_eq!(result.is_err(), true);
+
+        options.mode = ParseMode::Lax;
+        let result = parse(text, &options);
+        assert_eq!(result.is_err(), false);
+    }
+
     /// Macro implementation of custom block test.
     macro_rules! test_custom_block_tags_impl {
         ($start_tag:expr, $end_tag:expr) => {{

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/parser.rs

@@ -5,6 +5,7 @@ use std::sync;
 
 use liquid_core::error::{Result, ResultLiquidExt, ResultLiquidReplaceExt};
 use liquid_core::parser;
+use liquid_core::parser::ParseMode;
 use liquid_core::runtime;
 
 use super::Template;
@@ -19,6 +20,7 @@ pub struct ParserBuilder<P = Partials>
 where
     P: partials::PartialCompiler,
 {
+    mode: parser::ParseMode,
     blocks: parser::PluginRegistry<Box<dyn parser::ParseBlock>>,
     tags: parser::PluginRegistry<Box<dyn parser::ParseTag>>,
     filters: parser::PluginRegistry<Box<dyn parser::ParseFilter>>,
@@ -110,6 +112,12 @@ where
             .filter(stdlib::Where)
     }
 
+    /// Sets the parse mode to lax.
+    pub fn in_lax_mode(mut self) -> Self {
+        self.mode = ParseMode::Lax;
+        self
+    }
+
     /// Inserts a new custom block into the parser
     pub fn block<B: Into<Box<dyn parser::ParseBlock>>>(mut self, block: B) -> Self {
         let block = block.into();
@@ -136,12 +144,14 @@ where
     /// Set which partial-templates will be available.
     pub fn partials<N: partials::PartialCompiler>(self, partials: N) -> ParserBuilder<N> {
         let Self {
+            mode,
             blocks,
             tags,
             filters,
             partials: _partials,
         } = self;
         ParserBuilder {
+            mode,
             blocks,
             tags,
             filters,
@@ -152,13 +162,15 @@ where
     /// Create a parser
     pub fn build(self) -> Result<Parser> {
         let Self {
+            mode,
             blocks,
             tags,
             filters,
             partials,
         } = self;
 
         let mut options = parser::Language::empty();
+        options.mode = mode;
         options.blocks = blocks;
         options.tags = tags;
         options.filters = filters;
@@ -178,6 +190,7 @@ where
 {
     fn default() -> Self {
         Self {
+            mode: Default::default(),
             blocks: Default::default(),
             tags: Default::default(),
             filters: Default::default(),