Partial simple is working.

src/renderer/parameters_context.rs

@@ -1,6 +1,7 @@
 use crate::parser::KVPair;
 use crate::parser::{Filter, RValue};
 use crate::renderer::context_element::ContextElement;
+use crate::renderer::walking::walk_path;
 use crate::renderer::Loopable;
 use crate::renderer::RenderError;
 use crate::renderer::Renderable;
@@ -34,20 +35,52 @@ impl<'a> ContextElement for ParametersContext<'a> {}
 
 impl<'a> Renderable for ParametersContext<'a> {
     fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
+        // TODO: Would this even ever be called? Won't matter, but I'd
+        // like to know. Since it is injected 1 above the current
+        // context, we wouldn't be able to access it with `{.}`.
         Ok("[object Object]".to_owned())
     }
 }
 
 impl<'a> Loopable for ParametersContext<'a> {
     fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
-        // TODO: Would this even ever be called? Won't matter, but I'd like to know.
+        // TODO: Would this even ever be called? Won't matter, but I'd
+        // like to know. Since it is injected 1 above the current
+        // context, we wouldn't be able to access it with `{.}`.
         vec![self]
     }
 }
 
 impl<'a> Walkable for ParametersContext<'a> {
     fn walk(&self, segment: &str) -> Result<&dyn ContextElement, WalkError> {
-        // TODO: Actually implement
+        let rval = self.params.get(segment).ok_or(WalkError::CantWalk)?;
+        match rval {
+            RValue::RVPath(path) => walk_path(self.breadcrumbs, &path.keys),
+            RValue::RVString(text) => Ok(text),
+        }
+    }
+}
+
+impl ContextElement for String {}
+
+impl Renderable for String {
+    fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
+        Ok(self.clone())
+    }
+}
+
+impl Loopable for String {
+    fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
+        if self.is_empty() {
+            Vec::new()
+        } else {
+            vec![self]
+        }
+    }
+}
+
+impl Walkable for String {
+    fn walk(&self, segment: &str) -> Result<&dyn ContextElement, WalkError> {
         Err(WalkError::CantWalk)
     }
 }