Struct handlebars::Helper
source · pub struct Helper<'reg, 'rc> { /* private fields */ }
Expand description
Render-time Helper data when using in a helper definition
Implementations§
source§impl<'reg: 'rc, 'rc> Helper<'reg, 'rc>
impl<'reg: 'rc, 'rc> Helper<'reg, 'rc>
sourcepub fn name(&self) -> &str
pub fn name(&self) -> &str
Returns helper name
Examples found in repository?
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
fn render_helper<'reg: 'rc, 'rc>(
ht: &'reg HelperTemplate,
registry: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> Result<(), RenderError> {
let h = Helper::try_from_template(ht, registry, ctx, rc)?;
debug!(
"Rendering helper: {:?}, params: {:?}, hash: {:?}",
h.name(),
h.params(),
h.hash()
);
if let Some(ref d) = rc.get_local_helper(h.name()) {
d.call(&h, registry, ctx, rc, out)
} else {
let mut helper = registry.get_or_load_helper(h.name())?;
if helper.is_none() {
helper = registry.get_or_load_helper(if ht.block {
BLOCK_HELPER_MISSING
} else {
HELPER_MISSING
})?;
}
helper
.ok_or_else(|| RenderError::new(format!("Helper not defined: {:?}", h.name())))
.and_then(|d| d.call(&h, registry, ctx, rc, out))
}
}
sourcepub fn params(&self) -> &Vec<PathAndJson<'reg, 'rc>>
pub fn params(&self) -> &Vec<PathAndJson<'reg, 'rc>>
Returns all helper params, resolved within the context
Examples found in repository?
More examples
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
fn render_helper<'reg: 'rc, 'rc>(
ht: &'reg HelperTemplate,
registry: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> Result<(), RenderError> {
let h = Helper::try_from_template(ht, registry, ctx, rc)?;
debug!(
"Rendering helper: {:?}, params: {:?}, hash: {:?}",
h.name(),
h.params(),
h.hash()
);
if let Some(ref d) = rc.get_local_helper(h.name()) {
d.call(&h, registry, ctx, rc, out)
} else {
let mut helper = registry.get_or_load_helper(h.name())?;
if helper.is_none() {
helper = registry.get_or_load_helper(if ht.block {
BLOCK_HELPER_MISSING
} else {
HELPER_MISSING
})?;
}
helper
.ok_or_else(|| RenderError::new(format!("Helper not defined: {:?}", h.name())))
.and_then(|d| d.call(&h, registry, ctx, rc, out))
}
}
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
_: &'reg Registry<'reg>,
_: &'rc Context,
_: &mut RenderContext<'reg, 'rc>,
_: &mut dyn Output,
) -> HelperResult {
let param_to_log = h
.params()
.iter()
.map(|p| {
if let Some(ref relative_path) = p.relative_path() {
format!("{}: {}", relative_path, p.value().render())
} else {
p.value().render()
}
})
.collect::<Vec<String>>()
.join(", ");
let level = h
.hash_get("level")
.and_then(|v| v.value().as_str())
.unwrap_or("info");
if let Ok(log_level) = Level::from_str(level) {
log!(log_level, "{}", param_to_log)
} else {
return Err(RenderError::new(&format!(
"Unsupported logging level {}",
level
)));
}
Ok(())
}
sourcepub fn param(&self, idx: usize) -> Option<&PathAndJson<'reg, 'rc>>
pub fn param(&self, idx: usize) -> Option<&PathAndJson<'reg, 'rc>>
Returns nth helper param, resolved within the context.
Example
To get the first param in {{my_helper abc}}
or {{my_helper 2}}
,
use h.param(0)
in helper definition.
Variable abc
is auto resolved in current context.
use handlebars::*;
fn my_helper(h: &Helper, rc: &mut RenderContext) -> Result<(), RenderError> {
let v = h.param(0).map(|v| v.value())
.ok_or(RenderError::new("param not found"));
// ..
Ok(())
}
Examples found in repository?
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"if\""))?;
let include_zero = h
.hash_get("includeZero")
.and_then(|v| v.value().as_bool())
.unwrap_or(false);
let mut value = param.value().is_truthy(include_zero);
if !self.positive {
value = !value;
}
let tmpl = if value { h.template() } else { h.inverse() };
match tmpl {
Some(t) => t.render(r, ctx, rc, out),
None => Ok(()),
}
}
More examples
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
fn call_inner<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
_: &'rc Context,
_: &mut RenderContext<'reg, 'rc>,
) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
let collection_value = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"lookup\""))?;
let index = h
.param(1)
.ok_or_else(|| RenderError::new("Insufficient params for helper \"lookup\""))?;
let value = match *collection_value.value() {
Json::Array(ref v) => index
.value()
.as_u64()
.and_then(|u| v.get(u as usize))
.unwrap_or(&Json::Null),
Json::Object(ref m) => index
.value()
.as_str()
.and_then(|k| m.get(k))
.unwrap_or(&Json::Null),
_ => &Json::Null,
};
if r.strict_mode() && value.is_null() {
Err(RenderError::strict_error(None))
} else {
Ok(value.clone().into())
}
}
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"with\""))?;
if param.value().is_truthy(false) {
let mut block = create_block(param);
if let Some(block_param) = h.block_param() {
let mut params = BlockParams::new();
if param.context_path().is_some() {
params.add_path(block_param, Vec::with_capacity(0))?;
} else {
params.add_value(block_param, param.value().clone())?;
}
block.set_block_params(params);
}
rc.push_block(block);
if let Some(t) = h.template() {
t.render(r, ctx, rc, out)?;
};
rc.pop_block();
Ok(())
} else if let Some(t) = h.inverse() {
t.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(param.relative_path()))
} else {
Ok(())
}
}
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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let value = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"each\""))?;
let template = h.template();
match template {
Some(t) => match *value.value() {
Json::Array(ref list)
if !list.is_empty() || (list.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = list.len();
let array_path = value.context_path();
for (i, v) in list.iter().enumerate().take(len) {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let index = to_json(i);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("index", index.clone());
update_block_context(block, array_path, i.to_string(), is_first, v);
set_block_param(block, h, array_path, &index, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
Json::Object(ref obj)
if !obj.is_empty() || (obj.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = obj.len();
let obj_path = value.context_path();
for (i, (k, v)) in obj.iter().enumerate() {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let key = to_json(k);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("key", key.clone());
update_block_context(block, obj_path, k.to_string(), is_first, v);
set_block_param(block, h, obj_path, &key, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
_ => {
if let Some(else_template) = h.inverse() {
else_template.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(value.relative_path()))
} else {
Ok(())
}
}
},
None => Ok(()),
}
}
sourcepub fn hash(&self) -> &BTreeMap<&'reg str, PathAndJson<'reg, 'rc>>
pub fn hash(&self) -> &BTreeMap<&'reg str, PathAndJson<'reg, 'rc>>
Returns hash, resolved within the context
Examples found in repository?
More examples
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
fn render_helper<'reg: 'rc, 'rc>(
ht: &'reg HelperTemplate,
registry: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> Result<(), RenderError> {
let h = Helper::try_from_template(ht, registry, ctx, rc)?;
debug!(
"Rendering helper: {:?}, params: {:?}, hash: {:?}",
h.name(),
h.params(),
h.hash()
);
if let Some(ref d) = rc.get_local_helper(h.name()) {
d.call(&h, registry, ctx, rc, out)
} else {
let mut helper = registry.get_or_load_helper(h.name())?;
if helper.is_none() {
helper = registry.get_or_load_helper(if ht.block {
BLOCK_HELPER_MISSING
} else {
HELPER_MISSING
})?;
}
helper
.ok_or_else(|| RenderError::new(format!("Helper not defined: {:?}", h.name())))
.and_then(|d| d.call(&h, registry, ctx, rc, out))
}
}
sourcepub fn hash_get(&self, key: &str) -> Option<&PathAndJson<'reg, 'rc>>
pub fn hash_get(&self, key: &str) -> Option<&PathAndJson<'reg, 'rc>>
Return hash value of a given key, resolved within the context
Example
To get the first param in {{my_helper v=abc}}
or {{my_helper v=2}}
,
use h.hash_get("v")
in helper definition.
Variable abc
is auto resolved in current context.
use handlebars::*;
fn my_helper(h: &Helper, rc: &mut RenderContext) -> Result<(), RenderError> {
let v = h.hash_get("v").map(|v| v.value())
.ok_or(RenderError::new("param not found"));
// ..
Ok(())
}
Examples found in repository?
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"if\""))?;
let include_zero = h
.hash_get("includeZero")
.and_then(|v| v.value().as_bool())
.unwrap_or(false);
let mut value = param.value().is_truthy(include_zero);
if !self.positive {
value = !value;
}
let tmpl = if value { h.template() } else { h.inverse() };
match tmpl {
Some(t) => t.render(r, ctx, rc, out),
None => Ok(()),
}
}
More examples
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
_: &'reg Registry<'reg>,
_: &'rc Context,
_: &mut RenderContext<'reg, 'rc>,
_: &mut dyn Output,
) -> HelperResult {
let param_to_log = h
.params()
.iter()
.map(|p| {
if let Some(ref relative_path) = p.relative_path() {
format!("{}: {}", relative_path, p.value().render())
} else {
p.value().render()
}
})
.collect::<Vec<String>>()
.join(", ");
let level = h
.hash_get("level")
.and_then(|v| v.value().as_str())
.unwrap_or("info");
if let Ok(log_level) = Level::from_str(level) {
log!(log_level, "{}", param_to_log)
} else {
return Err(RenderError::new(&format!(
"Unsupported logging level {}",
level
)));
}
Ok(())
}
sourcepub fn template(&self) -> Option<&'reg Template>
pub fn template(&self) -> Option<&'reg Template>
Returns the default inner template if the helper is a block helper.
Typically you will render the template via: template.render(registry, render_context)
Examples found in repository?
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let tpl = h.template();
if let Some(t) = tpl {
t.render(r, ctx, rc, out)
} else {
Ok(())
}
}
More examples
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"if\""))?;
let include_zero = h
.hash_get("includeZero")
.and_then(|v| v.value().as_bool())
.unwrap_or(false);
let mut value = param.value().is_truthy(include_zero);
if !self.positive {
value = !value;
}
let tmpl = if value { h.template() } else { h.inverse() };
match tmpl {
Some(t) => t.render(r, ctx, rc, out),
None => Ok(()),
}
}
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"with\""))?;
if param.value().is_truthy(false) {
let mut block = create_block(param);
if let Some(block_param) = h.block_param() {
let mut params = BlockParams::new();
if param.context_path().is_some() {
params.add_path(block_param, Vec::with_capacity(0))?;
} else {
params.add_value(block_param, param.value().clone())?;
}
block.set_block_params(params);
}
rc.push_block(block);
if let Some(t) = h.template() {
t.render(r, ctx, rc, out)?;
};
rc.pop_block();
Ok(())
} else if let Some(t) = h.inverse() {
t.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(param.relative_path()))
} else {
Ok(())
}
}
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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let value = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"each\""))?;
let template = h.template();
match template {
Some(t) => match *value.value() {
Json::Array(ref list)
if !list.is_empty() || (list.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = list.len();
let array_path = value.context_path();
for (i, v) in list.iter().enumerate().take(len) {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let index = to_json(i);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("index", index.clone());
update_block_context(block, array_path, i.to_string(), is_first, v);
set_block_param(block, h, array_path, &index, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
Json::Object(ref obj)
if !obj.is_empty() || (obj.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = obj.len();
let obj_path = value.context_path();
for (i, (k, v)) in obj.iter().enumerate() {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let key = to_json(k);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("key", key.clone());
update_block_context(block, obj_path, k.to_string(), is_first, v);
set_block_param(block, h, obj_path, &key, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
_ => {
if let Some(else_template) = h.inverse() {
else_template.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(value.relative_path()))
} else {
Ok(())
}
}
},
None => Ok(()),
}
}
sourcepub fn inverse(&self) -> Option<&'reg Template>
pub fn inverse(&self) -> Option<&'reg Template>
Returns the template of else
branch if any
Examples found in repository?
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"if\""))?;
let include_zero = h
.hash_get("includeZero")
.and_then(|v| v.value().as_bool())
.unwrap_or(false);
let mut value = param.value().is_truthy(include_zero);
if !self.positive {
value = !value;
}
let tmpl = if value { h.template() } else { h.inverse() };
match tmpl {
Some(t) => t.render(r, ctx, rc, out),
None => Ok(()),
}
}
More examples
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"with\""))?;
if param.value().is_truthy(false) {
let mut block = create_block(param);
if let Some(block_param) = h.block_param() {
let mut params = BlockParams::new();
if param.context_path().is_some() {
params.add_path(block_param, Vec::with_capacity(0))?;
} else {
params.add_value(block_param, param.value().clone())?;
}
block.set_block_params(params);
}
rc.push_block(block);
if let Some(t) = h.template() {
t.render(r, ctx, rc, out)?;
};
rc.pop_block();
Ok(())
} else if let Some(t) = h.inverse() {
t.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(param.relative_path()))
} else {
Ok(())
}
}
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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let value = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"each\""))?;
let template = h.template();
match template {
Some(t) => match *value.value() {
Json::Array(ref list)
if !list.is_empty() || (list.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = list.len();
let array_path = value.context_path();
for (i, v) in list.iter().enumerate().take(len) {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let index = to_json(i);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("index", index.clone());
update_block_context(block, array_path, i.to_string(), is_first, v);
set_block_param(block, h, array_path, &index, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
Json::Object(ref obj)
if !obj.is_empty() || (obj.is_empty() && h.inverse().is_none()) =>
{
let block_context = create_block(value);
rc.push_block(block_context);
let len = obj.len();
let obj_path = value.context_path();
for (i, (k, v)) in obj.iter().enumerate() {
if let Some(ref mut block) = rc.block_mut() {
let is_first = i == 0usize;
let is_last = i == len - 1;
let key = to_json(k);
block.set_local_var("first", to_json(is_first));
block.set_local_var("last", to_json(is_last));
block.set_local_var("key", key.clone());
update_block_context(block, obj_path, k.to_string(), is_first, v);
set_block_param(block, h, obj_path, &key, v)?;
}
t.render(r, ctx, rc, out)?;
}
rc.pop_block();
Ok(())
}
_ => {
if let Some(else_template) = h.inverse() {
else_template.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(value.relative_path()))
} else {
Ok(())
}
}
},
None => Ok(()),
}
}
sourcepub fn is_block(&self) -> bool
pub fn is_block(&self) -> bool
Returns if the helper is a block one {{#helper}}{{/helper}}
or not {{helper 123}}
sourcepub fn has_block_param(&self) -> bool
pub fn has_block_param(&self) -> bool
Returns if the helper has either a block param or block param pair
sourcepub fn block_param(&self) -> Option<&'reg str>
pub fn block_param(&self) -> Option<&'reg str>
Returns block param if any
Examples found in repository?
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
fn set_block_param<'reg: 'rc, 'rc>(
block: &mut BlockContext<'reg>,
h: &Helper<'reg, 'rc>,
base_path: Option<&Vec<String>>,
k: &Json,
v: &Json,
) -> Result<(), RenderError> {
if let Some(bp_val) = h.block_param() {
let mut params = BlockParams::new();
if base_path.is_some() {
params.add_path(bp_val, Vec::with_capacity(0))?;
} else {
params.add_value(bp_val, v.clone())?;
}
block.set_block_params(params);
} else if let Some((bp_val, bp_key)) = h.block_param_pair() {
let mut params = BlockParams::new();
if base_path.is_some() {
params.add_path(bp_val, Vec::with_capacity(0))?;
} else {
params.add_value(bp_val, v.clone())?;
}
params.add_value(bp_key, k.clone())?;
block.set_block_params(params);
}
Ok(())
}
More examples
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
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry<'reg>,
ctx: &'rc Context,
rc: &mut RenderContext<'reg, 'rc>,
out: &mut dyn Output,
) -> HelperResult {
let param = h
.param(0)
.ok_or_else(|| RenderError::new("Param not found for helper \"with\""))?;
if param.value().is_truthy(false) {
let mut block = create_block(param);
if let Some(block_param) = h.block_param() {
let mut params = BlockParams::new();
if param.context_path().is_some() {
params.add_path(block_param, Vec::with_capacity(0))?;
} else {
params.add_value(block_param, param.value().clone())?;
}
block.set_block_params(params);
}
rc.push_block(block);
if let Some(t) = h.template() {
t.render(r, ctx, rc, out)?;
};
rc.pop_block();
Ok(())
} else if let Some(t) = h.inverse() {
t.render(r, ctx, rc, out)
} else if r.strict_mode() {
Err(RenderError::strict_error(param.relative_path()))
} else {
Ok(())
}
}
sourcepub fn block_param_pair(&self) -> Option<(&'reg str, &'reg str)>
pub fn block_param_pair(&self) -> Option<(&'reg str, &'reg str)>
Return block param pair (for example |key, val|) if any
Examples found in repository?
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
fn set_block_param<'reg: 'rc, 'rc>(
block: &mut BlockContext<'reg>,
h: &Helper<'reg, 'rc>,
base_path: Option<&Vec<String>>,
k: &Json,
v: &Json,
) -> Result<(), RenderError> {
if let Some(bp_val) = h.block_param() {
let mut params = BlockParams::new();
if base_path.is_some() {
params.add_path(bp_val, Vec::with_capacity(0))?;
} else {
params.add_value(bp_val, v.clone())?;
}
block.set_block_params(params);
} else if let Some((bp_val, bp_key)) = h.block_param_pair() {
let mut params = BlockParams::new();
if base_path.is_some() {
params.add_path(bp_val, Vec::with_capacity(0))?;
} else {
params.add_value(bp_val, v.clone())?;
}
params.add_value(bp_key, k.clone())?;
block.set_block_params(params);
}
Ok(())
}