language: c dist: trusty os: - osx - linux compiler: - clang - gcc env: - BUILD=yes TEST=test COVERAGE=no FEATURES=tiny CONFOPT= SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no # ASAN build - BUILD=yes TEST=test SANITIZER_CFLAGS="-g -O1 -DABORT_ON_INTERNAL_ERROR -DEXITFREE -fsanitize=address -fno-omit-frame-pointer" FEATURES=huge SRCDIR=./src CHECK_AUTOCONF=no ASAN_OPTIONS="print_stacktrace=1 log_path=asan" LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/src/testdir/lsan-suppress.txt" "CONFOPT='--enable-perlinterp --enable-pythoninterp --enable-rubyinterp --enable-luainterp --enable-tclinterp'" - BUILD=yes TEST=scripttests COVERAGE=yes CFLAGS=--coverage LDFLAGS=--coverage FEATURES=huge SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no "CONFOPT='--enable-perlinterp --enable-pythoninterp --enable-python3interp --enable-rubyinterp --enable-luainterp --enable-tclinterp'" - BUILD=no TEST=unittests COVERAGE=yes CFLAGS=--coverage LDFLAGS=--coverage FEATURES=huge SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=yes - BUILD=yes TEST=test COVERAGE=no FEATURES=normal CONFOPT= SHADOWOPT="-C src/shadow" SRCDIR=./src/shadow CHECK_AUTOCONF=no - BUILD=yes TEST=test COVERAGE=no FEATURES=small CONFOPT= SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no # Mac OSX build - BUILD=yes TEST=test COVERAGE=no FEATURES=huge SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no "CONFOPT='--enable-perlinterp --enable-pythoninterp --enable-rubyinterp --enable-luainterp --enable-tclinterp'" sudo: false # instead of a 2*2*8 matrix (2*os + 2*compiler + 8*env), # exclude some builds on mac os x and linux # linux: 2*compiler + 5*env + mac: 2*compiler + 2*env matrix: exclude: - os: osx env: BUILD=yes TEST=test COVERAGE=no FEATURES=normal CONFOPT= SHADOWOPT="-C src/shadow" SRCDIR=./src/shadow CHECK_AUTOCONF=no - os: osx env: BUILD=no TEST=unittests COVERAGE=yes CFLAGS=--coverage LDFLAGS=--coverage FEATURES=huge SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=yes - os: osx env: BUILD=yes TEST=test COVERAGE=no FEATURES=small CONFOPT= SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no - os: osx env: BUILD=yes TEST=scripttests COVERAGE=yes CFLAGS=--coverage LDFLAGS=--coverage FEATURES=huge SHADOWOPT= SRCDIR=./src CHECK_AUTOCONF=no "CONFOPT='--enable-perlinterp --enable-pythoninterp --enable-python3interp --enable-rubyinterp --enable-luainterp --enable-tclinterp'" - os: osx env: BUILD=yes TEST=test SANITIZER_CFLAGS="-g -O1 -DABORT_ON_INTERNAL_ERROR -DEXITFREE -fsanitize=address -fno-omit-frame-pointer" FEATURES=huge SRCDIR=./src CHECK_AUTOCONF=no ASAN_OPTIONS="print_stacktrace=1 log_path=asan" LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/src/testdir/lsan-suppress.txt" "CONFOPT='--enable-perlinterp --enable-pythoninterp --enable-rubyinterp --enable-luainterp --enable-tclinterp'" - os: linux compiler: clang env: BUILD=yes TEST=test SANITIZER_CFLAGS="-g -O1 -DABORT_ON_INTERNAL_ERROR -DEXITFREE -fsanitize=address -fno-omit-frame-pointer" FEATURES=huge SRCDIR=./src CHECK_AUTOCONF=no ASAN_OPTIONS="print_stacktrace=1 log_path=asan" LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/src/testdir/lsan-suppress.txt" "CONFOPT='--// Copyright 2017 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 partials provides template functions for working with reusable // templates. package partials import ( "errors" "fmt" "html/template" "io" "io/ioutil" "reflect" "strings" "sync" "github.com/gohugoio/hugo/common/hreflect" texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/tpl" bp "github.com/gohugoio/hugo/bufferpool" "github.com/gohugoio/hugo/deps" ) // TestTemplateProvider is global deps.ResourceProvider. // NOTE: It's currently unused. var TestTemplateProvider deps.ResourceProvider type partialCacheKey struct { name string variant interface{} } // partialCache represents a cache of partials protected by a mutex. type partialCache struct { sync.RWMutex p map[partialCacheKey]interface{} } func (p *partialCache) clear() { p.Lock() defer p.Unlock() p.p = make(map[partialCacheKey]interface{}) } // New returns a new instance of the templates-namespaced template functions. func New(deps *deps.Deps) *Namespace { cache := &partialCache{p: make(map[partialCacheKey]interface{})} deps.BuildStartListeners.Add( func() { cache.clear() }) return &Namespace{ deps: deps, cachedPartials: cache, } } // Namespace provides template functions for the "templates" namespace. type Namespace struct { deps *deps.Deps cachedPartials *partialCache } // contextWrapper makes room for a return value in a partial invocation. type contextWrapper struct { Arg interface{} Result interface{} } // Set sets the return value and returns an empty string. func (c *contextWrapper) Set(in interface{}) string { c.Result = in return "" } // Include executes the named partial. // If the partial contains a return statement, that value will be returned. // Else, the rendered output will be returned: // A string if the partial is a text/template, or template.HTML when html/template. func (ns *Namespace) Include(name string, contextList ...interface{}) (interface{}, error) { name = strings.TrimPrefix(name, "partials/") var context interface{} if len(contextList) > 0 { context = contextList[0] } n := "partials/" + name templ, found := ns.deps.Tmpl().Lookup(n) if !found { // For legacy reasons. templ, found = ns.deps.Tmpl().Lookup(n + ".html") } if !found { return "", fmt.Errorf("partial %q not found", name) } var info tpl.ParseInfo if ip, ok := templ.(tpl.Info); ok { info = ip.ParseInfo() } var w io.Writer if info.HasReturn { if !hreflect.IsTruthful(context) { // TODO(bep) we need to fix this, but it is non-trivial. return nil, errors.New("partial that returns a value needs a non-zero argument.") } // Wrap the context sent to the template to capture the return value. // Note that the template is rewritten to make sure that the dot (".") // and the $ variable points to Arg. context = &contextWrapper{ Arg: context, } // We don't care about any template output. w = ioutil.Discard } else { b := bp.GetBuffer() defer bp.PutBuffer(b) w = b } if err := ns.deps.Tmpl().Execute(templ, w, context); err != nil { return "", err } var result interface{} if ctx, ok := context.(*contextWrapper); ok { result = ctx.Result } else if _, ok := templ.(*texttemplate.Template); ok { result = w.(fmt.Stringer).String() } else { result = template.HTML(w.(fmt.Stringer).String()) } if ns.deps.Metrics != nil { ns.deps.Metrics.TrackValue(n, result) } return result, nil } // IncludeCached executes and caches partial templates. The cache is created with name+variants as the key. func (ns *Namespace) IncludeCached(name string, context interface{}, variants ...interface{}) (interface{}, error) { key, err := createKey(name, variants...) if err != nil { return nil, err } result, err := ns.getOrCreate(key, context) if err == errUnHashable { // Try one more key.variant = helpers.HashString(key.variant) result, err = ns.getOrCreate(key, context) } return result, err } func createKey(name string, variants ...interface{}) (partialCacheKey, error) { var variant interface{} if len(variants) > 1 { variant = helpers.HashString(variants...) } else if len(variants) == 1 { variant = variants[0] t := reflect.TypeOf(variant) switch t.Kind() { // This isn't an exhaustive list of unhashable types. // There may be structs with slices, // but that should be very rare. We do recover from that situation // below. case reflect.Slice, reflect.Array, reflect.Map: variant = helpers.HashString(variant) } } return partialCacheKey{name: name, variant: variant}, nil } var errUnHashable = errors.New("unhashable") func (ns *Namespace) getOrCreate(key partialCacheKey, context interface{}) (result interface{}, err error) { defer func() { if r := recover(); r != nil { err = r.(error) if strings.Contains(err.Error(), "unhashable type") { ns.cachedPartials.RUnlock() err = errUnHashable } } }() ns.cachedPartials.RLock() p, ok := ns.cachedPartials.p[key] ns.cachedPartials.RUnlock() if ok { return p, nil } p, err = ns.Include(key.name, context) if err != nil { return nil, err } ns.cachedPartials.Lock() defer ns.cachedPartials.Unlock() // Double-check. if p2, ok := ns.cachedPartials.p[key]; ok { return p2, nil } ns.cachedPartials.p[key] = p return p, nil }
// Copyright 2017 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 partials provides template functions for working with reusable // templates. package partials import ( "errors" "fmt" "html/template" "io" "io/ioutil" "reflect" "strings" "sync" "github.com/gohugoio/hugo/common/hreflect" texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/tpl" bp "github.com/gohugoio/hugo/bufferpool" "github.com/gohugoio/hugo/deps" ) // TestTemplateProvider is global deps.ResourceProvider. // NOTE: It's currently unused. var TestTemplateProvider deps.ResourceProvider type partialCacheKey struct { name string variant interface{} } // partialCache represents a cache of partials protected by a mutex. type partialCache struct { sync.RWMutex p map[partialCacheKey]interface{} } func (p *partialCache) clear() { p.Lock() defer p.Unlock() p.p = make(map[partialCacheKey]interface{}) } // New returns a new instance of the templates-namespaced template functions. func New(deps *deps.Deps) *Namespace { cache := &partialCache{p: make(map[partialCacheKey]interface{})} deps.BuildStartListeners.Add( func() { cache.clear() }) return &Namespace{ deps: deps, cachedPartials: cache, } } // Namespace provides template functions for the "templates" namespace. type Namespace struct { deps *deps.Deps cachedPartials *partialCache } // contextWrapper makes room for a return value in a partial invocation. type contextWrapper struct { Arg interface{} Result interface{} } // Set sets the return value and returns an empty string. func (c *contextWrapper) Set(in interface{}) string { c.Result = in return "" } // Include executes the named partial. // If the partial contains a return statement, that value will be returned. // Else, the rendered output will be returned: // A string if the partial is a text/template, or template.HTML when html/template. func (ns *Namespace) Include(name string, contextList ...interface{}) (interface{}, error) { name = strings.TrimPrefix(name, "partials/") var context interface{} if len(contextList) > 0 { context = contextList[0] } n := "partials/" + name templ, found := ns.deps.Tmpl().Lookup(n) if !found { // For legacy reasons. templ, found = ns.deps.Tmpl().Lookup(n + ".html") } if !found { return "", fmt.Errorf("partial %q not found", name) } var info tpl.ParseInfo if ip, ok := templ.(tpl.Info); ok { info = ip.ParseInfo() } var w io.Writer if info.HasReturn { if !hreflect.IsTruthful(context) { // TODO(bep) we need to fix this, but it is non-trivial. return nil, errors.New("partial that returns a value needs a non-zero argument.") } // Wrap the context sent to the template to capture the return value. // Note that the template is rewritten to make sure that the dot (".") // and the $ variable points to Arg. context = &contextWrapper{ Arg: context, } // We don't care about any template output. w = ioutil.Discard } else { b := bp.GetBuffer() defer bp.PutBuffer(b) w = b } if err := ns.deps.Tmpl().Execute(templ, w, context); err != nil { return "", err } var result interface{} if ctx, ok := context.(*contextWrapper); ok { result = ctx.Result } else if _, ok := templ.(*texttemplate.Template); ok { result = w.(fmt.Stringer).String() } else { result = template.HTML(w.(fmt.Stringer).String()) } if ns.deps.Metrics != nil { ns.deps.Metrics.TrackValue(n, result) } return result, nil } // IncludeCached executes and caches partial templates. The cache is created with name+variants as the key. func (ns *Namespace) IncludeCached(name string, context interface{}, variants ...interface{}) (interface{}, error) { key, err := createKey(name, variants...) if err != nil { return nil, err } result, err := ns.getOrCreate(key, context) if err == errUnHashable { // Try one more key.variant = helpers.HashString(key.variant) result, err = ns.getOrCreate(key, context) } return result, err } func createKey(name string, variants ...interface{}) (partialCacheKey, error) { var variant interface{} if len(variants) > 1 { variant = helpers.HashString(variants...) } else if len(variants) == 1 { variant = variants[0] t := reflect.TypeOf(variant) switch t.Kind() { // This isn't an exhaustive list of unhashable types. // There may be structs with slices, // but that should be very rare. We do recover from that situation // below. case reflect.Slice, reflect.Array, reflect.Map: variant = helpers.HashString(variant) } } return partialCacheKey{name: name, variant: variant}, nil } var errUnHashable = errors.New("unhashable") func (ns *Namespace) getOrCreate(key partialCacheKey, context interface{}) (result interface{}, err error) { defer func() { if r := recover(); r != nil { err = r.(error) if strings.Contains(err.Error(), "unhashable type") { ns.cachedPartials.RUnlock() err = errUnHashable } } }() ns.cachedPartials.RLock() p, ok := ns.cachedPartials.p[key] ns.cachedPartials.RUnlock() if ok { return p, nil } p, err = ns.Include(key.name, context) if err != nil { return nil, err } ns.cachedPartials.Lock() defer ns.cachedPartials.Unlock() // Double-check. if p2, ok := ns.cachedPartials.p[key]; ok { return p2, nil } ns.cachedPartials.p[key] = p return p, nil }