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

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

@@ -1,216 +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 (
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/mitchellh/hashstructure"
-	"github.com/pkg/errors"
-)
-
-var (
-	zero      reflect.Value
-	errorType = reflect.TypeOf((*error)(nil)).Elem()
-	timeType  = reflect.TypeOf((*time.Time)(nil)).Elem()
-)
-
-func numberToFloat(v reflect.Value) (float64, error) {
-	switch kind := v.Kind(); {
-	case isFloat(kind):
-		return v.Float(), nil
-	case isInt(kind):
-		return float64(v.Int()), nil
-	case isUint(kind):
-		return float64(v.Uint()), nil
-	case kind == reflect.Interface:
-		return numberToFloat(v.Elem())
-	default:
-		return 0, fmt.Errorf("invalid kind %s in numberToFloat", kind)
-	}
-}
-
-// normalizes different numeric types if isNumber
-// or get the hash values if not Comparable (such as map or struct)
-// to make them comparable
-func normalize(v reflect.Value) interface{} {
-	k := v.Kind()
-
-	switch {
-	case !v.Type().Comparable():
-		h, err := hashstructure.Hash(v.Interface(), nil)
-		if err != nil {
-			panic(err)
-		}
-		return h
-	case isNumber(k):
-		f, err := numberToFloat(v)
-		if err == nil {
-			return f
-		}
-	}
-	return v.Interface()
-}
-
-// collects identities from the slices in seqs into a set. Numeric values are normalized,
-// pointers unwrapped.
-func collectIdentities(seqs ...interface{}) (map[interface{}]bool, error) {
-	seen := make(map[interface{}]bool)
-	for _, seq := range seqs {
-		v := reflect.ValueOf(seq)
-		switch v.Kind() {
-		case reflect.Array, reflect.Slice:
-			for i := 0; i < v.Len(); i++ {
-				ev, _ := indirectInterface(v.Index(i))
-
-				if !ev.Type().Comparable() {
-					return nil, errors.New("elements must be comparable")
-				}
-
-				seen[normalize(ev)] = true
-			}
-		default:
-			return nil, fmt.Errorf("arguments must be slices or arrays")
-		}
-	}
-
-	return seen, nil
-}
-
-// We have some different numeric and string types that we try to behave like
-// they were the same.
-func convertValue(v reflect.Value, to reflect.Type) (reflect.Value, error) {
-	if v.Type().AssignableTo(to) {
-		return v, nil
-	}
-	switch kind := to.Kind(); {
-	case kind == reflect.String:
-		s, err := toString(v)
-		return reflect.ValueOf(s), err
-	case isNumber(kind):
-		return convertNumber(v, kind)
-	default:
-		return reflect.Value{}, errors.Errorf("%s is not assignable to %s", v.Type(), to)
-	}
-}
-
-// There are potential overflows in this function, but the downconversion of
-// int64 etc. into int8 etc. is coming from the synthetic unit tests for Union etc.
-// TODO(bep) We should consider normalizing the slices to int64 etc.
-func convertNumber(v reflect.Value, to reflect.Kind) (reflect.Value, error) {
-	var n reflect.Value
-	if isFloat(to) {
-		f, err := toFloat(v)
-		if err != nil {
-			return n, err
-		}
-		switch to {
-		case reflect.Float32:
-			n = reflect.ValueOf(float32(f))
-		default:
-			n = reflect.ValueOf(float64(f))
-		}
-	} else if isInt(to) {
-		i, err := toInt(v)
-		if err != nil {
-			return n, err
-		}
-		switch to {
-		case reflect.Int:
-			n = reflect.ValueOf(int(i))
-		case reflect.Int8:
-			n = reflect.ValueOf(int8(i))
-		case reflect.Int16:
-			n = reflect.ValueOf(int16(i))
-		case reflect.Int32:
-			n = reflect.ValueOf(int32(i))
-		case reflect.Int64:
-			n = reflect.ValueOf(int64(i))
-		}
-	} else if isUint(to) {
-		i, err := toUint(v)
-		if err != nil {
-			return n, err
-		}
-		switch to {
-		case reflect.Uint:
-			n = reflect.ValueOf(uint(i))
-		case reflect.Uint8:
-			n = reflect.ValueOf(uint8(i))
-		case reflect.Uint16:
-			n = reflect.ValueOf(uint16(i))
-		case reflect.Uint32:
-			n = reflect.ValueOf(uint32(i))
-		case reflect.Uint64:
-			n = reflect.ValueOf(uint64(i))
-		}
-
-	}
-
-	if !n.IsValid() {
-		return n, errors.New("invalid values")
-	}
-
-	return n, nil
-}
-
-func newSliceElement(items interface{}) interface{} {
-	tp := reflect.TypeOf(items)
-	if tp == nil {
-		return nil
-	}
-	switch tp.Kind() {
-	case reflect.Array, reflect.Slice:
-		tp = tp.Elem()
-		if tp.Kind() == reflect.Ptr {
-			tp = tp.Elem()
-		}
-
-		return reflect.New(tp).Interface()
-	}
-	return nil
-}
-
-func isNumber(kind reflect.Kind) bool {
-	return isInt(kind) || isUint(kind) || isFloat(kind)
-}
-
-func isInt(kind reflect.Kind) bool {
-	switch kind {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return true
-	default:
-		return false
-	}
-}
-
-func isUint(kind reflect.Kind) bool {
-	switch kind {
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return true
-	default:
-		return false
-	}
-}
-
-func isFloat(kind reflect.Kind) bool {
-	switch kind {
-	case reflect.Float32, reflect.Float64:
-		return true
-	default:
-		return false
-	}
-}

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

