@bookshop/hugo-engine 3.3.2 → 3.4.0-alpha.2

package/hugo-renderer/tpl/collections/complement.go

@@ -1,55 +0,0 @@
-// Copyright 2018 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 collections
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-// Complement gives the elements in the last element of seqs that are not in
-// any of the others.
-// All elements of seqs must be slices or arrays of comparable types.
-//
-// The reasoning behind this rather clumsy API is so we can do this in the templates:
-//    {{ $c := .Pages | complement $last4 }}
-func (ns *Namespace) Complement(seqs ...interface{}) (interface{}, error) {
-	if len(seqs) < 2 {
-		return nil, errors.New("complement needs at least two arguments")
-	}
-
-	universe := seqs[len(seqs)-1]
-	as := seqs[:len(seqs)-1]
-
-	aset, err := collectIdentities(as...)
-	if err != nil {
-		return nil, err
-	}
-
-	v := reflect.ValueOf(universe)
-	switch v.Kind() {
-	case reflect.Array, reflect.Slice:
-		sl := reflect.MakeSlice(v.Type(), 0, 0)
-		for i := 0; i < v.Len(); i++ {
-			ev, _ := indirectInterface(v.Index(i))
-			if _, found := aset[normalize(ev)]; !found {
-				sl = reflect.Append(sl, ev)
-			}
-		}
-		return sl.Interface(), nil
-	default:
-		return nil, fmt.Errorf("arguments to complement must be slices or arrays")
-	}
-}

package/hugo-renderer/tpl/collections/index.go

@@ -1,133 +0,0 @@
-// 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 collections
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-
-	"github.com/spf13/cast"
-
-	"github.com/gohugoio/hugo/common/maps"
-)
-
-// Index returns the result of indexing its first argument by the following
-// arguments. Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each
-// indexed item must be a map, slice, or array.
-//
-// Copied from Go stdlib src/text/template/funcs.go.
-//
-// We deviate from the stdlib due to https://github.com/golang/go/issues/14751.
-//
-// TODO(moorereason): merge upstream changes.
-func (ns *Namespace) Index(item interface{}, args ...interface{}) (interface{}, error) {
-	v := reflect.ValueOf(item)
-	if !v.IsValid() {
-		return nil, errors.New("index of untyped nil")
-	}
-
-	lowerm, ok := item.(maps.Params)
-	if ok {
-		return lowerm.Get(cast.ToStringSlice(args)...), nil
-	}
-
-	var indices []interface{}
-
-	if len(args) == 1 {
-		v := reflect.ValueOf(args[0])
-		if v.Kind() == reflect.Slice {
-			for i := 0; i < v.Len(); i++ {
-				indices = append(indices, v.Index(i).Interface())
-			}
-		}
-	}
-
-	if indices == nil {
-		indices = args
-	}
-
-	for _, i := range indices {
-		index := reflect.ValueOf(i)
-		var isNil bool
-		if v, isNil = indirect(v); isNil {
-			return nil, errors.New("index of nil pointer")
-		}
-		switch v.Kind() {
-		case reflect.Array, reflect.Slice, reflect.String:
-			var x int64
-			switch index.Kind() {
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				x = index.Int()
-			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-				x = int64(index.Uint())
-			case reflect.Invalid:
-				return nil, errors.New("cannot index slice/array with nil")
-			default:
-				return nil, fmt.Errorf("cannot index slice/array with type %s", index.Type())
-			}
-			if x < 0 || x >= int64(v.Len()) {
-				// We deviate from stdlib here.  Don't return an error if the
-				// index is out of range.
-				return nil, nil
-			}
-			v = v.Index(int(x))
-		case reflect.Map:
-			index, err := prepareArg(index, v.Type().Key())
-			if err != nil {
-				return nil, err
-			}
-
-			if x := v.MapIndex(index); x.IsValid() {
-				v = x
-			} else {
-				v = reflect.Zero(v.Type().Elem())
-			}
-		case reflect.Invalid:
-			// the loop holds invariant: v.IsValid()
-			panic("unreachable")
-		default:
-			return nil, fmt.Errorf("can't index item of type %s", v.Type())
-		}
-	}
-	return v.Interface(), nil
-}
-
-// prepareArg checks if value can be used as an argument of type argType, and
-// converts an invalid value to appropriate zero if possible.
-//
-// Copied from Go stdlib src/text/template/funcs.go.
-func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
-	if !value.IsValid() {
-		if !canBeNil(argType) {
-			return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
-		}
-		value = reflect.Zero(argType)
-	}
-	if !value.Type().AssignableTo(argType) {
-		return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
-	}
-	return value, nil
-}
-
-// canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero.
-//
-// Copied from Go stdlib src/text/template/exec.go.
-func canBeNil(typ reflect.Type) bool {
-	switch typ.Kind() {
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return true
-	}
-	return false
-}

