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

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

@@ -1,63 +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 cast provides template functions for data type conversions.
-package cast
-
-import (
-	"html/template"
-
-	_cast "github.com/spf13/cast"
-)
-
-// New returns a new instance of the cast-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "cast" namespace.
-type Namespace struct {
-}
-
-// ToInt converts the given value to an int.
-func (ns *Namespace) ToInt(v interface{}) (int, error) {
-	v = convertTemplateToString(v)
-	return _cast.ToIntE(v)
-}
-
-// ToString converts the given value to a string.
-func (ns *Namespace) ToString(v interface{}) (string, error) {
-	return _cast.ToStringE(v)
-}
-
-// ToFloat converts the given value to a float.
-func (ns *Namespace) ToFloat(v interface{}) (float64, error) {
-	v = convertTemplateToString(v)
-	return _cast.ToFloat64E(v)
-}
-
-func convertTemplateToString(v interface{}) interface{} {
-	switch vv := v.(type) {
-	case template.HTML:
-		v = string(vv)
-	case template.CSS:
-		v = string(vv)
-	case template.HTMLAttr:
-		v = string(vv)
-	case template.JS:
-		v = string(vv)
-	case template.JSStr:
-		v = string(vv)
-	}
-	return v
-}

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

@@ -1,57 +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 cast
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "cast"
-
-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.ToInt,
-			[]string{"int"},
-			[][2]string{
-				{`{{ "1234" | int | printf "%T" }}`, `int`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.ToString,
-			[]string{"string"},
-			[][2]string{
-				{`{{ 1234 | string | printf "%T" }}`, `string`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.ToFloat,
-			[]string{"float"},
-			[][2]string{
-				{`{{ "1234" | float | printf "%T" }}`, `float64`},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,37 +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"
-
-	"github.com/gohugoio/hugo/common/collections"
-)
-
-// Append appends the arguments up to the last one to the slice in the last argument.
-// This construct allows template constructs like this:
-//     {{ $pages = $pages | append $p2 $p1 }}
-// Note that with 2 arguments where both are slices of the same type,
-// the first slice will be appended to the second:
-//     {{ $pages = $pages | append .Site.RegularPages }}
-func (ns *Namespace) Append(args ...interface{}) (interface{}, error) {
-	if len(args) < 2 {
-		return nil, errors.New("need at least 2 arguments to append")
-	}
-
-	to := args[len(args)-1]
-	from := args[:len(args)-1]
-
-	return collections.Append(to, from...)
-}

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

@@ -1,131 +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"
-)
-
-// Apply takes a map, array, or slice and returns a new slice with the function fname applied over it.
-func (ns *Namespace) Apply(seq interface{}, fname string, args ...interface{}) (interface{}, error) {
-	if seq == nil {
-		return make([]interface{}, 0), nil
-	}
-
-	if fname == "apply" {
-		return nil, errors.New("can't apply myself (no turtles allowed)")
-	}
-
-	seqv := reflect.ValueOf(seq)
-	seqv, isNil := indirect(seqv)
-	if isNil {
-		return nil, errors.New("can't iterate over a nil value")
-	}
-
-	fnv, found := ns.lookupFunc(fname)
-	if !found {
-		return nil, errors.New("can't find function " + fname)
-	}
-
-	// fnv := reflect.ValueOf(fn)
-
-	switch seqv.Kind() {
-	case reflect.Array, reflect.Slice:
-		r := make([]interface{}, seqv.Len())
-		for i := 0; i < seqv.Len(); i++ {
-			vv := seqv.Index(i)
-
-			vvv, err := applyFnToThis(fnv, vv, args...)
-			if err != nil {
-				return nil, err
-			}
-
-			r[i] = vvv.Interface()
-		}
-
-		return r, nil
-	default:
-		return nil, fmt.Errorf("can't apply over %v", seq)
-	}
-}
-
-func applyFnToThis(fn, this reflect.Value, args ...interface{}) (reflect.Value, error) {
-	n := make([]reflect.Value, len(args))
-	for i, arg := range args {
-		if arg == "." {
-			n[i] = this
-		} else {
-			n[i] = reflect.ValueOf(arg)
-		}
-	}
-
-	num := fn.Type().NumIn()
-
-	if fn.Type().IsVariadic() {
-		num--
-	}
-
-	// TODO(bep) see #1098 - also see template_tests.go
-	/*if len(args) < num {
-		return reflect.ValueOf(nil), errors.New("Too few arguments")
-	} else if len(args) > num {
-		return reflect.ValueOf(nil), errors.New("Too many arguments")
-	}*/
-
-	for i := 0; i < num; i++ {
-		// AssignableTo reports whether xt is assignable to type targ.
-		if xt, targ := n[i].Type(), fn.Type().In(i); !xt.AssignableTo(targ) {
-			return reflect.ValueOf(nil), errors.New("called apply using " + xt.String() + " as type " + targ.String())
-		}
-	}
-
-	res := fn.Call(n)
-
-	if len(res) == 1 || res[1].IsNil() {
-		return res[0], nil
-	}
-	return reflect.ValueOf(nil), res[1].Interface().(error)
-}
-
-func (ns *Namespace) lookupFunc(fname string) (reflect.Value, bool) {
-	// TODO(bookshop): NYI
-	return reflect.Value{}, false
-}
-
-// indirect is borrowed from the Go stdlib: 'text/template/exec.go'
-func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
-	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
-		if v.IsNil() {
-			return v, true
-		}
-		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
-			break
-		}
-	}
-	return v, false
-}
-
-func indirectInterface(v reflect.Value) (rv reflect.Value, isNil bool) {
-	for ; v.Kind() == reflect.Interface; v = v.Elem() {
-		if v.IsNil() {
-			return v, true
-		}
-		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
-			break
-		}
-	}
-	return v, false
-}