src/vendor/handlebars/examples/render_file.rs

   1 #![allow(unused_imports, dead_code)]
   2 extern crate env_logger;
   3 extern crate handlebars;
   4 extern crate serde;
   5 #[macro_use]
   6 extern crate serde_derive;
   7 extern crate serde_json;
   8 use serde::Serialize;
   9 use serde_json::value::{self, Map, Value as Json};
  10
  11 use std::io::{Read, Write};
  12 use std::fs::File;
  13
  14 use handlebars::{to_json, Context, Handlebars, Helper, JsonRender, RenderContext, RenderError};
  15
  16 // define a custom helper
  17 fn format_helper(h: &Helper, _: &Handlebars, rc: &mut RenderContext) -> Result<(), RenderError> {
  18     let param = try!(
  19         h.param(0,)
  20             .ok_or(RenderError::new("Param 0 is required for format helper.",),)
  21     );
  22     let rendered = format!("{} pts", param.value().render());
  23     try!(rc.writer.write(rendered.into_bytes().as_ref()));
  24     Ok(())
  25 }
  26
  27 // another custom helper
  28 fn rank_helper(h: &Helper, _: &Handlebars, rc: &mut RenderContext) -> Result<(), RenderError> {
  29     let rank = try!(
  30         h.param(0,)
  31             .and_then(|v| v.value().as_u64(),)
  32             .ok_or(RenderError::new(
  33                 "Param 0 with u64 type is required for rank helper."
  34             ),)
  35     ) as usize;
  36     let teams = try!(
  37         h.param(1,)
  38             .and_then(|v| v.value().as_array(),)
  39             .ok_or(RenderError::new(
  40                 "Param 1 with array type is required for rank helper"
  41             ),)
  42     );
  43     let total = teams.len();
  44     if rank == 0 {
  45         try!(rc.writer.write("champion".as_bytes()));
  46     } else if rank >= total - 2 {
  47         try!(rc.writer.write("relegation".as_bytes()));
  48     } else if rank <= 2 {
  49         try!(rc.writer.write("acl".as_bytes()));
  50     }
  51     Ok(())
  52 }
  53
  54 static TYPES: &'static str = "serde_json";
  55
  56 // define some data
  57 #[derive(Serialize)]
  58 pub struct Team {
  59     name: String,
  60     pts: u16,
  61 }
  62
  63 // produce some data
  64 pub fn make_data() -> Map<String, Json> {
  65     let mut data = Map::new();
  66
  67     data.insert("year".to_string(), to_json(&"2015".to_owned()));
  68
  69     let teams = vec![
  70         Team {
  71             name: "Jiangsu Suning".to_string(),
  72             pts: 43u16,
  73         },
  74         Team {
  75             name: "Shanghai SIPG".to_string(),
  76             pts: 39u16,
  77         },
  78         Team {
  79             name: "Hebei CFFC".to_string(),
  80             pts: 27u16,
  81         },
  82         Team {
  83             name: "Guangzhou Evergrand".to_string(),
  84             pts: 22u16,
  85         },
  86         Team {
  87             name: "Shandong Luneng".to_string(),
  88             pts: 12u16,
  89         },
  90         Team {
  91             name: "Beijing Guoan".to_string(),
  92             pts: 7u16,
  93         },
  94         Team {
  95             name: "Hangzhou Greentown".to_string(),
  96             pts: 7u16,
  97         },
  98         Team {
  99             name: "Shanghai Shenhua".to_string(),
 100             pts: 4u16,
 101         },
 102     ];
 103
 104     data.insert("teams".to_string(), to_json(&teams));
 105     data.insert("engine".to_string(), to_json(&TYPES.to_owned()));
 106     data
 107 }
 108
 109 fn main() {
 110     env_logger::init().unwrap();
 111     let mut handlebars = Handlebars::new();
 112
 113     handlebars.register_helper("format", Box::new(format_helper));
 114     handlebars.register_helper("ranking_label", Box::new(rank_helper));
 115     // handlebars.register_helper("format", Box::new(FORMAT_HELPER));
 116
 117     let data = make_data();
 118
 119     // I'm using unwrap directly here to demostration.
 120     // Never use this style in your real-world projects.
 121     let mut source_template = File::open(&"./examples/render_file/template.hbs").unwrap();
 122     let mut output_file = File::create("target/table.html").unwrap();
 123     if let Err(e) =
 124         handlebars.render_template_source_to_write(&mut source_template, &data, &mut output_file)
 125     {
 126         println!("Failed to generate target/table.html: {}", e);
 127     } else {
 128         println!("target/table.html generated");
 129     };
 130 }