@bookshop/hugo-engine 2.4.0-hugo.0

package/hugo-renderer/helpers/bookshop_modified_content.go

@@ -0,0 +1,64 @@
+// Copyright 2019 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 helpers implements general utility functions that work with
+// and on content.  The helper functions defined here lay down the
+// foundation of how Hugo works with files and filepaths, and perform
+// string operations on content.
+package helpers
+
+import (
+	"strings"
+	"unicode"
+
+	bp "github.com/gohugoio/hugo/bufferpool"
+)
+
+var stripHTMLReplacer = strings.NewReplacer("\n", " ", "</p>", "\n", "<br>", "\n", "<br />", "\n")
+
+// StripHTML accepts a string, strips out all HTML tags and returns it.
+func StripHTML(s string) string {
+	// Shortcut strings with no tags in them
+	if !strings.ContainsAny(s, "<>") {
+		return s
+	}
+	s = stripHTMLReplacer.Replace(s)
+
+	// Walk through the string removing all tags
+	b := bp.GetBuffer()
+	defer bp.PutBuffer(b)
+	var inTag, isSpace, wasSpace bool
+	for _, r := range s {
+		if !inTag {
+			isSpace = false
+		}
+
+		switch {
+		case r == '<':
+			inTag = true
+		case r == '>':
+			inTag = false
+		case unicode.IsSpace(r):
+			isSpace = true
+			fallthrough
+		default:
+			if !inTag && (!isSpace || (isSpace && !wasSpace)) {
+				b.WriteRune(r)
+			}
+		}
+
+		wasSpace = isSpace
+
+	}
+	return b.String()
+}

package/hugo-renderer/helpers/bookshop_modified_general.go

@@ -0,0 +1,33 @@
+// Copyright 2019 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 helpers
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// FirstUpper returns a string with the first character as upper case.
+func FirstUpper(s string) string {
+	if s == "" {
+		return ""
+	}
+	r, n := utf8.DecodeRuneInString(s)
+	return string(unicode.ToUpper(r)) + s[n:]
+}
+
+// IsWhitespace determines if the given rune is whitespace.
+func IsWhitespace(r rune) bool {
+	return r == ' ' || r == '\t' || r == '\n' || r == '\r'
+}

package/hugo-renderer/main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"syscall/js"
+
+	engine "hugo-renderer/tpl/bookshop_engine"
+	library "hugo-renderer/tpl/bookshop_library"
+)
+
+func main() {
+	c := make(chan struct{}, 0)
+	js.Global().Set("renderHugo", js.FuncOf(renderHugo))
+	js.Global().Set("loadHugoBookshopPartials", js.FuncOf(loadHugoBookshopPartials))
+	<-c
+}
+
+func renderHugo(this js.Value, args []js.Value) interface{} {
+	templateString := args[0].String()
+	propsString := args[1].String()
+
+	return engine.RenderHugo(templateString, propsString)
+}
+
+func loadHugoBookshopPartials(this js.Value, args []js.Value) interface{} {
+	bookshopPartials := args[0].String()
+
+	return library.LoadHugoBookshopPartials(bookshopPartials)
+}

package/hugo-renderer/tpl/bookshop_engine/bookshop_func_importer.go

