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

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

@@ -1,500 +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 strings provides template functions for manipulating strings.
-package strings
-
-import (
-	"errors"
-	"html/template"
-	"hugo-renderer/deps"
-	"regexp"
-	"strings"
-	"unicode/utf8"
-
-	"hugo-renderer/helpers"
-
-	_errors "github.com/pkg/errors"
-	"github.com/spf13/cast"
-)
-
-// New returns a new instance of the strings-namespaced template functions.
-func New(d *deps.Deps) *Namespace {
-	return &Namespace{titleFunc: strings.Title} // TODO(bookshop): Only the "Go" title formatting is supported
-}
-
-// Namespace provides template functions for the "strings" namespace.
-// Most functions mimic the Go stdlib, but the order of the parameters may be
-// different to ease their use in the Go template system.
-type Namespace struct {
-	titleFunc func(s string) string
-}
-
-// CountRunes returns the number of runes in s, excluding whitespace.
-func (ns *Namespace) CountRunes(s interface{}) (int, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to convert content to string")
-	}
-
-	counter := 0
-	for _, r := range helpers.StripHTML(ss) {
-		if !helpers.IsWhitespace(r) {
-			counter++
-		}
-	}
-
-	return counter, nil
-}
-
-// RuneCount returns the number of runes in s.
-func (ns *Namespace) RuneCount(s interface{}) (int, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to convert content to string")
-	}
-	return utf8.RuneCountInString(ss), nil
-}
-
-// CountWords returns the approximate word count in s.
-func (ns *Namespace) CountWords(s interface{}) (int, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to convert content to string")
-	}
-
-	isCJKLanguage, err := regexp.MatchString(`\p{Han}|\p{Hangul}|\p{Hiragana}|\p{Katakana}`, ss)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to match regex pattern against string")
-	}
-
-	if !isCJKLanguage {
-		return len(strings.Fields(helpers.StripHTML((ss)))), nil
-	}
-
-	counter := 0
-	for _, word := range strings.Fields(helpers.StripHTML(ss)) {
-		runeCount := utf8.RuneCountInString(word)
-		if len(word) == runeCount {
-			counter++
-		} else {
-			counter += runeCount
-		}
-	}
-
-	return counter, nil
-}
-
-// Count counts the number of non-overlapping instances of substr in s.
-// If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
-func (ns *Namespace) Count(substr, s interface{}) (int, error) {
-	substrs, err := cast.ToStringE(substr)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to convert substr to string")
-	}
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return 0, _errors.Wrap(err, "Failed to convert s to string")
-	}
-	return strings.Count(ss, substrs), nil
-}
-
-// Chomp returns a copy of s with all trailing newline characters removed.
-func (ns *Namespace) Chomp(s interface{}) (interface{}, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	res := strings.TrimRight(ss, "\r\n")
-	switch s.(type) {
-	case template.HTML:
-		return template.HTML(res), nil
-	default:
-		return res, nil
-	}
-}
-
-// Contains reports whether substr is in s.
-func (ns *Namespace) Contains(s, substr interface{}) (bool, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return false, err
-	}
-
-	su, err := cast.ToStringE(substr)
-	if err != nil {
-		return false, err
-	}
-
-	return strings.Contains(ss, su), nil
-}
-
-// ContainsAny reports whether any Unicode code points in chars are within s.
-func (ns *Namespace) ContainsAny(s, chars interface{}) (bool, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return false, err
-	}
-
-	sc, err := cast.ToStringE(chars)
-	if err != nil {
-		return false, err
-	}
-
-	return strings.ContainsAny(ss, sc), nil
-}
-
-// HasPrefix tests whether the input s begins with prefix.
-func (ns *Namespace) HasPrefix(s, prefix interface{}) (bool, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return false, err
-	}
-
-	sx, err := cast.ToStringE(prefix)
-	if err != nil {
-		return false, err
-	}
-
-	return strings.HasPrefix(ss, sx), nil
-}
-
-// HasSuffix tests whether the input s begins with suffix.
-func (ns *Namespace) HasSuffix(s, suffix interface{}) (bool, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return false, err
-	}
-
-	sx, err := cast.ToStringE(suffix)
-	if err != nil {
-		return false, err
-	}
-
-	return strings.HasSuffix(ss, sx), nil
-}
-
-// Replace returns a copy of the string s with all occurrences of old replaced
-// with new.  The number of replacements can be limited with an optional fourth
-// parameter.
-func (ns *Namespace) Replace(s, old, new interface{}, limit ...interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	so, err := cast.ToStringE(old)
-	if err != nil {
-		return "", err
-	}
-
-	sn, err := cast.ToStringE(new)
-	if err != nil {
-		return "", err
-	}
-
-	if len(limit) == 0 {
-		return strings.ReplaceAll(ss, so, sn), nil
-	}
-
-	lim, err := cast.ToIntE(limit[0])
-	if err != nil {
-		return "", err
-	}
-
-	return strings.Replace(ss, so, sn, lim), nil
-}
-
-// SliceString slices a string by specifying a half-open range with
-// two indices, start and end. 1 and 4 creates a slice including elements 1 through 3.
-// The end index can be omitted, it defaults to the string's length.
-func (ns *Namespace) SliceString(a interface{}, startEnd ...interface{}) (string, error) {
-	aStr, err := cast.ToStringE(a)
-	if err != nil {
-		return "", err
-	}
-
-	var argStart, argEnd int
-
-	argNum := len(startEnd)
-
-	if argNum > 0 {
-		if argStart, err = cast.ToIntE(startEnd[0]); err != nil {
-			return "", errors.New("start argument must be integer")
-		}
-	}
-	if argNum > 1 {
-		if argEnd, err = cast.ToIntE(startEnd[1]); err != nil {
-			return "", errors.New("end argument must be integer")
-		}
-	}
-
-	if argNum > 2 {
-		return "", errors.New("too many arguments")
-	}
-
-	asRunes := []rune(aStr)
-
-	if argNum > 0 && (argStart < 0 || argStart >= len(asRunes)) {
-		return "", errors.New("slice bounds out of range")
-	}
-
-	if argNum == 2 {
-		if argEnd < 0 || argEnd > len(asRunes) {
-			return "", errors.New("slice bounds out of range")
-		}
-		return string(asRunes[argStart:argEnd]), nil
-	} else if argNum == 1 {
-		return string(asRunes[argStart:]), nil
-	} else {
-		return string(asRunes[:]), nil
-	}
-}
-
-// Split slices an input string into all substrings separated by delimiter.
-func (ns *Namespace) Split(a interface{}, delimiter string) ([]string, error) {
-	aStr, err := cast.ToStringE(a)
-	if err != nil {
-		return []string{}, err
-	}
-
-	return strings.Split(aStr, delimiter), nil
-}
-
-// Substr extracts parts of a string, beginning at the character at the specified
-// position, and returns the specified number of characters.
-//
-// It normally takes two parameters: start and length.
-// It can also take one parameter: start, i.e. length is omitted, in which case
-// the substring starting from start until the end of the string will be returned.
-//
-// To extract characters from the end of the string, use a negative start number.
-//
-// In addition, borrowing from the extended behavior described at http://php.net/substr,
-// if length is given and is negative, then that many characters will be omitted from
-// the end of string.
-func (ns *Namespace) Substr(a interface{}, nums ...interface{}) (string, error) {
-	s, err := cast.ToStringE(a)
-	if err != nil {
-		return "", err
-	}
-
-	asRunes := []rune(s)
-	rlen := len(asRunes)
-
-	var start, length int
-
-	switch len(nums) {
-	case 0:
-		return "", errors.New("too few arguments")
-	case 1:
-		if start, err = cast.ToIntE(nums[0]); err != nil {
-			return "", errors.New("start argument must be an integer")
-		}
-		length = rlen
-	case 2:
-		if start, err = cast.ToIntE(nums[0]); err != nil {
-			return "", errors.New("start argument must be an integer")
-		}
-		if length, err = cast.ToIntE(nums[1]); err != nil {
-			return "", errors.New("length argument must be an integer")
-		}
-	default:
-		return "", errors.New("too many arguments")
-	}
-
-	if rlen == 0 {
-		return "", nil
-	}
-
-	if start < 0 {
-		start += rlen
-	}
-
-	// start was originally negative beyond rlen
-	if start < 0 {
-		start = 0
-	}
-
-	if start > rlen-1 {
-		return "", nil
-	}
-
-	end := rlen
-
-	switch {
-	case length == 0:
-		return "", nil
-	case length < 0:
-		end += length
-	case length > 0:
-		end = start + length
-	}
-
-	if start >= end {
-		return "", nil
-	}
-
-	if end < 0 {
-		return "", nil
-	}
-
-	if end > rlen {
-		end = rlen
-	}
-
-	return string(asRunes[start:end]), nil
-}
-
-// Title returns a copy of the input s with all Unicode letters that begin words
-// mapped to their title case.
-func (ns *Namespace) Title(s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	return ns.titleFunc(ss), nil
-}
-
-// FirstUpper returns a string with the first character as upper case.
-func (ns *Namespace) FirstUpper(s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	return helpers.FirstUpper(ss), nil
-}
-
-// ToLower returns a copy of the input s with all Unicode letters mapped to their
-// lower case.
-func (ns *Namespace) ToLower(s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.ToLower(ss), nil
-}
-
-// ToUpper returns a copy of the input s with all Unicode letters mapped to their
-// upper case.
-func (ns *Namespace) ToUpper(s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.ToUpper(ss), nil
-}
-
-// Trim returns a string with all leading and trailing characters defined
-// contained in cutset removed.
-func (ns *Namespace) Trim(s, cutset interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sc, err := cast.ToStringE(cutset)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.Trim(ss, sc), nil
-}
-
-// TrimLeft returns a slice of the string s with all leading characters
-// contained in cutset removed.
-func (ns *Namespace) TrimLeft(cutset, s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sc, err := cast.ToStringE(cutset)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimLeft(ss, sc), nil
-}
-
-// TrimPrefix returns s without the provided leading prefix string. If s doesn't
-// start with prefix, s is returned unchanged.
-func (ns *Namespace) TrimPrefix(prefix, s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sx, err := cast.ToStringE(prefix)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimPrefix(ss, sx), nil
-}
-
-// TrimRight returns a slice of the string s with all trailing characters
-// contained in cutset removed.
-func (ns *Namespace) TrimRight(cutset, s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sc, err := cast.ToStringE(cutset)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimRight(ss, sc), nil
-}
-
-// TrimSuffix returns s without the provided trailing suffix string. If s
-// doesn't end with suffix, s is returned unchanged.
-func (ns *Namespace) TrimSuffix(suffix, s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sx, err := cast.ToStringE(suffix)
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSuffix(ss, sx), nil
-}
-
-// Repeat returns a new string consisting of count copies of the string s.
-func (ns *Namespace) Repeat(n, s interface{}) (string, error) {
-	ss, err := cast.ToStringE(s)
-	if err != nil {
-		return "", err
-	}
-
-	sn, err := cast.ToIntE(n)
-	if err != nil {
-		return "", err
-	}
-
-	if sn < 0 {
-		return "", errors.New("strings: negative Repeat count")
-	}
-
-	return strings.Repeat(ss, sn), nil
-}

