duster/src/renderer/parameters_context.rs

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;
use crate::renderer::WalkError;
use crate::renderer::Walkable;
use std::collections::HashMap;

#[derive(Clone, Debug)]
pub struct ParametersContext<'a> {
    params: HashMap<&'a str, &'a RValue<'a>>,
    breadcrumbs: &'a Vec<&'a dyn ContextElement>,
}

impl<'a> ParametersContext<'a> {
    pub fn new(
        breadcrumbs: &'a Vec<&'a dyn ContextElement>,
        params: &'a Vec<KVPair<'a>>,
    ) -> ParametersContext<'a> {
        let param_map = params
            .iter()
            .map(|pair: &KVPair<'a>| (pair.key, &pair.value))
            .collect();
        ParametersContext {
            params: param_map,
            breadcrumbs: breadcrumbs,
        }
    }
}

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. 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> {
        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)
    }
}