package/hugo-renderer/tpl/collections/init.go

@@ -1,214 +0,0 @@
-// 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 collections
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "collections"
-
-func init() {
-	f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
-		ctx := New(d)
-
-		ns := &internal.TemplateFuncsNamespace{
-			Name:    name,
-			Context: func(args ...interface{}) (interface{}, error) { return ctx, nil },
-		}
-
-		ns.AddMethodMapping(ctx.After,
-			[]string{"after"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Apply,
-			[]string{"apply"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Complement,
-			[]string{"complement"},
-			[][2]string{
-				{`{{ slice "a" "b" "c" "d" "e" "f" | complement (slice "b" "c") (slice "d" "e")  }}`, `[a f]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.SymDiff,
-			[]string{"symdiff"},
-			[][2]string{
-				{`{{ slice 1 2 3 | symdiff (slice 3 4) }}`, `[1 2 4]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Delimit,
-			[]string{"delimit"},
-			[][2]string{
-				{`{{ delimit (slice "A" "B" "C") ", " " and " }}`, `A, B and C`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Dictionary,
-			[]string{"dict"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.EchoParam,
-			[]string{"echoParam"},
-			[][2]string{
-				{`{{ echoParam .Params "langCode" }}`, `en`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.First,
-			[]string{"first"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.KeyVals,
-			[]string{"keyVals"},
-			[][2]string{
-				{`{{ keyVals "key" "a" "b" }}`, `key: [a b]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.In,
-			[]string{"in"},
-			[][2]string{
-				{`{{ if in "this string contains a substring" "substring" }}Substring found!{{ end }}`, `Substring found!`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Index,
-			[]string{"index"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Intersect,
-			[]string{"intersect"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.IsSet,
-			[]string{"isSet", "isset"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Last,
-			[]string{"last"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Querify,
-			[]string{"querify"},
-			[][2]string{
-				{
-					`{{ (querify "foo" 1 "bar" 2 "baz" "with spaces" "qux" "this&that=those") | safeHTML }}`,
-					`bar=2&baz=with+spaces&foo=1&qux=this%26that%3Dthose`,
-				},
-				{
-					`<a href="https://www.google.com?{{ (querify "q" "test" "page" 3) | safeURL }}">Search</a>`,
-					`<a href="https://www.google.com?page=3&amp;q=test">Search</a>`,
-				},
-				{
-					`{{ slice "foo" 1 "bar" 2 | querify | safeHTML }}`,
-					`bar=2&foo=1`,
-				},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Shuffle,
-			[]string{"shuffle"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Slice,
-			[]string{"slice"},
-			[][2]string{
-				{`{{ slice "B" "C" "A" | sort }}`, `[A B C]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Sort,
-			[]string{"sort"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Union,
-			[]string{"union"},
-			[][2]string{
-				{`{{ union (slice 1 2 3) (slice 3 4 5) }}`, `[1 2 3 4 5]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Where,
-			[]string{"where"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Append,
-			[]string{"append"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Group,
-			[]string{"group"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Seq,
-			[]string{"seq"},
-			[][2]string{
-				{`{{ seq 3 }}`, `[1 2 3]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.NewScratch,
-			[]string{"newScratch"},
-			[][2]string{
-				{`{{ $scratch := newScratch }}{{ $scratch.Add "b" 2 }}{{ $scratch.Add "b" 2 }}{{ $scratch.Get "b" }}`, `4`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Uniq,
-			[]string{"uniq"},
-			[][2]string{
-				{`{{ slice 1 2 3 2 | uniq }}`, `[1 2 3]`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Merge,
-			[]string{"merge"},
-			[][2]string{
-				{
-					`{{ dict "title" "Hugo Rocks!" | collections.Merge (dict "title" "Default Title" "description" "Yes, Hugo Rocks!") | sort }}`,
-					`[Yes, Hugo Rocks! Hugo Rocks!]`,
-				},
-				{
-					`{{  merge (dict "title" "Default Title" "description" "Yes, Hugo Rocks!") (dict "title" "Hugo Rocks!") | sort }}`,
-					`[Yes, Hugo Rocks! Hugo Rocks!]`,
-				},
-				{
-					`{{  merge (dict "title" "Default Title" "description" "Yes, Hugo Rocks!") (dict "title" "Hugo Rocks!") (dict "extra" "For reals!") | sort }}`,
-					`[Yes, Hugo Rocks! For reals! Hugo Rocks!]`,
-				},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

package/hugo-renderer/tpl/collections/merge.go

@@ -1,126 +0,0 @@
-// Copyright 2019 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 collections
-
-import (
-	"reflect"
-	"strings"
-
-	"github.com/gohugoio/hugo/common/hreflect"
-	"github.com/gohugoio/hugo/common/maps"
-
-	"github.com/pkg/errors"
-)
-
-// Merge creates a copy of the final parameter and merges the preceding
-// parameters into it in reverse order.
-// Currently only maps are supported. Key handling is case insensitive.
-func (ns *Namespace) Merge(params ...interface{}) (interface{}, error) {
-	if len(params) < 2 {
-		return nil, errors.New("merge requires at least two parameters")
-	}
-
-	var err error
-	result := params[len(params)-1]
-
-	for i := len(params) - 2; i >= 0; i-- {
-		result, err = ns.merge(params[i], result)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return result, nil
-}
-
-// merge creates a copy of dst and merges src into it.
-func (ns *Namespace) merge(src, dst interface{}) (interface{}, error) {
-	vdst, vsrc := reflect.ValueOf(dst), reflect.ValueOf(src)
-
-	if vdst.Kind() != reflect.Map {
-		return nil, errors.Errorf("destination must be a map, got %T", dst)
-	}
-
-	if !hreflect.IsTruthfulValue(vsrc) {
-		return dst, nil
-	}
-
-	if vsrc.Kind() != reflect.Map {
-		return nil, errors.Errorf("source must be a map, got %T", src)
-	}
-
-	if vsrc.Type().Key() != vdst.Type().Key() {
-		return nil, errors.Errorf("incompatible map types, got %T to %T", src, dst)
-	}
-
-	return mergeMap(vdst, vsrc).Interface(), nil
-}
-
-func caseInsensitiveLookup(m, k reflect.Value) (reflect.Value, bool) {
-	if m.Type().Key().Kind() != reflect.String || k.Kind() != reflect.String {
-		// Fall back to direct lookup.
-		v := m.MapIndex(k)
-		return v, hreflect.IsTruthfulValue(v)
-	}
-
-	for _, key := range m.MapKeys() {
-		if strings.EqualFold(k.String(), key.String()) {
-			return m.MapIndex(key), true
-		}
-	}
-
-	return reflect.Value{}, false
-}
-
-func mergeMap(dst, src reflect.Value) reflect.Value {
-	out := reflect.MakeMap(dst.Type())
-
-	// If the destination is Params, we must lower case all keys.
-	_, lowerCase := dst.Interface().(maps.Params)
-
-	// Copy the destination map.
-	for _, key := range dst.MapKeys() {
-		v := dst.MapIndex(key)
-		out.SetMapIndex(key, v)
-	}
-
-	// Add all keys in src not already in destination.
-	// Maps of the same type will be merged.
-	for _, key := range src.MapKeys() {
-		sv := src.MapIndex(key)
-		dv, found := caseInsensitiveLookup(dst, key)
-
-		if found {
-			// If both are the same map key type, merge.
-			dve := dv.Elem()
-			if dve.Kind() == reflect.Map {
-				sve := sv.Elem()
-				if sve.Kind() != reflect.Map {
-					continue
-				}
-
-				if dve.Type().Key() == sve.Type().Key() {
-					out.SetMapIndex(key, mergeMap(dve, sve))
-				}
-			}
-		} else {
-			if lowerCase && key.Kind() == reflect.String {
-				key = reflect.ValueOf(strings.ToLower(key.String()))
-			}
-			out.SetMapIndex(key, sv)
-		}
-	}
-
-	return out
-}