Merge pull request #506 from epage/render

feat: Add render tag

Author: epage

crates/core/src/parser/filter.rs

@@ -110,7 +110,7 @@ pub struct FilterArguments<'a> {
 /// }
 ///
 /// impl Filter for AtLeastFilter {
-///     fn evaluate(&self, input: &ValueViwe, runtime: &dyn Runtime) -> Result<Value> {
+///     fn evaluate(&self, input: &ValueView, runtime: &dyn Runtime) -> Result<Value> {
 ///         // Evaluate the `FilterParameters`
 ///         let args = self.args.evaluate(runtime)?;
 ///

crates/core/src/runtime/stack.rs

@@ -2,6 +2,8 @@ use crate::error::Error;
 use crate::error::Result;
 use crate::model::{Object, ObjectView, ScalarCow, Value, ValueCow, ValueView};
 
+use super::Registers;
+
 /// Layer variables on top of the existing runtime
 pub struct StackFrame<P, O> {
     parent: P,
@@ -89,12 +91,14 @@ impl<P: super::Runtime, O: ObjectView> super::Runtime for StackFrame<P, O> {
     }
 }
 
-pub(crate) struct GlobalFrame<P> {
+/// A stack frame that only provides a sandboxed set of globals
+pub struct GlobalFrame<P> {
     parent: P,
     data: std::cell::RefCell<Object>,
 }
 
 impl<P: super::Runtime> GlobalFrame<P> {
+    /// Override globals for `parent`
     pub fn new(parent: P) -> Self {
         Self {
             parent,
@@ -238,3 +242,176 @@ impl<P: super::Runtime> super::Runtime for IndexFrame<P> {
         self.parent.registers()
     }
 }
+
+/// A [`StackFrame`] where variables are not recursively searched for,
+/// However, you can still access the parent's partials.
+pub struct SandboxedStackFrame<P, O> {
+    parent: P,
+    name: Option<crate::model::KString>,
+    data: O,
+    registers: Registers,
+}
+
+impl<P: super::Runtime, O: ObjectView> SandboxedStackFrame<P, O> {
+    /// Create a new [`SandboxedStackFrame`] from a parent and some data
+    pub fn new(parent: P, data: O) -> Self {
+        Self {
+            parent,
+            name: None,
+            data,
+            registers: Default::default(),
+        }
+    }
+
+    /// Name the current context
+    pub fn with_name<S: Into<crate::model::KString>>(mut self, name: S) -> Self {
+        self.name = Some(name.into());
+        self
+    }
+}
+
+impl<P: super::Runtime, O: ObjectView> super::Runtime for SandboxedStackFrame<P, O> {
+    fn partials(&self) -> &dyn super::PartialStore {
+        self.parent.partials()
+    }
+
+    fn name(&self) -> Option<crate::model::KStringRef<'_>> {
+        self.name
+            .as_ref()
+            .map(|n| n.as_ref())
+            .or_else(|| self.parent.name())
+    }
+
+    fn roots(&self) -> std::collections::BTreeSet<crate::model::KStringCow<'_>> {
+        let mut roots = std::collections::BTreeSet::new();
+        roots.extend(self.data.keys());
+        roots
+    }
+
+    fn try_get(&self, path: &[ScalarCow<'_>]) -> Option<ValueCow<'_>> {
+        let key = path.first()?;
+        let key = key.to_kstr();
+        let data = &self.data;
+        data.get(key.as_str())
+            .and_then(|_| crate::model::try_find(data.as_value(), path))
+    }
+
+    fn get(&self, path: &[ScalarCow<'_>]) -> Result<ValueCow<'_>> {
+        let key = path.first().ok_or_else(|| {
+            Error::with_msg("Unknown variable").context("requested variable", "nil")
+        })?;
+        let key = key.to_kstr();
+        let data = &self.data;
+        data.get(key.as_str())
+            .and_then(|_| crate::model::try_find(data.as_value(), path))
+            .map(|v| v.into_owned().into())
+            .ok_or_else(|| Error::with_msg("Unknown variable").context("requested variable", key))
+    }
+
+    fn set_global(
+        &self,
+        name: crate::model::KString,
+        val: crate::model::Value,
+    ) -> Option<crate::model::Value> {
+        self.parent.set_global(name, val)
+    }
+
+    fn set_index(&self, name: crate::model::KString, val: Value) -> Option<Value> {
+        self.parent.set_index(name, val)
+    }
+
+    fn get_index<'a>(&'a self, name: &str) -> Option<ValueCow<'a>> {
+        self.parent.get_index(name)
+    }
+
+    fn registers(&self) -> &super::Registers {
+        &self.registers
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{runtime::RuntimeBuilder, Runtime};
+
+    use super::*;
+
+    #[test]
+    fn test_opaque_stack_frame_try_get() {
+        let globals = {
+            let mut o = Object::new();
+            o.insert("a".into(), Value::Scalar(1i64.into()));
+            o
+        };
+        let runtime = RuntimeBuilder::new().set_globals(&globals).build();
+        let opaque_stack_frame = SandboxedStackFrame::new(&runtime, {
+            let mut o = Object::new();
+            o.insert("b".into(), Value::Scalar(2i64.into()));
+            o
+        });
+
+        // Testing that you can access variables in the current frame, but not the parent
+        assert!(opaque_stack_frame.try_get(&["a".into()]).is_none());
+        assert!(opaque_stack_frame.try_get(&["b".into()]).is_some());
+
+        let stack_frame = StackFrame::new(opaque_stack_frame, {
+            let mut o = Object::new();
+            o.insert("c".into(), Value::Scalar(1i64.into()));
+            o
+        });
+
+        // Testing that a child of a OpaqueStackFrame can access access OpaqueStackFrame's variables but not the parent
+        assert!(stack_frame.try_get(&["a".into()]).is_none());
+        assert!(stack_frame.try_get(&["b".into()]).is_some());
+        assert!(stack_frame.try_get(&["c".into()]).is_some());
+    }
+
+    #[test]
+    fn test_opaque_stack_frame_get() {
+        let globals = {
+            let mut o = Object::new();
+            o.insert("a".into(), Value::Scalar(1i64.into()));
+            o
+        };
+        let runtime = RuntimeBuilder::new().set_globals(&globals).build();
+        let opaque_stack_frame = SandboxedStackFrame::new(&runtime, {
+            let mut o = Object::new();
+            o.insert("b".into(), Value::Scalar(2i64.into()));
+            o
+        });
+
+        // Testing that you can access variables in the current frame, but not the parent
+        assert!(opaque_stack_frame.get(&["a".into()]).is_err());
+        assert!(opaque_stack_frame.get(&["b".into()]).is_ok());
+
+        let stack_frame = StackFrame::new(opaque_stack_frame, {
+            let mut o = Object::new();
+            o.insert("c".into(), Value::Scalar(1i64.into()));
+            o
+        });
+
+        // Testing that a child of a OpaqueStackFrame can access access OpaqueStackFrame's variables but not the parent
+        assert!(stack_frame.get(&["a".into()]).is_err());
+        assert!(stack_frame.get(&["b".into()]).is_ok());
+        assert!(stack_frame.get(&["c".into()]).is_ok());
+    }
+
+    #[test]
+    fn test_opaque_stack_frame_roots() {
+        let globals = {
+            let mut o = Object::new();
+            o.insert("a".into(), Value::Scalar(1i64.into()));
+            o
+        };
+        let runtime = RuntimeBuilder::new().set_globals(&globals).build();
+        let opaque_stack_frame = SandboxedStackFrame::new(&runtime, {
+            let mut o = Object::new();
+            o.insert("b".into(), Value::Scalar(2i64.into()));
+            o
+        });
+        let roots = opaque_stack_frame.roots();
+
+        // Testing that the roots are not copied from the parent
+        assert!(!roots.contains("a"));
+        assert!(roots.contains("b"));
+    }
+}

crates/derive/src/lib.rs

@@ -45,7 +45,7 @@ use proc_macro::TokenStream;
 ///
 /// If you want to only accept a certain type of `Value` for a given argument,
 /// you may mark its type with `arg_type = "..."`. This will take away the burden
-/// and boilerplate of handling errors and unwraping the liquid `Value` into a rust
+/// and boilerplate of handling errors and unwrapping the liquid `Value` into a rust
 /// type.
 ///
 /// Right now, there is a default `arg_type`, "any", that accepts any value, as well

crates/lib/src/stdlib/blocks/for_block.rs

@@ -226,7 +226,7 @@ impl Renderable for For {
 }
 
 #[derive(Debug, Clone, ValueView, ObjectView)]
-struct ForloopObject<'p> {
+pub struct ForloopObject<'p> {
     length: i64,
     parentloop: Option<&'p dyn ValueView>,
     index0: i64,
@@ -238,7 +238,7 @@ struct ForloopObject<'p> {
 }
 
 impl<'p> ForloopObject<'p> {
-    fn new(i: usize, len: usize) -> Self {
+    pub fn new(i: usize, len: usize) -> Self {
         let i = i as i64;
         let len = len as i64;
         let first = i == 0;
@@ -520,7 +520,7 @@ fn evaluate_attr(attr: &Option<Expression>, runtime: &dyn Runtime) -> Result<Opt
 }
 
 #[derive(Clone, Debug)]
-enum RangeExpression {
+pub enum RangeExpression {
     Array(Expression),
     Counted(Expression, Expression),
 }
@@ -554,7 +554,7 @@ impl fmt::Display for RangeExpression {
 }
 
 #[derive(Clone, Debug)]
-enum Range<'r> {
+pub enum Range<'r> {
     Array(ValueCow<'r>),
     Counted(i64, i64),
 }

crates/lib/src/stdlib/blocks/mod.rs

@@ -15,3 +15,7 @@ pub use self::if_block::IfBlock;
 pub use self::if_block::UnlessBlock;
 pub use self::ifchanged_block::IfChangedBlock;
 pub use self::raw_block::RawBlock;
+
+pub use self::for_block::ForloopObject;
+pub use self::for_block::Range;
+pub use self::for_block::RangeExpression;

crates/lib/src/stdlib/mod.rs

@@ -5,3 +5,7 @@ mod tags;
 pub use blocks::*;
 pub use filters::*;
 pub use tags::*;
+
+pub use blocks::ForloopObject;
+pub use blocks::Range;
+pub use blocks::RangeExpression;

crates/lib/src/stdlib/tags/mod.rs

@@ -3,6 +3,7 @@ mod cycle_tag;
 mod include_tag;
 mod increment_tags;
 mod interrupt_tags;
+mod render_tag;
 
 pub use self::assign_tag::AssignTag;
 pub use self::cycle_tag::CycleTag;
@@ -11,3 +12,4 @@ pub use self::increment_tags::DecrementTag;
 pub use self::increment_tags::IncrementTag;
 pub use self::interrupt_tags::BreakTag;
 pub use self::interrupt_tags::ContinueTag;
+pub use self::render_tag::RenderTag;