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

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

@@ -1,164 +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 math provides template functions for mathematical operations.
-package math
-
-import (
-	"errors"
-	"math"
-
-	_math "github.com/gohugoio/hugo/common/math"
-
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the math-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "math" namespace.
-type Namespace struct{}
-
-// Add adds two numbers.
-func (ns *Namespace) Add(a, b interface{}) (interface{}, error) {
-	return _math.DoArithmetic(a, b, '+')
-}
-
-// Ceil returns the least integer value greater than or equal to x.
-func (ns *Namespace) Ceil(x interface{}) (float64, error) {
-	xf, err := cast.ToFloat64E(x)
-	if err != nil {
-		return 0, errors.New("Ceil operator can't be used with non-float value")
-	}
-
-	return math.Ceil(xf), nil
-}
-
-// Div divides two numbers.
-func (ns *Namespace) Div(a, b interface{}) (interface{}, error) {
-	return _math.DoArithmetic(a, b, '/')
-}
-
-// Floor returns the greatest integer value less than or equal to x.
-func (ns *Namespace) Floor(x interface{}) (float64, error) {
-	xf, err := cast.ToFloat64E(x)
-	if err != nil {
-		return 0, errors.New("Floor operator can't be used with non-float value")
-	}
-
-	return math.Floor(xf), nil
-}
-
-// Log returns the natural logarithm of a number.
-func (ns *Namespace) Log(a interface{}) (float64, error) {
-	af, err := cast.ToFloat64E(a)
-	if err != nil {
-		return 0, errors.New("Log operator can't be used with non integer or float value")
-	}
-
-	return math.Log(af), nil
-}
-
-// Max returns the greater of two numbers.
-func (ns *Namespace) Max(a, b interface{}) (float64, error) {
-	af, erra := cast.ToFloat64E(a)
-	bf, errb := cast.ToFloat64E(b)
-
-	if erra != nil || errb != nil {
-		return 0, errors.New("Max operator can't be used with non-float value")
-	}
-
-	return math.Max(af, bf), nil
-}
-
-// Min returns the smaller of two numbers.
-func (ns *Namespace) Min(a, b interface{}) (float64, error) {
-	af, erra := cast.ToFloat64E(a)
-	bf, errb := cast.ToFloat64E(b)
-
-	if erra != nil || errb != nil {
-		return 0, errors.New("Min operator can't be used with non-float value")
-	}
-
-	return math.Min(af, bf), nil
-}
-
-// Mod returns a % b.
-func (ns *Namespace) Mod(a, b interface{}) (int64, error) {
-	ai, erra := cast.ToInt64E(a)
-	bi, errb := cast.ToInt64E(b)
-
-	if erra != nil || errb != nil {
-		return 0, errors.New("modulo operator can't be used with non integer value")
-	}
-
-	if bi == 0 {
-		return 0, errors.New("the number can't be divided by zero at modulo operation")
-	}
-
-	return ai % bi, nil
-}
-
-// ModBool returns the boolean of a % b.  If a % b == 0, return true.
-func (ns *Namespace) ModBool(a, b interface{}) (bool, error) {
-	res, err := ns.Mod(a, b)
-	if err != nil {
-		return false, err
-	}
-
-	return res == int64(0), nil
-}
-
-// Mul multiplies two numbers.
-func (ns *Namespace) Mul(a, b interface{}) (interface{}, error) {
-	return _math.DoArithmetic(a, b, '*')
-}
-
-// Pow returns a raised to the power of b.
-func (ns *Namespace) Pow(a, b interface{}) (float64, error) {
-	af, erra := cast.ToFloat64E(a)
-	bf, errb := cast.ToFloat64E(b)
-
-	if erra != nil || errb != nil {
-		return 0, errors.New("Pow operator can't be used with non-float value")
-	}
-
-	return math.Pow(af, bf), nil
-}
-
-// Round returns the nearest integer, rounding half away from zero.
-func (ns *Namespace) Round(x interface{}) (float64, error) {
-	xf, err := cast.ToFloat64E(x)
-	if err != nil {
-		return 0, errors.New("Round operator can't be used with non-float value")
-	}
-
-	return _round(xf), nil
-}
-
-// Sqrt returns the square root of a number.
-func (ns *Namespace) Sqrt(a interface{}) (float64, error) {
-	af, err := cast.ToFloat64E(a)
-	if err != nil {
-		return 0, errors.New("Sqrt operator can't be used with non integer or float value")
-	}
-
-	return math.Sqrt(af), nil
-}
-
-// Sub subtracts two numbers.
-func (ns *Namespace) Sub(a, b interface{}) (interface{}, error) {
-	return _math.DoArithmetic(a, b, '-')
-}

package/hugo-renderer/tpl/math/round.go

@@ -1,61 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// According to https://github.com/golang/go/issues/20100, the Go stdlib will
-// include math.Round beginning with Go 1.10.
-//
-// The following implementation was taken from https://golang.org/cl/43652.
-
-package math
-
-import "math"
-
-const (
-	mask  = 0x7FF
-	shift = 64 - 11 - 1
-	bias  = 1023
-)
-
-// Round returns the nearest integer, rounding half away from zero.
-//
-// Special cases are:
-//	Round(±0) = ±0
-//	Round(±Inf) = ±Inf
-//	Round(NaN) = NaN
-func _round(x float64) float64 {
-	// Round is a faster implementation of:
-	//
-	// func Round(x float64) float64 {
-	//   t := Trunc(x)
-	//   if Abs(x-t) >= 0.5 {
-	//     return t + Copysign(1, x)
-	//   }
-	//   return t
-	// }
-	const (
-		signMask = 1 << 63
-		fracMask = 1<<shift - 1
-		half     = 1 << (shift - 1)
-		one      = bias << shift
-	)
-
-	bits := math.Float64bits(x)
-	e := uint(bits>>shift) & mask
-	if e < bias {
-		// Round abs(x) < 1 including denormals.
-		bits &= signMask // +-0
-		if e == bias-1 {
-			bits |= one // +-1
-		}
-	} else if e < bias+shift {
-		// Round any abs(x) >= 1 containing a fractional component [0,1).
-		//
-		// Numbers with larger exponents are returned unchanged since they
-		// must be either an integer, infinity, or NaN.
-		e -= bias
-		bits += half >> e
-		bits &^= fracMask >> e
-	}
-	return math.Float64frombits(bits)
-}

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

@@ -1,55 +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 partials
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "partials"
-
-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.Include,
-			[]string{"partial"},
-			[][2]string{
-				{`{{ partial "header.html" . }}`, `<title>Hugo Rocks!</title>`},
-			},
-		)
-
-		// TODO(bep) we need the return to be a valid identifier, but
-		// should consider another way of adding it.
-		ns.AddMethodMapping(func() string { return "" },
-			[]string{"return"},
-			[][2]string{},
-		)
-
-		ns.AddMethodMapping(ctx.IncludeCached,
-			[]string{"partialCached"},
-			[][2]string{},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,88 +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 partials provides template functions for working with reusable
-// templates.
-package partials
-
-import (
-	"bytes"
-	"fmt"
-	"html/template"
-	"strings"
-
-	library "hugo-renderer/tpl/bookshop_library"
-
-	"hugo-renderer/deps"
-)
-
-// Bookshop: This file has been stripped to only support Bookshop partials when live editing.
-
-// New returns a new instance of the templates-namespaced template functions.
-func New(deps *deps.Deps) *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "templates" namespace.
-type Namespace struct {
-}
-
-// 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(tagname string, contextList ...interface{}) (interface{}, error) {
-	// TODO(bookshop): Fallback to this
-	_ = strings.TrimPrefix(name, "partials/")
-
-	var context interface{}
-	if len(contextList) > 0 {
-		context = contextList[0]
-	}
-
-	var name string
-
-	switch tagname {
-	case "bookshop":
-		name, context = library.UnwrapBookshopComponent(context)
-	case "bookshop_partial":
-		name, context = library.UnwrapBookshopPartial(context)
-	default:
-		panic("Can't render standard includes yet")
-	}
-
-	templ, found := library.RetrieveBookshopPartial(name)
-
-	if !found {
-		// TODO(bookshop): Fallback to the name above
-		return "", fmt.Errorf("partial %q not found", name)
-	}
-
-	// TODO(bookshop): Large section of code was omitted
-	// meaning partials with return values won't work.
-
-	buf := bytes.NewBufferString("")
-	if err := templ.Execute(buf, context); err != nil {
-		return "", err
-	}
-
-	return template.HTML(buf.String()), 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) {
-	// Bookshop skips cached partials
-	// because partial rendering is implemented at a higher
-	// asbtraction level
-	return ns.Include(name, context)
-}

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