@@ -1,183 +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"
-	"reflect"
-	"sort"
-	"strings"
-
-	"hugo-renderer/tpl/compare"
-
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/spf13/cast"
-)
-
-var sortComp = compare.New(true)
-
-// Sort returns a sorted sequence.
-func (ns *Namespace) Sort(seq interface{}, args ...interface{}) (interface{}, error) {
-	if seq == nil {
-		return nil, errors.New("sequence must be provided")
-	}
-
-	seqv, isNil := indirect(reflect.ValueOf(seq))
-	if isNil {
-		return nil, errors.New("can't iterate over a nil value")
-	}
-
-	var sliceType reflect.Type
-	switch seqv.Kind() {
-	case reflect.Array, reflect.Slice:
-		sliceType = seqv.Type()
-	case reflect.Map:
-		sliceType = reflect.SliceOf(seqv.Type().Elem())
-	default:
-		return nil, errors.New("can't sort " + reflect.ValueOf(seq).Type().String())
-	}
-
-	// Create a list of pairs that will be used to do the sort
-	p := pairList{SortAsc: true, SliceType: sliceType}
-	p.Pairs = make([]pair, seqv.Len())
-
-	var sortByField string
-	for i, l := range args {
-		dStr, err := cast.ToStringE(l)
-		switch {
-		case i == 0 && err != nil:
-			sortByField = ""
-		case i == 0 && err == nil:
-			sortByField = dStr
-		case i == 1 && err == nil && dStr == "desc":
-			p.SortAsc = false
-		case i == 1:
-			p.SortAsc = true
-		}
-	}
-	path := strings.Split(strings.Trim(sortByField, "."), ".")
-
-	switch seqv.Kind() {
-	case reflect.Array, reflect.Slice:
-		for i := 0; i < seqv.Len(); i++ {
-			p.Pairs[i].Value = seqv.Index(i)
-			if sortByField == "" || sortByField == "value" {
-				p.Pairs[i].Key = p.Pairs[i].Value
-			} else {
-				v := p.Pairs[i].Value
-				var err error
-				for i, elemName := range path {
-					v, err = evaluateSubElem(v, elemName)
-					if err != nil {
-						return nil, err
-					}
-					if !v.IsValid() {
-						continue
-					}
-					// Special handling of lower cased maps.
-					if params, ok := v.Interface().(maps.Params); ok {
-						v = reflect.ValueOf(params.Get(path[i+1:]...))
-						break
-					}
-				}
-				p.Pairs[i].Key = v
-			}
-		}
-
-	case reflect.Map:
-		keys := seqv.MapKeys()
-		for i := 0; i < seqv.Len(); i++ {
-			p.Pairs[i].Value = seqv.MapIndex(keys[i])
-
-			if sortByField == "" {
-				p.Pairs[i].Key = keys[i]
-			} else if sortByField == "value" {
-				p.Pairs[i].Key = p.Pairs[i].Value
-			} else {
-				v := p.Pairs[i].Value
-				var err error
-				for i, elemName := range path {
-					v, err = evaluateSubElem(v, elemName)
-					if err != nil {
-						return nil, err
-					}
-					if !v.IsValid() {
-						continue
-					}
-					// Special handling of lower cased maps.
-					if params, ok := v.Interface().(maps.Params); ok {
-						v = reflect.ValueOf(params.Get(path[i+1:]...))
-						break
-					}
-				}
-				p.Pairs[i].Key = v
-			}
-		}
-	}
-	return p.sort(), nil
-}
-
-// Credit for pair sorting method goes to Andrew Gerrand
-// https://groups.google.com/forum/#!topic/golang-nuts/FT7cjmcL7gw
-// A data structure to hold a key/value pair.
-type pair struct {
-	Key   reflect.Value
-	Value reflect.Value
-}
-
-// A slice of pairs that implements sort.Interface to sort by Value.
-type pairList struct {
-	Pairs     []pair
-	SortAsc   bool
-	SliceType reflect.Type
-}
-
-func (p pairList) Swap(i, j int) { p.Pairs[i], p.Pairs[j] = p.Pairs[j], p.Pairs[i] }
-func (p pairList) Len() int      { return len(p.Pairs) }
-func (p pairList) Less(i, j int) bool {
-	iv := p.Pairs[i].Key
-	jv := p.Pairs[j].Key
-
-	if iv.IsValid() {
-		if jv.IsValid() {
-			// can only call Interface() on valid reflect Values
-			return sortComp.Lt(iv.Interface(), jv.Interface())
-		}
-
-		// if j is invalid, test i against i's zero value
-		return sortComp.Lt(iv.Interface(), reflect.Zero(iv.Type()))
-	}
-
-	if jv.IsValid() {
-		// if i is invalid, test j against j's zero value
-		return sortComp.Lt(reflect.Zero(jv.Type()), jv.Interface())
-	}
-
-	return false
-}
-
-// sorts a pairList and returns a slice of sorted values
-func (p pairList) sort() interface{} {
-	if p.SortAsc {
-		sort.Sort(p)
-	} else {
-		sort.Sort(sort.Reverse(p))
-	}
-	sorted := reflect.MakeSlice(p.SliceType, len(p.Pairs), len(p.Pairs))
-	for i, v := range p.Pairs {
-		sorted.Index(i).Set(v.Value)
-	}
-
-	return sorted.Interface()
-}

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

