fix: Isolate context creation

If nothing else, this makes me feel better about who has acess to do
what.

BREAKING CHANGE: How to create a `Context` has changed.

src/interpreter/context.rs

@@ -94,16 +94,18 @@ pub struct Stack {
 }
 
 impl Stack {
-    pub fn new() -> Self {
+    pub fn empty() -> Self {
         Self {
             globals: Object::new(),
             // Mutable frame for globals.
             stack: vec![Object::new()],
         }
     }
 
-    pub fn with_globals(&mut self, values: Object) {
-        self.globals = values;
+    pub fn with_globals(globals: Object) -> Self {
+        let mut stack = Self::empty();
+        stack.globals = globals;
+        stack
     }
 
     /// Creates a new variable scope chained to a parent scope.
@@ -197,36 +199,57 @@ impl Stack {
 
 impl Default for Stack {
     fn default() -> Self {
-        Self::new()
+        Self::empty()
     }
 }
 
 #[derive(Default)]
-pub struct Context {
-    stack: Stack,
-
-    interrupt: InterruptState,
-    cycles: CycleStateInner,
-
+pub struct ContextBuilder {
+    globals: Object,
     filters: sync::Arc<HashMap<&'static str, BoxedValueFilter>>,
 }
 
-impl Context {
+impl ContextBuilder {
     /// Creates a new, empty rendering context.
     pub fn new() -> Self {
         Default::default()
     }
 
-    pub fn with_values(mut self, values: Object) -> Self {
-        self.stack.with_globals(values);
+    pub fn set_globals(mut self, values: Object) -> Self {
+        self.globals = values;
         self
     }
 
-    pub fn with_filters(mut self, filters: &sync::Arc<HashMap<&'static str, BoxedValueFilter>>) -> Self {
+    pub fn set_filters(mut self, filters: &sync::Arc<HashMap<&'static str, BoxedValueFilter>>) -> Self {
         self.filters = sync::Arc::clone(filters);
         self
     }
 
+    pub fn build(self) -> Context {
+        Context {
+            stack: Stack::with_globals(self.globals),
+            interrupt: InterruptState::default(),
+            cycles: CycleStateInner::default(),
+            filters: self.filters,
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct Context {
+    stack: Stack,
+
+    interrupt: InterruptState,
+    cycles: CycleStateInner,
+
+    filters: sync::Arc<HashMap<&'static str, BoxedValueFilter>>,
+}
+
+impl Context {
+    pub fn new() -> Self {
+        Context::default()
+    }
+
     pub fn get_filter<'b>(&'b self, name: &str) -> Option<&'b FilterValue> {
         self.filters.get(name).map(|f| {
             let f: &FilterValue = f;

src/interpreter/mod.rs

@@ -8,7 +8,7 @@ mod text;
 mod variable;
 
 pub use self::argument::Argument;
-pub use self::context::{unexpected_value_error, Context, Interrupt, InterruptState};
+pub use self::context::{unexpected_value_error, ContextBuilder, Context, Interrupt, InterruptState};
 pub use self::filter::{BoxedValueFilter, FilterError, FilterResult, FilterValue, FnFilterValue};
 pub use self::output::{FilterPrototype, Output};
 pub use self::renderable::Renderable;

src/tags/for_block.rs

@@ -299,6 +299,7 @@ mod test {
     use std::collections::HashMap;
     use std::sync;
 
+    use interpreter::ContextBuilder;
     use compiler;
     use interpreter;
 
@@ -636,7 +637,7 @@ mod test {
                 as interpreter::FnFilterValue)
                 .into(),
                     );
-        let mut context = Context::new().with_filters(&sync::Arc::new(filters));
+        let mut context = ContextBuilder::new().set_filters(&sync::Arc::new(filters)).build();
 
         context.stack_mut().set_global_val(
             "array",

src/tags/include_tag.rs

@@ -65,6 +65,7 @@ mod test {
     use value;
     use compiler;
     use filters;
+    use interpreter::ContextBuilder;
     use interpreter;
 
     use super::*;
@@ -97,7 +98,7 @@ mod test {
 
         let mut filters: HashMap<&'static str, interpreter::BoxedValueFilter> = HashMap::new();
         filters.insert("size",(filters::size as interpreter::FnFilterValue).into());
-        let mut context = Context::new().with_filters(&sync::Arc::new(filters));
+        let mut context = ContextBuilder::new().set_filters(&sync::Arc::new(filters)).build();
         context.stack_mut().set_global_val("num", value::Value::scalar(5f64));
         context.stack_mut().set_global_val("numTwo", value::Value::scalar(10f64));
         let output = template.render(&mut context).unwrap();
@@ -114,7 +115,7 @@ mod test {
 
         let mut filters: HashMap<&'static str, interpreter::BoxedValueFilter> = HashMap::new();
         filters.insert("size",(filters::size as interpreter::FnFilterValue).into());
-        let mut context = Context::new().with_filters(&sync::Arc::new(filters));
+        let mut context = ContextBuilder::new().set_filters(&sync::Arc::new(filters)).build();
         context.stack_mut().set_global_val("num", value::Value::scalar(5f64));
         context.stack_mut().set_global_val("numTwo", value::Value::scalar(10f64));
         let output = template.render(&mut context).unwrap();

src/template.rs

@@ -23,9 +23,10 @@ impl Template {
 
     /// Renders an instance of the Template, using the given globals.
     pub fn render_to(&self, writer: &mut Write, globals: &Object) -> Result<()> {
-        let mut data = interpreter::Context::new()
-            .with_filters(&self.filters)
-            .with_values(globals.clone());
+        let mut data = interpreter::ContextBuilder::new()
+            .set_filters(&self.filters)
+            .set_globals(globals.clone())
+            .build();
         self.template
             .render_to(writer, &mut data)
     }