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

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

@@ -1,90 +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 encoding provides template functions for encoding content.
-package encoding
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"html/template"
-
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the encoding-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "encoding" namespace.
-type Namespace struct{}
-
-// Base64Decode returns the base64 decoding of the given content.
-func (ns *Namespace) Base64Decode(content interface{}) (string, error) {
-	conv, err := cast.ToStringE(content)
-	if err != nil {
-		return "", err
-	}
-
-	dec, err := base64.StdEncoding.DecodeString(conv)
-	return string(dec), err
-}
-
-// Base64Encode returns the base64 encoding of the given content.
-func (ns *Namespace) Base64Encode(content interface{}) (string, error) {
-	conv, err := cast.ToStringE(content)
-	if err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString([]byte(conv)), nil
-}
-
-// Jsonify encodes a given object to JSON.  To pretty print the JSON, pass a map
-// or dictionary of options as the first argument.  Supported options are
-// "prefix" and "indent".  Each JSON element in the output will begin on a new
-// line beginning with prefix followed by one or more copies of indent according
-// to the indentation nesting.
-func (ns *Namespace) Jsonify(args ...interface{}) (template.HTML, error) {
-	var (
-		b   []byte
-		err error
-	)
-
-	switch len(args) {
-	case 0:
-		return "", nil
-	case 1:
-		b, err = json.Marshal(args[0])
-	case 2:
-		var opts map[string]string
-
-		opts, err = maps.ToStringMapStringE(args[0])
-		if err != nil {
-			break
-		}
-
-		b, err = json.MarshalIndent(args[1], opts["prefix"], opts["indent"])
-	default:
-		err = errors.New("too many arguments to jsonify")
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	return template.HTML(b), nil
-}

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

@@ -1,59 +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 encoding
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "encoding"
-
-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.Base64Decode,
-			[]string{"base64Decode"},
-			[][2]string{
-				{`{{ "SGVsbG8gd29ybGQ=" | base64Decode }}`, `Hello world`},
-				{`{{ 42 | base64Encode | base64Decode }}`, `42`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Base64Encode,
-			[]string{"base64Encode"},
-			[][2]string{
-				{`{{ "Hello world" | base64Encode }}`, `SGVsbG8gd29ybGQ=`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Jsonify,
-			[]string{"jsonify"},
-			[][2]string{
-				{`{{ (slice "A" "B" "C") | jsonify }}`, `["A","B","C"]`},
-				{`{{ (slice "A" "B" "C") | jsonify (dict "indent" "  ") }}`, "[\n  \"A\",\n  \"B\",\n  \"C\"\n]"},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,66 +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 fmt provides template functions for formatting strings.
-package fmt
-
-import (
-	_fmt "fmt"
-
-	"hugo-renderer/deps"
-)
-
-// Bookshop: This file has been stripped due to irrelevancy with live editing.
-
-// New returns a new instance of the fmt-namespaced template functions.
-func New(d *deps.Deps) *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "fmt" namespace.
-type Namespace struct {
-}
-
-// Print returns string representation of the passed arguments.
-func (ns *Namespace) Print(a ...interface{}) string {
-	return _fmt.Sprint(a...)
-}
-
-// Printf returns a formatted string representation of the passed arguments.
-func (ns *Namespace) Printf(format string, a ...interface{}) string {
-	return _fmt.Sprintf(format, a...)
-}
-
-// Println returns string representation of the passed arguments ending with a newline.
-func (ns *Namespace) Println(a ...interface{}) string {
-	return _fmt.Sprintln(a...)
-}
-
-// Errorf formats according to a format specifier and logs an ERROR.
-// It returns an empty string.
-func (ns *Namespace) Errorf(format string, a ...interface{}) string {
-	return "" // TODO(bookshop): NYI
-}
-
-// Erroridf formats according to a format specifier and logs an ERROR and
-// an information text that the error with the given ID can be suppressed in config.
-// It returns an empty string.
-func (ns *Namespace) Erroridf(id, format string, a ...interface{}) string {
-	return "" // TODO(bookshop): NYI
-}
-
-// Warnf formats according to a format specifier and logs a WARNING.
-// It returns an empty string.
-func (ns *Namespace) Warnf(format string, a ...interface{}) string {
-	return "" // TODO(bookshop): NYI
-}

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

@@ -1,77 +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 fmt
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "fmt"
-
-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.Print,
-			[]string{"print"},
-			[][2]string{
-				{`{{ print "works!" }}`, `works!`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Println,
-			[]string{"println"},
-			[][2]string{
-				{`{{ println "works!" }}`, "works!\n"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Printf,
-			[]string{"printf"},
-			[][2]string{
-				{`{{ printf "%s!" "works" }}`, `works!`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Errorf,
-			[]string{"errorf"},
-			[][2]string{
-				{`{{ errorf "%s." "failed" }}`, ``},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Erroridf,
-			[]string{"erroridf"},
-			[][2]string{
-				{`{{ erroridf "my-err-id" "%s." "failed" }}`, ``},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Warnf,
-			[]string{"warnf"},
-			[][2]string{
-				{`{{ warnf "%s." "warning" }}`, ``},
-			},
-		)
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

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

@@ -1,79 +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 inflect provides template functions for the inflection of words.
-package inflect
-
-import (
-	"strconv"
-	"strings"
-
-	_inflect "github.com/gobuffalo/flect"
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the inflect-namespaced template functions.
-func New() *Namespace {
-	return &Namespace{}
-}
-
-// Namespace provides template functions for the "inflect" namespace.
-type Namespace struct{}
-
-// Humanize returns the humanized form of a single parameter.
-//
-// If the parameter is either an integer or a string containing an integer
-// value, the behavior is to add the appropriate ordinal.
-//
-//     Example:  "my-first-post" -> "My first post"
-//     Example:  "103" -> "103rd"
-//     Example:  52 -> "52nd"
-func (ns *Namespace) Humanize(in interface{}) (string, error) {
-	word, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	if word == "" {
-		return "", nil
-	}
-
-	_, ok := in.(int)           // original param was literal int value
-	_, err = strconv.Atoi(word) // original param was string containing an int value
-	if ok || err == nil {
-		return _inflect.Ordinalize(word), nil
-	}
-
-	str := _inflect.Humanize(word)
-	return _inflect.Humanize(strings.ToLower(str)), nil
-}
-
-// Pluralize returns the plural form of a single word.
-func (ns *Namespace) Pluralize(in interface{}) (string, error) {
-	word, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	return _inflect.Pluralize(word), nil
-}
-
-// Singularize returns the singular form of a single word.
-func (ns *Namespace) Singularize(in interface{}) (string, error) {
-	word, err := cast.ToStringE(in)
-	if err != nil {
-		return "", err
-	}
-
-	return _inflect.Singularize(word), nil
-}

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

@@ -1,60 +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 inflect
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "inflect"
-
-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.Humanize,
-			[]string{"humanize"},
-			[][2]string{
-				{`{{ humanize "my-first-post" }}`, `My first post`},
-				{`{{ humanize "myCamelPost" }}`, `My camel post`},
-				{`{{ humanize "52" }}`, `52nd`},
-				{`{{ humanize 103 }}`, `103rd`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Pluralize,
-			[]string{"pluralize"},
-			[][2]string{
-				{`{{ "cat" | pluralize }}`, `cats`},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Singularize,
-			[]string{"singularize"},
-			[][2]string{
-				{`{{ "cats" | singularize }}`, `cat`},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}

package/hugo-renderer/tpl/internal/bookshop_modified_templatefuncsRegistry.go

@@ -1,88 +0,0 @@
-package internal
-
-import (
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"strings"
-
-	"hugo-renderer/deps"
-)
-
-// TemplateFuncsNamespaceRegistry describes a registry of functions that provide
-// namespaces.
-var TemplateFuncsNamespaceRegistry []func(d *deps.Deps) *TemplateFuncsNamespace
-
-// AddTemplateFuncsNamespace adds a given function to a registry.
-func AddTemplateFuncsNamespace(ns func(d *deps.Deps) *TemplateFuncsNamespace) {
-	TemplateFuncsNamespaceRegistry = append(TemplateFuncsNamespaceRegistry, ns)
-}
-
-// TemplateFuncsNamespace represents a template function namespace.
-type TemplateFuncsNamespace struct {
-	// The namespace name, "strings", "lang", etc.
-	Name string
-
-	// This is the method receiver.
-	Context func(v ...interface{}) (interface{}, error)
-
-	// Additional info, aliases and examples, per method name.
-	MethodMappings map[string]TemplateFuncMethodMapping
-}
-
-// TemplateFuncsNamespaces is a slice of TemplateFuncsNamespace.
-type TemplateFuncsNamespaces []*TemplateFuncsNamespace
-
-// TemplateFuncMethodMapping represents a mapping of functions to methods for a
-// given namespace.
-type TemplateFuncMethodMapping struct {
-	Method interface{}
-
-	// Any template funcs aliases. This is mainly motivated by keeping
-	// backwards compatibility, but some new template funcs may also make
-	// sense to give short and snappy aliases.
-	// Note that these aliases are global and will be merged, so the last
-	// key will win.
-	Aliases []string
-
-	// A slice of input/expected examples.
-	// We keep it a the namespace level for now, but may find a way to keep track
-	// of the single template func, for documentation purposes.
-	// Some of these, hopefully just a few, may depend on some test data to run.
-	Examples [][2]string
-}
-
-func methodToName(m interface{}) string {
-	name := runtime.FuncForPC(reflect.ValueOf(m).Pointer()).Name()
-	name = filepath.Ext(name)
-	name = strings.TrimPrefix(name, ".")
-	name = strings.TrimSuffix(name, "-fm")
-	return name
-}
-
-// AddMethodMapping adds a method to a template function namespace.
-func (t *TemplateFuncsNamespace) AddMethodMapping(m interface{}, aliases []string, examples [][2]string) {
-	if t.MethodMappings == nil {
-		t.MethodMappings = make(map[string]TemplateFuncMethodMapping)
-	}
-
-	name := methodToName(m)
-
-	// sanity check
-	for _, e := range examples {
-		if e[0] == "" {
-			panic(t.Name + ": Empty example for " + name)
-		}
-	}
-	for _, a := range aliases {
-		if a == "" {
-			panic(t.Name + ": Empty alias for " + name)
-		}
-	}
-
-	t.MethodMappings[name] = TemplateFuncMethodMapping{
-		Method:   m,
-		Aliases:  aliases,
-		Examples: examples,
-	}
-}

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

@@ -1,134 +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
-
-import (
-	"hugo-renderer/deps"
-	"hugo-renderer/tpl/internal"
-)
-
-const name = "math"
-
-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.Add,
-			[]string{"add"},
-			[][2]string{
-				{"{{add 1 2}}", "3"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Ceil,
-			nil,
-			[][2]string{
-				{"{{math.Ceil 2.1}}", "3"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Div,
-			[]string{"div"},
-			[][2]string{
-				{"{{div 6 3}}", "2"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Floor,
-			nil,
-			[][2]string{
-				{"{{math.Floor 1.9}}", "1"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Log,
-			nil,
-			[][2]string{
-				{"{{math.Log 1}}", "0"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Max,
-			nil,
-			[][2]string{
-				{"{{math.Max 1 2 }}", "2"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Min,
-			nil,
-			[][2]string{
-				{"{{math.Min 1 2 }}", "1"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Mod,
-			[]string{"mod"},
-			[][2]string{
-				{"{{mod 15 3}}", "0"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.ModBool,
-			[]string{"modBool"},
-			[][2]string{
-				{"{{modBool 15 3}}", "true"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Mul,
-			[]string{"mul"},
-			[][2]string{
-				{"{{mul 2 3}}", "6"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Pow,
-			[]string{"pow"},
-			[][2]string{
-				{"{{math.Pow 2 3}}", "8"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Round,
-			nil,
-			[][2]string{
-				{"{{math.Round 1.5}}", "2"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Sqrt,
-			nil,
-			[][2]string{
-				{"{{math.Sqrt 81}}", "9"},
-			},
-		)
-
-		ns.AddMethodMapping(ctx.Sub,
-			[]string{"sub"},
-			[][2]string{
-				{"{{sub 3 2}}", "1"},
-			},
-		)
-
-		return ns
-	}
-
-	internal.AddTemplateFuncsNamespace(f)
-}