src/vendor/handlebars/src/helpers/helper_lookup.rs

   1 #[cfg(all(feature = "rustc_ser_type", not(feature = "serde_type")))]
   2 use serialize::json::Json;
   3 #[cfg(feature = "serde_type")]
   4 use serde_json::value::Value as Json;
   5
   6 use helpers::HelperDef;
   7 use registry::Registry;
   8 use context::JsonRender;
   9 use render::{RenderContext, RenderError, Helper};
  10
  11 #[derive(Clone, Copy)]
  12 pub struct LookupHelper;
  13
  14 impl HelperDef for LookupHelper {
  15     fn call(&self, h: &Helper, _: &Registry, rc: &mut RenderContext) -> Result<(), RenderError> {
  16         let collection_value = try!(h.param(0).ok_or_else(|| {
  17             RenderError::new("Param not found for helper \"lookup\"")
  18         }));
  19         let index = try!(h.param(1).ok_or_else(|| {
  20             RenderError::new("Insufficient params for helper \"lookup\"")
  21         }));
  22
  23         let null = Json::Null;
  24         let value = match collection_value.value() {
  25             &Json::Array(ref v) => {
  26                 index.value()
  27                     .as_u64()
  28                     .and_then(|u| Some(u as usize))
  29                     .and_then(|u| v.get(u))
  30                     .unwrap_or(&null)
  31             }
  32             #[cfg(all(feature = "rustc_ser_type", not(feature = "serde_type")))]
  33             &Json::Object(ref m) => {
  34                 index.value()
  35                     .as_string()
  36                     .and_then(|k| m.get(k))
  37                     .unwrap_or(&null)
  38             }
  39             #[cfg(feature = "serde_type")]
  40             &Json::Object(ref m) => {
  41                 index.value()
  42                     .as_str()
  43                     .and_then(|k| m.get(k))
  44                     .unwrap_or(&null)
  45             }
  46             _ => &null,
  47         };
  48         let r = value.render();
  49         try!(rc.writer.write(r.into_bytes().as_ref()));
  50         Ok(())
  51     }
  52 }
  53
  54 pub static LOOKUP_HELPER: LookupHelper = LookupHelper;
  55
  56 #[cfg(test)]
  57 mod test {
  58     use registry::Registry;
  59
  60     use std::collections::BTreeMap;
  61
  62     #[test]
  63     fn test_lookup() {
  64         let mut handlebars = Registry::new();
  65         assert!(handlebars.register_template_string("t0", "{{#each v1}}{{lookup ../../v2 @index}}{{/each}}").is_ok());
  66         assert!(handlebars.register_template_string("t1",
  67                                                     "{{#each v1}}{{lookup ../../v2 1}}{{/each}}")
  68                     .is_ok());
  69         assert!(handlebars.register_template_string("t2", "{{lookup kk \"a\"}}").is_ok());
  70
  71         let mut m: BTreeMap<String, Vec<u16>> = BTreeMap::new();
  72         m.insert("v1".to_string(), vec![1u16, 2u16, 3u16]);
  73         m.insert("v2".to_string(), vec![9u16, 8u16, 7u16]);
  74
  75         let m2 = btreemap!{
  76             "kk".to_string() => btreemap!{"a".to_string() => "world".to_string()}
  77         };
  78
  79         let r0 = handlebars.render("t0", &m);
  80         assert_eq!(r0.ok().unwrap(), "987".to_string());
  81
  82         let r1 = handlebars.render("t1", &m);
  83         assert_eq!(r1.ok().unwrap(), "888".to_string());
  84
  85         let r2 = handlebars.render("t2", &m2);
  86         assert_eq!(r2.ok().unwrap(), "world".to_string());
  87     }
  88 }