package/hugo-renderer/tpl/strings/truncate.go

@@ -1,157 +0,0 @@
-// Copyright 2016 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 strings
-
-import (
-	"errors"
-	"html"
-	"html/template"
-	"regexp"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/spf13/cast"
-)
-
-var (
-	tagRE        = regexp.MustCompile(`^<(/)?([^ ]+?)(?:(\s*/)| .*?)?>`)
-	htmlSinglets = map[string]bool{
-		"br": true, "col": true, "link": true,
-		"base": true, "img": true, "param": true,
-		"area": true, "hr": true, "input": true,
-	}
-)
-
-type htmlTag struct {
-	name    string
-	pos     int
-	openTag bool
-}
-
-// Truncate truncates a given string to the specified length.
-func (ns *Namespace) Truncate(a interface{}, options ...interface{}) (template.HTML, error) {
-	length, err := cast.ToIntE(a)
-	if err != nil {
-		return "", err
-	}
-	var textParam interface{}
-	var ellipsis string
-
-	switch len(options) {
-	case 0:
-		return "", errors.New("truncate requires a length and a string")
-	case 1:
-		textParam = options[0]
-		ellipsis = " …"
-	case 2:
-		textParam = options[1]
-		ellipsis, err = cast.ToStringE(options[0])
-		if err != nil {
-			return "", errors.New("ellipsis must be a string")
-		}
-		if _, ok := options[0].(template.HTML); !ok {
-			ellipsis = html.EscapeString(ellipsis)
-		}
-	default:
-		return "", errors.New("too many arguments passed to truncate")
-	}
-	if err != nil {
-		return "", errors.New("text to truncate must be a string")
-	}
-	text, err := cast.ToStringE(textParam)
-	if err != nil {
-		return "", errors.New("text must be a string")
-	}
-
-	_, isHTML := textParam.(template.HTML)
-
-	if utf8.RuneCountInString(text) <= length {
-		if isHTML {
-			return template.HTML(text), nil
-		}
-		return template.HTML(html.EscapeString(text)), nil
-	}
-
-	tags := []htmlTag{}
-	var lastWordIndex, lastNonSpace, currentLen, endTextPos, nextTag int
-
-	for i, r := range text {
-		if i < nextTag {
-			continue
-		}
-
-		if isHTML {
-			// Make sure we keep tag of HTML tags
-			slice := text[i:]
-			m := tagRE.FindStringSubmatchIndex(slice)
-			if len(m) > 0 && m[0] == 0 {
-				nextTag = i + m[1]
-				tagname := slice[m[4]:m[5]]
-				lastWordIndex = lastNonSpace
-				_, singlet := htmlSinglets[tagname]
-				if !singlet && m[6] == -1 {
-					tags = append(tags, htmlTag{name: tagname, pos: i, openTag: m[2] == -1})
-				}
-
-				continue
-			}
-		}
-
-		currentLen++
-		if unicode.IsSpace(r) {
-			lastWordIndex = lastNonSpace
-		} else if unicode.In(r, unicode.Han, unicode.Hangul, unicode.Hiragana, unicode.Katakana) {
-			lastWordIndex = i
-		} else {
-			lastNonSpace = i + utf8.RuneLen(r)
-		}
-
-		if currentLen > length {
-			if lastWordIndex == 0 {
-				endTextPos = i
-			} else {
-				endTextPos = lastWordIndex
-			}
-			out := text[0:endTextPos]
-			if isHTML {
-				out += ellipsis
-				// Close out any open HTML tags
-				var currentTag *htmlTag
-				for i := len(tags) - 1; i >= 0; i-- {
-					tag := tags[i]
-					if tag.pos >= endTextPos || currentTag != nil {
-						if currentTag != nil && currentTag.name == tag.name {
-							currentTag = nil
-						}
-						continue
-					}
-
-					if tag.openTag {
-						out += ("</" + tag.name + ">")
-					} else {
-						currentTag = &tag
-					}
-				}
-
-				return template.HTML(out), nil
-			}
-			return template.HTML(html.EscapeString(out) + ellipsis), nil
-		}
-	}
-
-	if isHTML {
-		return template.HTML(text), nil
-	}
-	return template.HTML(html.EscapeString(text)), nil
-}

package/hugo-renderer/tpl/transform/bookshop_unmarshal.go

@@ -1,39 +0,0 @@
-// 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 transform
-
-import (
-	"encoding/json"
-
-	"github.com/pkg/errors"
-)
-
-// Unmarshal unmarshals the data given, which can be either a string, json.RawMessage
-// or a Resource. Supported formats are JSON, TOML, YAML, and CSV.
-// You can optionally provide an options map as the first argument.
-func (ns *Namespace) BookshopUnmarshal(args ...interface{}) (interface{}, error) {
-	if len(args) != 1 {
-		return nil, errors.New("Bookshop unmarshal takes 1 argument")
-	}
-
-	var data interface{}
-
-	if r, ok := args[0].(string); ok {
-		if err := json.Unmarshal([]byte(r), &data); err != nil {
-			return nil, err
-		}
-		return data, nil
-	}
-	return nil, errors.New("Needed a string")
-}