When I am importing a subtemplate outside of a {{ range }} loop, variables are passed successfully inside the imported template:
...
{{ template "userdata" . }}
...
(here, I can access my outer templates variables in the inner template userdata). So far so good.
However same fashion import doesn't work when being called inside a {{ range }} loop:
...
{{ range $instance := .Instances }}
- type: instance
metadata:
userdata: {{ template "userdata" . }}
...
Above ends with error messaging out something like:
Error: template: template.tmpl:3:46: executing "userdata" at <XXX>: can't evaluate field XXX in type int`
As far as I understand, it shadow my context variable with the loop iterator variable, and so it does not work.
How am I supposed to do it properly?
How do I pass the value of . outside of the range loop to template "userdata" when inside a range loop?
Assign the value of . to a variable. Use the variable in the loop:
...
{{$x := .}}
{{ range $instance := .Instances }}
- type: instance
metadata:
userdata: {{ template "userdata" $x }}
...
If . is the root value in the template, then use $ to refer to that value:
...
{{ range $instance := .Instances }}
- type: instance
metadata:
userdata: {{ template "userdata" $ }}
...
Run it on the playground.
Related
I am writing a layout template for a Hugo generated post/page. The .yaml header is
image:
- post/mytitle/image.jpg
The template incorporates the variable in Hugo as
{{ .Params.Image }}
When served, the variable is returned as
[post/mytitle/image.jpg]
My html then becomes
<img src="[post/mytitle/image.jpg]"/>
which is 404 in the browser. I've tried a number of Hugo functions to no avail like {{ trim .Param.Image "[]" }} and {{ subset .Params.Image 1 -1 }} and {{ print .Params.Image }}. Each time Hugo returned the error: "error calling substr: unable to cast []string{"post/mytitle/image.jpg"} of type []string to string".
How do I get the variable to return the string without the brackets, or alternatively, how do I omit the brackets from the string?
In Go template, you access an item in a slice with index:
{{ index .Params.Image 0 }}
The question is why the value is a sequence in the first place. You could simply do
image:
post/mytitle/image.jpg
Then you could keep the original syntax since it is now a simple value, not a sequence.
If you want to possibly include multiple images, you'd do
{{ range .Params.Image }}<img src="{{.}}">{{ end }}
Then you can have
image:
- post/mytitle/image.jpg
- post/mytitle/anotherimage.jpg
I'm developing a big hugo template. I try to simplfy the problem, so I have two datafile:
PROMO_00_1.yaml
PROMO_00_2.yaml
that are phisically stored in this directory:
themes/data/hp/
So, in the site config the user will decide which of this data file will be used simply indicate it in a param (HpElement).
In the template I call the partial in this way:
{{ partial "multiplepages/homepage/promos/00_promo_singleslide_text_video" (dict "context" . "data" $.Site.Params.HpElement) }}
In a partial I write:
{{ $data_partial := (printf "$.Site.Data.homepage.%s" .data)}}
{{ $data_partial}}
and the Hugo output is on the website:
$.Site.Data.homepage.PROMO_00_1
What I need is to access the single variable inside the .yaml file but the user MUST can decide which YAML file have to use. How can I achieve that?
Thanks
I just finished up a similar use case where I needed to select a YAML based on a date stamp. The index function is key to this operation.
https://gohugo.io/functions/index-function/
Here is a simplified version of my situation:
{{ $date := now.Format "s20060102"}}
{{ $data := (index .Site.Data.schedule $date) }}
{{ with $data }}
<h1>.longdate</h1>
{{ range .times }}
<h2>{{ .name }} - {{ .location }}
{{ end}
{{ end}
The example in the Hugo documentation uses an example where the data file is selected based on an attribute in the front matter.
I need to write a template where I first define some variables, and then use them in what will be generated from the template:
{{ if $value.Env.CADDY_URL }}
{{ $url := $value.Env.CADDY_URL }}
{{ else }}
{{ $url := printf "http://%s.example.info" $value.Name }}
{{ end }}
{{/* more template */}}
{{/* and here I would like to use $url defined above */}}
{{ $url }}
I get the error
undefined variable "$url"
Reading the documentation, I see that
A variable's scope extends to the "end" action of the control structure ("if", "with", or "range") in which it is declared, or to the end of the template if there is no such control structure.
Does this mean that there are no global (or scoped on the whole template) variables? Or is there a way to define $url so that it can be reused later in the template?
Variables are scoped. You create the $url variable inside the {{if}} and {{else}} blocks, so they are not visible outside of those blocks.
Create the variable before the {{if}}, and use assignment = instead of declaration :=:
{{$url := ""}}
{{ if . }}
{{ $url = "http://true.com" }}
{{ else }}
{{ $url = "http://false.com" }}
{{ end }}
{{ $url }}
Testing it:
t := template.Must(template.New("").Parse(src))
fmt.Println(t.Execute(os.Stdout, true))
fmt.Println(t.Execute(os.Stdout, false))
Output (try it on the Go Playground):
http://true.com<nil>
http://false.com<nil>
Note: Modifying template variables with assignment was added in Go 1.11, so you need to build your app with Go 1.11 or newer. If you're using an older version, you cannot modify values of template variables.
Edit: I've found a duplicate: How do I assign variables within a conditional
You can mimic "changeable template variables" in earlier versions, see this question for examples: In a Go template range loop, are variables declared outside the loop reset on each iteration?
The below works
{{- if hasKey (index $envAll.Values.policy) "type" }}
{{- if has "two-wheeler" (index $envAll.Values.policy "type") }}
<code goes here>
{{- end }}
{{- end }}
while the below fails with "runtime error: invalid memory address or nil pointer dereference"
{{- if and (hasKey (index $envAll.Values.policy) "type") (has "two-wheeler" (index $envAll.Values.policy "type")) }}
<code goes here>
{{- end}}
There is no list by name "type" declared under $envAll.Values.policy.
In Go, if the right operand is evaluated conditionally, why does the last condition gets evaluated in the second code snippet? How do I solve it?
Edit (since it marked as duplicate):
Unfortunately, I cannot use embedded {{ if }} like it is mentioned in the other post.
I simplified my problem above. I actually have to achieve this...
{{if or (and (condition A) (condition B)) (condition C)) }}
<code goes here>
{{ end }}
You get an error when using the and function because the and function in Go templates is not short-circuit evaluated (unlike the && operator in Go), all its arguments are evaluated always. Read more about it here: Golang template and testing for Valid fields
So you have to use embedded {{if}} actions so the 2nd argument is only evaluated if the first is also true.
You edited the question and stated that your actual problem is this:
{{if or (and (condition A) (condition B)) (condition C)) }}
<code goes here>
{{ end }}
This is how you can do it in templates only:
{{ $result := false }}
{{ if (conddition A )}}
{{ if (condition B) }}
{{ $result = true }}
{{ end }}
{{ end }}
{{ if or $result (condition C) }}
<code goes here>
{{ end }}
Another option is to pass the result of that logic to the template as a parameter.
If you can't or don't know the result before calling the template, yet another option is to register a custom function, and call this custom function from the template, and you can do short-circuit evaluation in Go code. For an example, see How to calculate something in html/template.
You could potentially use the Helm default function to avoid the second conditional.
It looks like your code is trying to test if .Values.policy.type.two-wheeler is present, with the caveat that the type layer may not exist at all. If there's no type, then .Values.policy.type evaluates to nil, and you can't do additional lookups in it.
The workaround, then, is to use default to substitute an empty dictionary for nil. Since it's then a dictionary you can do lookups in it, and since the default is empty testing for any specific thing will fail.
{{- $type := $envAll.Values.policy.type | default dict }}
{{- if has "two-wheeler" $type }}
<code goes here>
{{- end }}
You can put this into a one-liner if you want
{{- if has "two-wheeler" ($envAll.Values.policy.type | default dict) }}...{{ end }}
If you're actually going to use the value and not just test for its presence, another useful trick here can be to use the standard template with block instead of if. If with's conditional is "true" then it evaluates the block with . set to its value, and otherwise it skips the block (or runs an else block). In particular here, if a map value isn't present, then its lookup returns nil, which is "false" for conditional purposes (though note other things like 0 and empty string are "false" as well).
{{- $type := $envAll.Values.policy.type | default dict }}
{{- with $type.two-wheeler }}
{{-/* this references .Values.policy.type.two-wheeler.frontWheel */}}
frontWheel: {{ .frontWheel }}
backWheel: {{ .backWheel }}
{{- end }}
When inside a with or range, the scope of . is changed. How do you access the calling scope?
{{with .Inner}}
Outer: {{$.OuterValue}}
Inner: {{.InnerValue}}
{{end}}
$ is documented in the text/template docs:
When execution begins, $ is set to the data argument passed to Execute, that is, to the starting value of dot.
You can save the calling scope with a variable:
{{ $save := . }}
{{ with .Inner }}
Outer: {{ $save.OuterValue }}
Inner: {{ .InnerValue }}
{{ end }}