@@ -1,60 +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 path
-
-import (
-	"fmt"
-	"path/filepath"
-
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "path"
-
-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.Split,
-			nil,
-			[][2]string{
-				{`{{ "/my/path/filename.txt" | path.Split }}`, `/my/path/|filename.txt`},
-				{fmt.Sprintf(`{{ %q | path.Split }}`, filepath.FromSlash("/my/path/filename.txt")), `/my/path/|filename.txt`},
-			},
-		)
-
-		testDir := filepath.Join("my", "path")
-		testFile := filepath.Join(testDir, "filename.txt")
-
-		ns.AddMethodMapping(ctx.Join,
-			nil,
-			[][2]string{
-				{fmt.Sprintf(`{{ slice %q "filename.txt" | path.Join  }}`, testDir), `my/path/filename.txt`},
-				{`{{  path.Join "my" "path" "filename.txt" }}`, `my/path/filename.txt`},
-				{fmt.Sprintf(`{{ %q | path.Ext  }}`, testFile), `.txt`},
-				{fmt.Sprintf(`{{ %q | path.Base  }}`, testFile), `filename.txt`},
-				{fmt.Sprintf(`{{ %q | path.Dir  }}`, testFile), `my/path`},
-			},
-		)
-
-		return ns
-	}
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,159 +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 path provides template functions for manipulating paths.
-package path
-
-import (
-	"fmt"
-	_path "path"
-	"path/filepath"
-
-	"hugo-renderer/deps"
-
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the path-namespaced template functions.
-func New(deps *deps.Deps) *Namespace {
-	return &Namespace{
-		deps: deps,
-	}
-}
-
-// Namespace provides template functions for the "os" namespace.
-type Namespace struct {
-	deps *deps.Deps
-}
-
-// DirFile holds the result from path.Split.
-type DirFile struct {
-	Dir  string
-	File string
-}
-
-// Used in test.
-func (df DirFile) String() string {
-	return fmt.Sprintf("%s|%s", df.Dir, df.File)
-}
-
-// Ext returns the file name extension used by path.
-// The extension is the suffix beginning at the final dot
-// in the final slash-separated element of path;
-// it is empty if there is no dot.
-// The input path is passed into filepath.ToSlash converting any Windows slashes
-// to forward slashes.
-func (ns *Namespace) Ext(path interface{}) (string, error) {
-	spath, err := cast.ToStringE(path)
-	if err != nil {
-		return "", err
-	}
-	spath = filepath.ToSlash(spath)
-	return _path.Ext(spath), nil
-}
-
-// Dir returns all but the last element of path, typically the path's directory.
-// After dropping the final element using Split, the path is Cleaned and trailing
-// slashes are removed.
-// If the path is empty, Dir returns ".".
-// If the path consists entirely of slashes followed by non-slash bytes, Dir
-// returns a single slash. In any other case, the returned path does not end in a
-// slash.
-// The input path is passed into filepath.ToSlash converting any Windows slashes
-// to forward slashes.
-func (ns *Namespace) Dir(path interface{}) (string, error) {
-	spath, err := cast.ToStringE(path)
-	if err != nil {
-		return "", err
-	}
-	spath = filepath.ToSlash(spath)
-	return _path.Dir(spath), nil
-}
-
-// Base returns the last element of path.
-// Trailing slashes are removed before extracting the last element.
-// If the path is empty, Base returns ".".
-// If the path consists entirely of slashes, Base returns "/".
-// The input path is passed into filepath.ToSlash converting any Windows slashes
-// to forward slashes.
-func (ns *Namespace) Base(path interface{}) (string, error) {
-	spath, err := cast.ToStringE(path)
-	if err != nil {
-		return "", err
-	}
-	spath = filepath.ToSlash(spath)
-	return _path.Base(spath), nil
-}
-
-// Split splits path immediately following the final slash,
-// separating it into a directory and file name component.
-// If there is no slash in path, Split returns an empty dir and
-// file set to path.
-// The input path is passed into filepath.ToSlash converting any Windows slashes
-// to forward slashes.
-// The returned values have the property that path = dir+file.
-func (ns *Namespace) Split(path interface{}) (DirFile, error) {
-	spath, err := cast.ToStringE(path)
-	if err != nil {
-		return DirFile{}, err
-	}
-	spath = filepath.ToSlash(spath)
-	dir, file := _path.Split(spath)
-
-	return DirFile{Dir: dir, File: file}, nil
-}
-
-// Join joins any number of path elements into a single path, adding a
-// separating slash if necessary. All the input
-// path elements are passed into filepath.ToSlash converting any Windows slashes
-// to forward slashes.
-// The result is Cleaned; in particular,
-// all empty strings are ignored.
-func (ns *Namespace) Join(elements ...interface{}) (string, error) {
-	var pathElements []string
-	for _, elem := range elements {
-		switch v := elem.(type) {
-		case []string:
-			for _, e := range v {
-				pathElements = append(pathElements, filepath.ToSlash(e))
-			}
-		case []interface{}:
-			for _, e := range v {
-				elemStr, err := cast.ToStringE(e)
-				if err != nil {
-					return "", err
-				}
-				pathElements = append(pathElements, filepath.ToSlash(elemStr))
-			}
-		default:
-			elemStr, err := cast.ToStringE(elem)
-			if err != nil {
-				return "", err
-			}
-			pathElements = append(pathElements, filepath.ToSlash(elemStr))
-		}
-	}
-	return _path.Join(pathElements...), nil
-}
-
-// Clean replaces the separators used with standard slashes and then
-// extraneous slashes are removed.
-func (ns *Namespace) Clean(path interface{}) (string, error) {
-	spath, err := cast.ToStringE(path)
-
-	if err != nil {
-		return "", err
-	}
-	spath = filepath.ToSlash(spath)
-	return _path.Clean(spath), nil
-}

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

@@ -1,51 +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 reflect provides template functions for run-time object reflection.
-package reflect
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "reflect"
-
-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.IsMap,
-			nil,
-			[][2]string{
-				{`{{ if reflect.IsMap (dict "a" 1) }}Map{{ end }}`, `Map`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.IsSlice,
-			nil,
-			[][2]string{
-				{`{{ if reflect.IsSlice (slice 1 2 3) }}Slice{{ end }}`, `Slice`},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,36 +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 reflect
-
-import (
-	"reflect"
-)
-
-// New returns a new instance of the reflect-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "reflect" namespace.
-type Namespace struct{}
-
-// IsMap reports whether v is a map.
-func (ns *Namespace) IsMap(v interface{}) bool {
-	return reflect.ValueOf(v).Kind() == reflect.Map
-}
-
-// IsSlice reports whether v is a slice.
-func (ns *Namespace) IsSlice(v interface{}) bool {
-	return reflect.ValueOf(v).Kind() == reflect.Slice
-}