mirror of
https://github.com/gohugoio/hugo.git
synced 2024-07-14 04:48:06 +00:00
![Bjørn Erik Pedersen](/assets/img/avatar_default.png)
Before this commit, due to a bug in Go's `text/template` package, this would print different output for typed nil interface values: ``` {{ if .AuthenticatedUser }}User is authenticated!{{ else }}{{ end }} {{ if not .AuthenticatedUser }}{{ else }}}User is authenticated!{{ end }} ``` This commit works around this by wrapping every `if` and `with` with a custom `getif` template func with truth logic that matches `not`, `and` and `or`. Those 3 template funcs from Go's stdlib are now pulled into Hugo's source tree and adjusted to support custom zero values, e.g. types that implement `IsZero`. This means that you can now do: ``` {{ with .Date }}{{ . }}{{ end }} ``` And it would work as expected. Fixes #5738
347 lines
7.8 KiB
Go
347 lines
7.8 KiB
Go
// Copyright 2016 The Hugo Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package tplimpl
|
|
|
|
import (
|
|
"errors"
|
|
"html/template"
|
|
"strings"
|
|
texttemplate "text/template"
|
|
"text/template/parse"
|
|
)
|
|
|
|
// decl keeps track of the variable mappings, i.e. $mysite => .Site etc.
|
|
type decl map[string]string
|
|
|
|
const (
|
|
paramsIdentifier = "Params"
|
|
)
|
|
|
|
// Containers that may contain Params that we will not touch.
|
|
var reservedContainers = map[string]bool{
|
|
// Aka .Site.Data.Params which must stay case sensitive.
|
|
"Data": true,
|
|
}
|
|
|
|
type templateContext struct {
|
|
decl decl
|
|
visited map[string]bool
|
|
lookupFn func(name string) *parse.Tree
|
|
}
|
|
|
|
func (c templateContext) getIfNotVisited(name string) *parse.Tree {
|
|
if c.visited[name] {
|
|
return nil
|
|
}
|
|
c.visited[name] = true
|
|
return c.lookupFn(name)
|
|
}
|
|
|
|
func newTemplateContext(lookupFn func(name string) *parse.Tree) *templateContext {
|
|
return &templateContext{lookupFn: lookupFn, decl: make(map[string]string), visited: make(map[string]bool)}
|
|
|
|
}
|
|
|
|
func createParseTreeLookup(templ *template.Template) func(nn string) *parse.Tree {
|
|
return func(nn string) *parse.Tree {
|
|
tt := templ.Lookup(nn)
|
|
if tt != nil {
|
|
return tt.Tree
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func applyTemplateTransformersToHMLTTemplate(templ *template.Template) error {
|
|
return applyTemplateTransformers(templ.Tree, createParseTreeLookup(templ))
|
|
}
|
|
|
|
func applyTemplateTransformersToTextTemplate(templ *texttemplate.Template) error {
|
|
return applyTemplateTransformers(templ.Tree,
|
|
func(nn string) *parse.Tree {
|
|
tt := templ.Lookup(nn)
|
|
if tt != nil {
|
|
return tt.Tree
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func applyTemplateTransformers(templ *parse.Tree, lookupFn func(name string) *parse.Tree) error {
|
|
if templ == nil {
|
|
return errors.New("expected template, but none provided")
|
|
}
|
|
|
|
c := newTemplateContext(lookupFn)
|
|
|
|
c.applyTransformations(templ.Root)
|
|
|
|
return nil
|
|
}
|
|
|
|
// The truth logic in Go's template package is broken for certain values
|
|
// for the if and with keywords. This works around that problem by wrapping
|
|
// the node passed to if/with in a getif conditional.
|
|
// getif works slightly different than the Go built-in in that it also
|
|
// considers any IsZero methods on the values (as in time.Time).
|
|
// See https://github.com/gohugoio/hugo/issues/5738
|
|
func (c *templateContext) wrapWithGetIf(p *parse.PipeNode) {
|
|
if len(p.Cmds) == 0 {
|
|
return
|
|
}
|
|
|
|
// getif will return an empty string if not evaluated as truthful,
|
|
// which is when we need the value in the with clause.
|
|
firstArg := parse.NewIdentifier("getif")
|
|
secondArg := p.CopyPipe()
|
|
newCmd := p.Cmds[0].Copy().(*parse.CommandNode)
|
|
|
|
// secondArg is a PipeNode and will behave as it was wrapped in parens, e.g:
|
|
// {{ getif (len .Params | eq 2) }}
|
|
newCmd.Args = []parse.Node{firstArg, secondArg}
|
|
|
|
p.Cmds = []*parse.CommandNode{newCmd}
|
|
|
|
}
|
|
|
|
// applyTransformations do two things:
|
|
// 1) Make all .Params.CamelCase and similar into lowercase.
|
|
// 2) Wraps every with and if pipe in getif
|
|
func (c *templateContext) applyTransformations(n parse.Node) {
|
|
switch x := n.(type) {
|
|
case *parse.ListNode:
|
|
if x != nil {
|
|
c.applyTransformationsToNodes(x.Nodes...)
|
|
}
|
|
case *parse.ActionNode:
|
|
c.applyTransformationsToNodes(x.Pipe)
|
|
case *parse.IfNode:
|
|
c.applyTransformationsToNodes(x.Pipe, x.List, x.ElseList)
|
|
c.wrapWithGetIf(x.Pipe)
|
|
case *parse.WithNode:
|
|
c.applyTransformationsToNodes(x.Pipe, x.List, x.ElseList)
|
|
c.wrapWithGetIf(x.Pipe)
|
|
case *parse.RangeNode:
|
|
c.applyTransformationsToNodes(x.Pipe, x.List, x.ElseList)
|
|
case *parse.TemplateNode:
|
|
subTempl := c.getIfNotVisited(x.Name)
|
|
if subTempl != nil {
|
|
c.applyTransformationsToNodes(subTempl.Root)
|
|
}
|
|
case *parse.PipeNode:
|
|
if len(x.Decl) == 1 && len(x.Cmds) == 1 {
|
|
// maps $site => .Site etc.
|
|
c.decl[x.Decl[0].Ident[0]] = x.Cmds[0].String()
|
|
}
|
|
|
|
for _, cmd := range x.Cmds {
|
|
c.applyTransformations(cmd)
|
|
}
|
|
|
|
case *parse.CommandNode:
|
|
for _, elem := range x.Args {
|
|
switch an := elem.(type) {
|
|
case *parse.FieldNode:
|
|
c.updateIdentsIfNeeded(an.Ident)
|
|
case *parse.VariableNode:
|
|
c.updateIdentsIfNeeded(an.Ident)
|
|
case *parse.PipeNode:
|
|
c.applyTransformations(an)
|
|
case *parse.ChainNode:
|
|
// site.Params...
|
|
if len(an.Field) > 1 && an.Field[0] == paramsIdentifier {
|
|
c.updateIdentsIfNeeded(an.Field)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *templateContext) applyTransformationsToNodes(nodes ...parse.Node) {
|
|
for _, node := range nodes {
|
|
c.applyTransformations(node)
|
|
}
|
|
}
|
|
|
|
func (c *templateContext) updateIdentsIfNeeded(idents []string) {
|
|
index := c.decl.indexOfReplacementStart(idents)
|
|
|
|
if index == -1 {
|
|
return
|
|
}
|
|
|
|
for i := index; i < len(idents); i++ {
|
|
idents[i] = strings.ToLower(idents[i])
|
|
}
|
|
|
|
}
|
|
|
|
// indexOfReplacementStart will return the index of where to start doing replacement,
|
|
// -1 if none needed.
|
|
func (d decl) indexOfReplacementStart(idents []string) int {
|
|
|
|
l := len(idents)
|
|
|
|
if l == 0 {
|
|
return -1
|
|
}
|
|
|
|
if l == 1 {
|
|
first := idents[0]
|
|
if first == "" || first == paramsIdentifier || first[0] == '$' {
|
|
// This can not be a Params.x
|
|
return -1
|
|
}
|
|
}
|
|
|
|
var lookFurther bool
|
|
var needsVarExpansion bool
|
|
for _, ident := range idents {
|
|
if ident[0] == '$' {
|
|
lookFurther = true
|
|
needsVarExpansion = true
|
|
break
|
|
} else if ident == paramsIdentifier {
|
|
lookFurther = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !lookFurther {
|
|
return -1
|
|
}
|
|
|
|
var resolvedIdents []string
|
|
|
|
if !needsVarExpansion {
|
|
resolvedIdents = idents
|
|
} else {
|
|
var ok bool
|
|
resolvedIdents, ok = d.resolveVariables(idents)
|
|
if !ok {
|
|
return -1
|
|
}
|
|
}
|
|
|
|
var paramFound bool
|
|
for i, ident := range resolvedIdents {
|
|
if ident == paramsIdentifier {
|
|
if i > 0 {
|
|
container := resolvedIdents[i-1]
|
|
if reservedContainers[container] {
|
|
// .Data.Params.someKey
|
|
return -1
|
|
}
|
|
}
|
|
|
|
paramFound = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !paramFound {
|
|
return -1
|
|
}
|
|
|
|
var paramSeen bool
|
|
idx := -1
|
|
for i, ident := range idents {
|
|
if ident == "" || ident[0] == '$' {
|
|
continue
|
|
}
|
|
|
|
if ident == paramsIdentifier {
|
|
paramSeen = true
|
|
idx = -1
|
|
|
|
} else {
|
|
if paramSeen {
|
|
return i
|
|
}
|
|
if idx == -1 {
|
|
idx = i
|
|
}
|
|
}
|
|
}
|
|
return idx
|
|
|
|
}
|
|
|
|
func (d decl) resolveVariables(idents []string) ([]string, bool) {
|
|
var (
|
|
replacements []string
|
|
replaced []string
|
|
)
|
|
|
|
// An Ident can start out as one of
|
|
// [Params] [$blue] [$colors.Blue]
|
|
// We need to resolve the variables, so
|
|
// $blue => [Params Colors Blue]
|
|
// etc.
|
|
replacements = []string{idents[0]}
|
|
|
|
// Loop until there are no more $vars to resolve.
|
|
for i := 0; i < len(replacements); i++ {
|
|
|
|
if i > 20 {
|
|
// bail out
|
|
return nil, false
|
|
}
|
|
|
|
potentialVar := replacements[i]
|
|
|
|
if potentialVar == "$" {
|
|
continue
|
|
}
|
|
|
|
if potentialVar == "" || potentialVar[0] != '$' {
|
|
// leave it as is
|
|
replaced = append(replaced, strings.Split(potentialVar, ".")...)
|
|
continue
|
|
}
|
|
|
|
replacement, ok := d[potentialVar]
|
|
|
|
if !ok {
|
|
// Temporary range vars. We do not care about those.
|
|
return nil, false
|
|
}
|
|
|
|
if !d.isKeyword(replacement) {
|
|
// This can not be .Site.Params etc.
|
|
return nil, false
|
|
}
|
|
|
|
replacement = strings.TrimPrefix(replacement, ".")
|
|
|
|
if replacement == "" {
|
|
continue
|
|
}
|
|
|
|
if replacement[0] == '$' {
|
|
// Needs further expansion
|
|
replacements = append(replacements, strings.Split(replacement, ".")...)
|
|
} else {
|
|
replaced = append(replaced, strings.Split(replacement, ".")...)
|
|
}
|
|
}
|
|
|
|
return append(replaced, idents[1:]...), true
|
|
|
|
}
|
|
|
|
func (d decl) isKeyword(s string) bool {
|
|
return !strings.ContainsAny(s, " -\"")
|
|
}
|