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

package/hugo-renderer/tpl/compare/compare.go

@@ -1,324 +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 compare provides template functions for comparing values.
-package compare
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"time"
-
-	"github.com/gohugoio/hugo/compare"
-
-	"github.com/gohugoio/hugo/common/types"
-)
-
-// New returns a new instance of the compare-namespaced template functions.
-func New(caseInsensitive bool) *Namespace {
-	return &Namespace{caseInsensitive: caseInsensitive}
-}
-
-// Namespace provides template functions for the "compare" namespace.
-type Namespace struct {
-	// Enable to do case insensitive string compares.
-	caseInsensitive bool
-}
-
-// Default checks whether a given value is set and returns a default value if it
-// is not.  "Set" in this context means non-zero for numeric types and times;
-// non-zero length for strings, arrays, slices, and maps;
-// any boolean or struct value; or non-nil for any other types.
-func (*Namespace) Default(dflt interface{}, given ...interface{}) (interface{}, error) {
-	// given is variadic because the following construct will not pass a piped
-	// argument when the key is missing:  {{ index . "key" | default "foo" }}
-	// The Go template will complain that we got 1 argument when we expected 2.
-
-	if len(given) == 0 {
-		return dflt, nil
-	}
-	if len(given) != 1 {
-		return nil, fmt.Errorf("wrong number of args for default: want 2 got %d", len(given)+1)
-	}
-
-	g := reflect.ValueOf(given[0])
-	if !g.IsValid() {
-		return dflt, nil
-	}
-
-	set := false
-
-	switch g.Kind() {
-	case reflect.Bool:
-		set = true
-	case reflect.String, reflect.Array, reflect.Slice, reflect.Map:
-		set = g.Len() != 0
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		set = g.Int() != 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		set = g.Uint() != 0
-	case reflect.Float32, reflect.Float64:
-		set = g.Float() != 0
-	case reflect.Complex64, reflect.Complex128:
-		set = g.Complex() != 0
-	case reflect.Struct:
-		switch actual := given[0].(type) {
-		case time.Time:
-			set = !actual.IsZero()
-		default:
-			set = true
-		}
-	default:
-		set = !g.IsNil()
-	}
-
-	if set {
-		return given[0], nil
-	}
-
-	return dflt, nil
-}
-
-// Eq returns the boolean truth of arg1 == arg2 || arg1 == arg3 || arg1 == arg4.
-func (n *Namespace) Eq(first interface{}, others ...interface{}) bool {
-	if n.caseInsensitive {
-		panic("caseInsensitive not implemented for Eq")
-	}
-	if len(others) == 0 {
-		panic("missing arguments for comparison")
-	}
-
-	normalize := func(v interface{}) interface{} {
-		if types.IsNil(v) {
-			return nil
-		}
-		vv := reflect.ValueOf(v)
-		switch vv.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return vv.Int()
-		case reflect.Float32, reflect.Float64:
-			return vv.Float()
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return vv.Uint()
-		case reflect.String:
-			return vv.String()
-		default:
-			return v
-		}
-	}
-
-	normFirst := normalize(first)
-	for _, other := range others {
-		if e, ok := first.(compare.Eqer); ok {
-			if e.Eq(other) {
-				return true
-			}
-			continue
-		}
-
-		if e, ok := other.(compare.Eqer); ok {
-			if e.Eq(first) {
-				return true
-			}
-			continue
-		}
-
-		other = normalize(other)
-		if reflect.DeepEqual(normFirst, other) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Ne returns the boolean truth of arg1 != arg2 && arg1 != arg3 && arg1 != arg4.
-func (n *Namespace) Ne(first interface{}, others ...interface{}) bool {
-	for _, other := range others {
-		if n.Eq(first, other) {
-			return false
-		}
-	}
-	return true
-}
-
-// Ge returns the boolean truth of arg1 >= arg2 && arg1 >= arg3 && arg1 >= arg4.
-func (n *Namespace) Ge(first interface{}, others ...interface{}) bool {
-	for _, other := range others {
-		left, right := n.compareGet(first, other)
-		if !(left >= right) {
-			return false
-		}
-	}
-	return true
-}
-
-// Gt returns the boolean truth of arg1 > arg2 && arg1 > arg3 && arg1 > arg4.
-func (n *Namespace) Gt(first interface{}, others ...interface{}) bool {
-	for _, other := range others {
-		left, right := n.compareGet(first, other)
-		if !(left > right) {
-			return false
-		}
-	}
-	return true
-}
-
-// Le returns the boolean truth of arg1 <= arg2 && arg1 <= arg3 && arg1 <= arg4.
-func (n *Namespace) Le(first interface{}, others ...interface{}) bool {
-	for _, other := range others {
-		left, right := n.compareGet(first, other)
-		if !(left <= right) {
-			return false
-		}
-	}
-	return true
-}
-
-// Lt returns the boolean truth of arg1 < arg2 && arg1 < arg3 && arg1 < arg4.
-func (n *Namespace) Lt(first interface{}, others ...interface{}) bool {
-	for _, other := range others {
-		left, right := n.compareGet(first, other)
-		if !(left < right) {
-			return false
-		}
-	}
-	return true
-}
-
-// Conditional can be used as a ternary operator.
-// It returns a if condition, else b.
-func (n *Namespace) Conditional(condition bool, a, b interface{}) interface{} {
-	if condition {
-		return a
-	}
-	return b
-}
-
-func (ns *Namespace) compareGet(a interface{}, b interface{}) (float64, float64) {
-	if ac, ok := a.(compare.Comparer); ok {
-		c := ac.Compare(b)
-		if c < 0 {
-			return 1, 0
-		} else if c == 0 {
-			return 0, 0
-		} else {
-			return 0, 1
-		}
-	}
-
-	if bc, ok := b.(compare.Comparer); ok {
-		c := bc.Compare(a)
-		if c < 0 {
-			return 0, 1
-		} else if c == 0 {
-			return 0, 0
-		} else {
-			return 1, 0
-		}
-	}
-
-	var left, right float64
-	var leftStr, rightStr *string
-	av := reflect.ValueOf(a)
-
-	switch av.Kind() {
-	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
-		left = float64(av.Len())
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		left = float64(av.Int())
-	case reflect.Float32, reflect.Float64:
-		left = av.Float()
-	case reflect.String:
-		var err error
-		left, err = strconv.ParseFloat(av.String(), 64)
-		if err != nil {
-			str := av.String()
-			leftStr = &str
-		}
-	case reflect.Struct:
-		switch av.Type() {
-		case timeType:
-			left = float64(toTimeUnix(av))
-		}
-	case reflect.Bool:
-		left = 0
-		if av.Bool() {
-			left = 1
-		}
-	}
-
-	bv := reflect.ValueOf(b)
-
-	switch bv.Kind() {
-	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
-		right = float64(bv.Len())
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		right = float64(bv.Int())
-	case reflect.Float32, reflect.Float64:
-		right = bv.Float()
-	case reflect.String:
-		var err error
-		right, err = strconv.ParseFloat(bv.String(), 64)
-		if err != nil {
-			str := bv.String()
-			rightStr = &str
-		}
-	case reflect.Struct:
-		switch bv.Type() {
-		case timeType:
-			right = float64(toTimeUnix(bv))
-		}
-	case reflect.Bool:
-		right = 0
-		if bv.Bool() {
-			right = 1
-		}
-	}
-
-	if ns.caseInsensitive && leftStr != nil && rightStr != nil {
-		c := compare.Strings(*leftStr, *rightStr)
-		if c < 0 {
-			return 0, 1
-		} else if c > 0 {
-			return 1, 0
-		} else {
-			return 0, 0
-		}
-	}
-
-	switch {
-	case leftStr == nil || rightStr == nil:
-	case *leftStr < *rightStr:
-		return 0, 1
-	case *leftStr > *rightStr:
-		return 1, 0
-	default:
-		return 0, 0
-	}
-
-	return left, right
-}
-
-var timeType = reflect.TypeOf((*time.Time)(nil)).Elem()
-
-func toTimeUnix(v reflect.Value) int64 {
-	if v.Kind() == reflect.Interface {
-		return toTimeUnix(v.Elem())
-	}
-	if v.Type() != timeType {
-		panic("coding error: argument must be time.Time type reflect Value")
-	}
-	return v.MethodByName("Unix").Call([]reflect.Value{})[0].Int()
-}

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

@@ -1,85 +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 compare
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "compare"
-
-func init() {
-	f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
-		ctx := New(false)
-
-		ns := &internal.TemplateFuncsNamespace{
-			Name:    name,
-			Context: func(args ...interface{}) (interface{}, error) { return ctx, nil },
-		}
-
-		ns.AddMethodMapping(ctx.Default,
-			[]string{"default"},
-			[][2]string{
-				{`{{ "Hugo Rocks!" | default "Hugo Rules!" }}`, `Hugo Rocks!`},
-				{`{{ "" | default "Hugo Rules!" }}`, `Hugo Rules!`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Eq,
-			[]string{"eq"},
-			[][2]string{
-				{`{{ if eq .Section "blog" }}current{{ end }}`, `current`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Ge,
-			[]string{"ge"},
-			[][2]string{
-				{`{{ if ge .Hugo.Version "0.36" }}Reasonable new Hugo version!{{ end }}`, `Reasonable new Hugo version!`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Gt,
-			[]string{"gt"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Le,
-			[]string{"le"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Lt,
-			[]string{"lt"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Ne,
-			[]string{"ne"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.Conditional,
-			[]string{"cond"},
-			[][2]string{
-				{`{{ cond (eq (add 2 2) 4) "2+2 is 4" "what?" | safeHTML }}`, `2+2 is 4`},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

package/hugo-renderer/tpl/crypto/crypto.go

@@ -1,109 +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 crypto provides template functions for cryptographic operations.
-package crypto
-
-import (
-	"crypto/hmac"
-	"crypto/md5"
-	"crypto/sha1"
-	"crypto/sha256"
-	"crypto/sha512"
-	"encoding/hex"
-	"fmt"
-	"hash"
-
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the crypto-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "crypto" namespace.
-type Namespace struct{}
-
-// MD5 hashes the given input and returns its MD5 checksum.
-func (ns *Namespace) MD5(in interface{}) (string, error) {
-	conv, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	hash := md5.Sum([]byte(conv))
-	return hex.EncodeToString(hash[:]), nil
-}
-
-// SHA1 hashes the given input and returns its SHA1 checksum.
-func (ns *Namespace) SHA1(in interface{}) (string, error) {
-	conv, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	hash := sha1.Sum([]byte(conv))
-	return hex.EncodeToString(hash[:]), nil
-}
-
-// SHA256 hashes the given input and returns its SHA256 checksum.
-func (ns *Namespace) SHA256(in interface{}) (string, error) {
-	conv, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	hash := sha256.Sum256([]byte(conv))
-	return hex.EncodeToString(hash[:]), nil
-}
-
-// HMAC returns a cryptographic hash that uses a key to sign a message.
-func (ns *Namespace) HMAC(h interface{}, k interface{}, m interface{}) (string, error) {
-	ha, err := cast.ToStringE(h)
-	if err != nil {
-		return "", err
-	}
-
-	var hash func() hash.Hash
-	switch ha {
-	case "md5":
-		hash = md5.New
-	case "sha1":
-		hash = sha1.New
-	case "sha256":
-		hash = sha256.New
-	case "sha512":
-		hash = sha512.New
-	default:
-		return "", fmt.Errorf("hmac: %s is not a supported hash function", ha)
-	}
-
-	msg, err := cast.ToStringE(m)
-	if err != nil {
-		return "", err
-	}
-
-	key, err := cast.ToStringE(k)
-	if err != nil {
-		return "", err
-	}
-
-	mac := hmac.New(hash, []byte(key))
-	_, err = mac.Write([]byte(msg))
-	if err != nil {
-		return "", err
-	}
-
-	return hex.EncodeToString(mac.Sum(nil)[:]), nil
-}

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

@@ -1,65 +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 crypto
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "crypto"
-
-func init() {
-	f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
-		ctx := New()
-
-		ns := &internal.TemplateFuncsNamespace{
-			Name:    name,
-			Context: func(args ...interface{}) (interface{}, error) { return ctx, nil },
-		}
-
-		ns.AddMethodMapping(ctx.MD5,
-			[]string{"md5"},
-			[][2]string{
-				{`{{ md5 "Hello world, gophers!" }}`, `b3029f756f98f79e7f1b7f1d1f0dd53b`},
-				{`{{ crypto.MD5 "Hello world, gophers!" }}`, `b3029f756f98f79e7f1b7f1d1f0dd53b`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.SHA1,
-			[]string{"sha1"},
-			[][2]string{
-				{`{{ sha1 "Hello world, gophers!" }}`, `c8b5b0e33d408246e30f53e32b8f7627a7a649d4`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.SHA256,
-			[]string{"sha256"},
-			[][2]string{
-				{`{{ sha256 "Hello world, gophers!" }}`, `6ec43b78da9669f50e4e422575c54bf87536954ccd58280219c393f2ce352b46`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.HMAC,
-			[]string{"hmac"},
-			[][2]string{
-				{`{{ hmac "sha256" "Secret key" "Hello world, gophers!" }}`, `b6d11b6c53830b9d87036272ca9fe9d19306b8f9d8aa07b15da27d89e6e34f40`},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

package/hugo-renderer/tpl/debug/debug.go

@@ -1,40 +0,0 @@
-// Copyright 2020 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 debug provides template functions to help debugging templates.
-package debug
-
-import (
-	"github.com/sanity-io/litter"
-
-	"hugo-renderer/deps"
-)
-
-// New returns a new instance of the debug-namespaced template functions.
-func New(d *deps.Deps) *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "debug" namespace.
-type Namespace struct {
-}
-
-// Dump returns a object dump of val as a string.
-// Note that not every value passed to Dump will print so nicely, but
-// we'll improve on that. We recommend using the "go" Chroma lexer to format the output
-// nicely.
-// Also note that the output from Dump may change from Hugo version to the next,
-// so don't depend on a specific output.
-func (ns *Namespace) Dump(val interface{}) string {
-	return litter.Sdump(val)
-}

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

@@ -1,45 +0,0 @@
-// Copyright 2020 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 debug
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "debug"
-
-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.Dump,
-			nil,
-			[][2]string{
-				{`{{- $m := newScratch -}}
-{{- $m.Set "Hugo" "Rocks!" -}}
-{{- $m.Values | debug.Dump | safeHTML -}}`, "map[string]interface {}{\n  \"Hugo\": \"Rocks!\",\n}"},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}