@@ -0,0 +1,34 @@
+package engine
+
+import (
+	_ "hugo-renderer/tpl/cast"
+	_ "hugo-renderer/tpl/collections" // ———————————— 🥴 TODO: `apply` NYI, relies on tpl.TemplateHandler & co. Reimplement based on bookshop_render -> createFuncMap
+	_ "hugo-renderer/tpl/compare"
+	_ "hugo-renderer/tpl/crypto"
+
+	// _ "hugo-renderer/tpl/data" // ———————————————— ⏭️ NTBI: Networking / FS / Resources
+	_ "hugo-renderer/tpl/debug"
+	_ "hugo-renderer/tpl/encoding"
+	_ "hugo-renderer/tpl/fmt"
+
+	// _ "hugo-renderer/tpl/hugo" // ———————————————— ❗ TODO: Should this be stubbed out ??
+	// _ "hugo-renderer/tpl/images" // —————————————— ❗ TODO: Should this be mocked ??
+	_ "hugo-renderer/tpl/inflect"
+	// _ "hugo-renderer/tpl/js" // —————————————————— ⏭️ NTBI: Shouldn't be done inside a component
+	// _ "hugo-renderer/tpl/lang" // ———————————————— ❗ TODO: Not sure how this would interact in the Bookshop environment
+	_ "hugo-renderer/tpl/math"
+	// _ "hugo-renderer/tpl/openapi/openapi3" // ———— ❗ TODO: Maybe a rabbit hole
+	// _ "hugo-renderer/tpl/os" // —————————————————— ⏭️ NTBI: We don't have an OS
+	_ "hugo-renderer/tpl/partials" // ——————————————— ❗ TODO: Return partials / use bookshop module partials
+	_ "hugo-renderer/tpl/path"
+	_ "hugo-renderer/tpl/reflect"
+
+	// _ "hugo-renderer/tpl/resources" // ——————————— ⏭️ NTBI: Bookshop components won't support resources
+	_ "hugo-renderer/tpl/safe" // ——————————————————— 🥴 TODO: `SanitizeURL` NYI — helpers require is too large
+	// _ "hugo-renderer/tpl/site" // ———————————————— ❗ TODO: Should this be stubbed out ??
+	_ "hugo-renderer/tpl/strings" // ———————————————— 🥴 TODO: Only the "Go" title formatting is supported
+	// _ "hugo-renderer/tpl/templates" // ——————————— ❗ TODO: Maybe a rabbit hole
+	// _ "hugo-renderer/tpl/time" // ———————————————— ❗ TODO: This relies on lang stuff that is thus far excluded
+	// _ "hugo-renderer/tpl/transform" // ——————————— ❗ TODO: Definitely a rabbit hole
+	// _ "hugo-renderer/tpl/urls" // ———————————————— ❗ TODO: Relies on pathspec that relies on FS impls
+)

package/hugo-renderer/tpl/bookshop_engine/bookshop_render.go

@@ -0,0 +1,64 @@
+package engine
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"html/template"
+
+	"hugo-renderer/deps"
+	"hugo-renderer/tpl/internal"
+)
+
+// TODO(bookshop): DRY
+func createFuncMap(d *deps.Deps) map[string]interface{} {
+	funcMap := template.FuncMap{}
+
+	// Merge the namespace funcs
+	for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
+		ns := nsf(d)
+		if _, exists := funcMap[ns.Name]; exists {
+			panic(ns.Name + " is a duplicate template func")
+		}
+		funcMap[ns.Name] = ns.Context
+		for _, mm := range ns.MethodMappings {
+			for _, alias := range mm.Aliases {
+				if _, exists := funcMap[alias]; exists {
+					panic(alias + " is a duplicate template func")
+				}
+				funcMap[alias] = mm.Method
+			}
+		}
+	}
+
+	return funcMap
+}
+
+// RenderHugo takes a component from the browser,
+// as well as a JSON blob of its data,
+// and renders it.
+func RenderHugo(templateString string, props string) interface{} {
+	var parsedProps map[string]interface{}
+	err := json.Unmarshal([]byte(props), &parsedProps)
+	if err != nil {
+		buf := bytes.NewBufferString(fmt.Sprintf("bad json unmarshal: %s", err.Error()))
+		return buf.String()
+	}
+
+	d := deps.Deps{}
+	funcMap := createFuncMap(&d)
+
+	templ, err := template.New("").Funcs(funcMap).Parse(templateString)
+	if err != nil {
+		buf := bytes.NewBufferString(fmt.Sprintf("bad template parse: %s", err.Error()))
+		return buf.String()
+	}
+
+	buf := bytes.NewBufferString("")
+	err = templ.Execute(buf, parsedProps)
+	if err != nil {
+		buf := bytes.NewBufferString(fmt.Sprintf("bad template render: %s", err.Error()))
+		return buf.String()
+	}
+	return buf.String()
+}

