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