@@ -1,68 +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 (
-	"fmt"
-	"reflect"
-
-	"github.com/pkg/errors"
-)
-
-// SymDiff returns the symmetric difference of s1 and s2.
-// Arguments must be either a slice or an array of comparable types.
-func (ns *Namespace) SymDiff(s2, s1 interface{}) (interface{}, error) {
-	ids1, err := collectIdentities(s1)
-	if err != nil {
-		return nil, err
-	}
-	ids2, err := collectIdentities(s2)
-	if err != nil {
-		return nil, err
-	}
-
-	var slice reflect.Value
-	var sliceElemType reflect.Type
-
-	for i, s := range []interface{}{s1, s2} {
-		v := reflect.ValueOf(s)
-
-		switch v.Kind() {
-		case reflect.Array, reflect.Slice:
-			if i == 0 {
-				sliceType := v.Type()
-				sliceElemType = sliceType.Elem()
-				slice = reflect.MakeSlice(sliceType, 0, 0)
-			}
-
-			for i := 0; i < v.Len(); i++ {
-				ev, _ := indirectInterface(v.Index(i))
-				key := normalize(ev)
-
-				// Append if the key is not in their intersection.
-				if ids1[key] != ids2[key] {
-					v, err := convertValue(ev, sliceElemType)
-					if err != nil {
-						return nil, errors.WithMessage(err, "symdiff: failed to convert value")
-					}
-					slice = reflect.Append(slice, v)
-				}
-			}
-		default:
-			return nil, fmt.Errorf("arguments to symdiff must be slices or arrays")
-		}
-	}
-
-	return slice.Interface(), nil
-}