package/hugo-renderer/tpl/bookshop_library/bookshop_components.go

@@ -0,0 +1,107 @@
+package bookshop_library
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"html/template"
+
+	"hugo-renderer/deps"
+	"hugo-renderer/tpl/internal"
+)
+
+// TODO(bookshop): DRY
+func createFuncMap(d *deps.Deps) map[string]interface{} {
+	funcMap := template.FuncMap{}
+
+	// Merge the namespace funcs
+	for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
+		ns := nsf(d)
+		if _, exists := funcMap[ns.Name]; exists {
+			panic(ns.Name + " is a duplicate template func")
+		}
+		funcMap[ns.Name] = ns.Context
+		for _, mm := range ns.MethodMappings {
+			for _, alias := range mm.Aliases {
+				if _, exists := funcMap[alias]; exists {
+					panic(alias + " is a duplicate template func")
+				}
+				funcMap[alias] = mm.Method
+			}
+		}
+	}
+
+	return funcMap
+}
+
+type bookshopPartial struct {
+	Contents       string `json:"contents"`
+	ParsedContents *template.Template
+}
+
+var componentLibrary map[string]bookshopPartial
+
+// LoadHugoBookshopPartials takes all files that the
+// @bookshop/hugo-engine was given and stashes them away
+// on this side of the wasm boundary, for the partials
+// function to use.
+func LoadHugoBookshopPartials(partials string) interface{} {
+	err := json.Unmarshal([]byte(partials), &componentLibrary)
+	if err != nil {
+		buf := bytes.NewBufferString(fmt.Sprintf("bad json unmarshal: %s", err.Error()))
+		return buf.String()
+	}
+
+	buf := bytes.NewBufferString(fmt.Sprintf("loaded %d components", len(componentLibrary)))
+	return buf.String()
+}
+
+// RetrieveBookshopPartial looks for a Bookshop file
+// and returns its template in a standard lib go html/template.
+// TODO(bookshop): This should probably one day play
+// nicer with the Hugo templating packages.
+func RetrieveBookshopPartial(bookshop_key string) (*template.Template, bool) {
+	if component, ok := componentLibrary[bookshop_key]; ok {
+		if component.ParsedContents == nil {
+			d := deps.Deps{}
+			funcMap := createFuncMap(&d)
+			templ, err := template.New("").Funcs(funcMap).Parse(component.Contents)
+			if err != nil {
+				return nil, false
+			}
+			component.ParsedContents = templ
+		}
+		return component.ParsedContents, true
+	}
+	return nil, false
+}
+
+// UnwrapBookshopPartial takes the dict or slice that the {{ partial "bookshop" ... }}
+// was given, and pulls out the component / partial name that should be rendered.
+// TODO(bookshop): Ideally our templating support gets better,
+// and we can call the production bookshop module partials.
+func UnwrapBookshopComponent(context interface{}) (string, interface{}) {
+	if componentData, ok := context.(map[string]interface{}); ok {
+		if component, ok := componentData["_bookshop_name"]; ok {
+			key := fmt.Sprintf("components/%s/%s.hugo.html", component.(string), component.(string))
+			return key, context
+		}
+	}
+	if componentData, ok := context.([]interface{}); ok {
+		if component, ok := componentData[0].(string); ok {
+			key := fmt.Sprintf("components/%s/%s.hugo.html", component, component)
+			return key, componentData[1]
+		}
+	}
+	return "err_no_bookshop_name", context
+}
+
+func UnwrapBookshopPartial(context interface{}) (string, interface{}) {
+	if partialData, ok := context.([]interface{}); ok {
+		if partial, ok := partialData[0].(string); ok {
+			key := fmt.Sprintf("shared/hugo/%s.hugo.html", partial)
+			return key, partialData[1]
+		}
+	}
+	return "err_no_bookshop_name", context
+}

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

@@ -0,0 +1,63 @@
+// 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

@@ -0,0 +1,57 @@
+// 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

@@ -0,0 +1,37 @@
+// 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

@@ -0,0 +1,131 @@
+// 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
+}