mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-21 20:46:30 -05:00
tpl: Add humanize func and cleanup lint
Add humanize (inflect.Humanize) to the template funcMap. Documentation and tests are included. Various code cleanups of the template funcs: - Break pluralize and singularize out into stand-alone funcs. - Sort the list of funcMap entries. - Add some minimal godoc comments to all public funcs. - Fix some issues found by golint and grind.
This commit is contained in:
Cameron Moore
Bjørn Erik Pedersen
parent
e95f3af933
commit
45df4596bb
3 changed files with 168 additions and 110 deletions
|
|
@ -387,6 +387,16 @@ Takes a string of code and a language, uses Pygments to return the syntax highli
|
|||
Used in the [highlight shortcode](/extras/highlighting/).
|
||||
|
||||
|
||||
### humanize
|
||||
Humanize returns the humanized version of a string with the first letter capitalized.
|
||||
|
||||
e.g.
|
||||
```
|
||||
{{humanize "my-first-post"}} → "My first post"
|
||||
{{humanize "myCamelPost"}} → "My camel post"
|
||||
```
|
||||
|
||||
|
||||
### lower
|
||||
Converts all characters in string to lowercase.
|
||||
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ import (
|
|||
|
||||
var funcMap template.FuncMap
|
||||
|
||||
// Eq returns the boolean truth of arg1 == arg2.
|
||||
func Eq(x, y interface{}) bool {
|
||||
normalize := func(v interface{}) interface{} {
|
||||
vv := reflect.ValueOf(v)
|
||||
|
|
@ -57,30 +58,38 @@ func Eq(x, y interface{}) bool {
|
|||
return reflect.DeepEqual(x, y)
|
||||
}
|
||||
|
||||
// Ne returns the boolean truth of arg1 != arg2.
|
||||
func Ne(x, y interface{}) bool {
|
||||
return !Eq(x, y)
|
||||
}
|
||||
|
||||
// Ge returns the boolean truth of arg1 >= arg2.
|
||||
func Ge(a, b interface{}) bool {
|
||||
left, right := compareGetFloat(a, b)
|
||||
return left >= right
|
||||
}
|
||||
|
||||
// Gt returns the boolean truth of arg1 > arg2.
|
||||
func Gt(a, b interface{}) bool {
|
||||
left, right := compareGetFloat(a, b)
|
||||
return left > right
|
||||
}
|
||||
|
||||
// Le returns the boolean truth of arg1 <= arg2.
|
||||
func Le(a, b interface{}) bool {
|
||||
left, right := compareGetFloat(a, b)
|
||||
return left <= right
|
||||
}
|
||||
|
||||
// Lt returns the boolean truth of arg1 < arg2.
|
||||
func Lt(a, b interface{}) bool {
|
||||
left, right := compareGetFloat(a, b)
|
||||
return left < right
|
||||
}
|
||||
|
||||
// Dictionary creates a map[string]interface{} from the given parameters by
|
||||
// walking the parameters and treating them as key-value pairs. The number
|
||||
// of parameters must be even.
|
||||
func Dictionary(values ...interface{}) (map[string]interface{}, error) {
|
||||
if len(values)%2 != 0 {
|
||||
return nil, errors.New("invalid dict call")
|
||||
|
|
@ -99,7 +108,6 @@ func Dictionary(values ...interface{}) (map[string]interface{}, error) {
|
|||
func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
|
||||
var left, right float64
|
||||
var leftStr, rightStr *string
|
||||
var err error
|
||||
av := reflect.ValueOf(a)
|
||||
|
||||
switch av.Kind() {
|
||||
|
|
@ -110,6 +118,7 @@ func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
|
|||
case reflect.Float32, reflect.Float64:
|
||||
left = av.Float()
|
||||
case reflect.String:
|
||||
var err error
|
||||
left, err = strconv.ParseFloat(av.String(), 64)
|
||||
if err != nil {
|
||||
str := av.String()
|
||||
|
|
@ -132,6 +141,7 @@ func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
|
|||
case reflect.Float32, reflect.Float64:
|
||||
right = bv.Float()
|
||||
case reflect.String:
|
||||
var err error
|
||||
right, err = strconv.ParseFloat(bv.String(), 64)
|
||||
if err != nil {
|
||||
str := bv.String()
|
||||
|
|
@ -157,7 +167,7 @@ func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
|
|||
return left, right
|
||||
}
|
||||
|
||||
// Slicing in Slicestr is done by specifying a half-open range with
|
||||
// Slicestr 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 Slicestr(a interface{}, startEnd ...interface{}) (string, error) {
|
||||
|
|
@ -249,7 +259,7 @@ func Substr(a interface{}, nums ...interface{}) (string, error) {
|
|||
start = 0
|
||||
}
|
||||
if start > len(asRunes) {
|
||||
return "", errors.New(fmt.Sprintf("start position out of bounds for %d-byte string", len(aStr)))
|
||||
return "", fmt.Errorf("start position out of bounds for %d-byte string", len(aStr))
|
||||
}
|
||||
|
||||
var s, e int
|
||||
|
|
@ -268,16 +278,16 @@ func Substr(a interface{}, nums ...interface{}) (string, error) {
|
|||
}
|
||||
|
||||
if s > e {
|
||||
return "", errors.New(fmt.Sprintf("calculated start position greater than end position: %d > %d", s, e))
|
||||
return "", fmt.Errorf("calculated start position greater than end position: %d > %d", s, e)
|
||||
}
|
||||
if e > len(asRunes) {
|
||||
e = len(asRunes)
|
||||
}
|
||||
|
||||
return string(asRunes[s:e]), nil
|
||||
|
||||
}
|
||||
|
||||
// Split slices an input string into all substrings separated by delimiter.
|
||||
func Split(a interface{}, delimiter string) ([]string, error) {
|
||||
aStr, err := cast.ToStringE(a)
|
||||
if err != nil {
|
||||
|
|
@ -286,6 +296,8 @@ func Split(a interface{}, delimiter string) ([]string, error) {
|
|||
return strings.Split(aStr, delimiter), nil
|
||||
}
|
||||
|
||||
// Intersect returns the common elements in the given sets, l1 and l2. l1 and
|
||||
// l2 must be of the same type and may be either arrays or slices.
|
||||
func Intersect(l1, l2 interface{}) (interface{}, error) {
|
||||
if l1 == nil || l2 == nil {
|
||||
return make([]interface{}, 0), nil
|
||||
|
|
@ -334,6 +346,7 @@ func Intersect(l1, l2 interface{}) (interface{}, error) {
|
|||
}
|
||||
}
|
||||
|
||||
// In returns whether v is in the set l. l may be an array or slice.
|
||||
func In(l interface{}, v interface{}) bool {
|
||||
lv := reflect.ValueOf(l)
|
||||
vv := reflect.ValueOf(v)
|
||||
|
|
@ -388,10 +401,8 @@ func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
|
|||
return v, false
|
||||
}
|
||||
|
||||
// First is exposed to templates, to iterate over the first N items in a
|
||||
// rangeable list.
|
||||
// First returns the first N items in a rangeable list.
|
||||
func First(limit interface{}, seq interface{}) (interface{}, error) {
|
||||
|
||||
if limit == nil || seq == nil {
|
||||
return nil, errors.New("both limit and seq must be provided")
|
||||
}
|
||||
|
|
@ -424,10 +435,8 @@ func First(limit interface{}, seq interface{}) (interface{}, error) {
|
|||
return seqv.Slice(0, limitv).Interface(), nil
|
||||
}
|
||||
|
||||
// Last is exposed to templates, to iterate over the last N items in a
|
||||
// rangeable list.
|
||||
// Last returns the last N items in a rangeable list.
|
||||
func Last(limit interface{}, seq interface{}) (interface{}, error) {
|
||||
|
||||
if limit == nil || seq == nil {
|
||||
return nil, errors.New("both limit and seq must be provided")
|
||||
}
|
||||
|
|
@ -460,10 +469,8 @@ func Last(limit interface{}, seq interface{}) (interface{}, error) {
|
|||
return seqv.Slice(seqv.Len()-limitv, seqv.Len()).Interface(), nil
|
||||
}
|
||||
|
||||
// After is exposed to templates, to iterate over all the items after N in a
|
||||
// rangeable list. It's meant to accompany First
|
||||
// After returns all the items after the first N in a rangeable list.
|
||||
func After(index interface{}, seq interface{}) (interface{}, error) {
|
||||
|
||||
if index == nil || seq == nil {
|
||||
return nil, errors.New("both limit and seq must be provided")
|
||||
}
|
||||
|
|
@ -496,10 +503,8 @@ func After(index interface{}, seq interface{}) (interface{}, error) {
|
|||
return seqv.Slice(indexv, seqv.Len()).Interface(), nil
|
||||
}
|
||||
|
||||
// Shuffle is exposed to templates, to iterate over items in rangeable list in
|
||||
// a randomised order.
|
||||
// Shuffle returns the given rangeable list in a randomised order.
|
||||
func Shuffle(seq interface{}) (interface{}, error) {
|
||||
|
||||
if seq == nil {
|
||||
return nil, errors.New("both count and seq must be provided")
|
||||
}
|
||||
|
|
@ -742,15 +747,15 @@ func checkCondition(v, mv reflect.Value, op string) (bool, error) {
|
|||
}
|
||||
if op == "not in" {
|
||||
return !r, nil
|
||||
} else {
|
||||
return r, nil
|
||||
}
|
||||
return r, nil
|
||||
default:
|
||||
return false, errors.New("no such an operator")
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// Where returns a filtered subset of a given data type.
|
||||
func Where(seq, key interface{}, args ...interface{}) (r interface{}, err error) {
|
||||
seqv := reflect.ValueOf(seq)
|
||||
kv := reflect.ValueOf(key)
|
||||
|
|
@ -813,7 +818,7 @@ func Where(seq, key interface{}, args ...interface{}) (r interface{}, err error)
|
|||
}
|
||||
}
|
||||
|
||||
// Apply, given a map, array, or slice, returns a new slice with the function fname applied over it.
|
||||
// Apply takes a map, array, or slice and returns a new slice with the function fname applied over it.
|
||||
func Apply(seq interface{}, fname string, args ...interface{}) (interface{}, error) {
|
||||
if seq == nil {
|
||||
return make([]interface{}, 0), nil
|
||||
|
|
@ -890,11 +895,12 @@ func applyFnToThis(fn, this reflect.Value, args ...interface{}) (reflect.Value,
|
|||
|
||||
if len(res) == 1 || res[1].IsNil() {
|
||||
return res[0], nil
|
||||
} else {
|
||||
return reflect.ValueOf(nil), res[1].Interface().(error)
|
||||
}
|
||||
return reflect.ValueOf(nil), res[1].Interface().(error)
|
||||
}
|
||||
|
||||
// Delimit takes a given sequence and returns a delimited HTML string.
|
||||
// If last is passed to the function, it will be used as the final delimiter.
|
||||
func Delimit(seq, delimiter interface{}, last ...interface{}) (template.HTML, error) {
|
||||
d, err := cast.ToStringE(delimiter)
|
||||
if err != nil {
|
||||
|
|
@ -950,6 +956,7 @@ func Delimit(seq, delimiter interface{}, last ...interface{}) (template.HTML, er
|
|||
return template.HTML(str), nil
|
||||
}
|
||||
|
||||
// Sort returns a sorted sequence.
|
||||
func Sort(seq interface{}, args ...interface{}) (interface{}, error) {
|
||||
seqv := reflect.ValueOf(seq)
|
||||
seqv, isNil := indirect(seqv)
|
||||
|
|
@ -1066,6 +1073,8 @@ func (p pairList) sort() interface{} {
|
|||
return sorted.Interface()
|
||||
}
|
||||
|
||||
// IsSet returns whether a given array, channel, slice, or map has a key
|
||||
// defined.
|
||||
func IsSet(a interface{}, key interface{}) bool {
|
||||
av := reflect.ValueOf(a)
|
||||
kv := reflect.ValueOf(key)
|
||||
|
|
@ -1084,6 +1093,8 @@ func IsSet(a interface{}, key interface{}) bool {
|
|||
return false
|
||||
}
|
||||
|
||||
// ReturnWhenSet returns a given value if it set. Otherwise, it returns an
|
||||
// empty string.
|
||||
func ReturnWhenSet(a, k interface{}) interface{} {
|
||||
av, isNil := indirect(reflect.ValueOf(a))
|
||||
if isNil {
|
||||
|
|
@ -1120,6 +1131,7 @@ func ReturnWhenSet(a, k interface{}) interface{} {
|
|||
return ""
|
||||
}
|
||||
|
||||
// Highlight returns an HTML string with syntax highlighting applied.
|
||||
func Highlight(in interface{}, lang, opts string) template.HTML {
|
||||
var str string
|
||||
av := reflect.ValueOf(in)
|
||||
|
|
@ -1134,6 +1146,7 @@ func Highlight(in interface{}, lang, opts string) template.HTML {
|
|||
var markdownTrimPrefix = []byte("<p>")
|
||||
var markdownTrimSuffix = []byte("</p>\n")
|
||||
|
||||
// Markdownify renders a given string from Markdown to HTML.
|
||||
func Markdownify(text string) template.HTML {
|
||||
m := helpers.RenderBytes(&helpers.RenderingContext{Content: []byte(text), PageFmt: "markdown"})
|
||||
m = bytes.TrimPrefix(m, markdownTrimPrefix)
|
||||
|
|
@ -1168,14 +1181,17 @@ func refPage(page interface{}, ref, methodName string) template.HTML {
|
|||
return template.HTML(ref)
|
||||
}
|
||||
|
||||
// Ref returns the absolute URL path to a given content item.
|
||||
func Ref(page interface{}, ref string) template.HTML {
|
||||
return refPage(page, ref, "Ref")
|
||||
}
|
||||
|
||||
// RelRef returns the relative URL path to a given content item.
|
||||
func RelRef(page interface{}, ref string) template.HTML {
|
||||
return refPage(page, ref, "RelRef")
|
||||
}
|
||||
|
||||
// Chomp removes trailing newline characters from a string.
|
||||
func Chomp(text interface{}) (string, error) {
|
||||
s, err := cast.ToStringE(text)
|
||||
if err != nil {
|
||||
|
|
@ -1222,23 +1238,28 @@ func DateFormat(layout string, v interface{}) (string, error) {
|
|||
return t.Format(layout), nil
|
||||
}
|
||||
|
||||
// "safeHTMLAttr" is currently disabled, pending further discussion
|
||||
// SafeHTMLAttr returns a given string as html/template HTMLAttr content.
|
||||
//
|
||||
// SafeHTMLAttr is currently disabled, pending further discussion
|
||||
// on its use case. 2015-01-19
|
||||
func SafeHTMLAttr(text string) template.HTMLAttr {
|
||||
return template.HTMLAttr(text)
|
||||
}
|
||||
|
||||
// SafeCSS returns a given string as html/template CSS content.
|
||||
func SafeCSS(text string) template.CSS {
|
||||
return template.CSS(text)
|
||||
}
|
||||
|
||||
// SafeURL returns a given string as html/template URL content.
|
||||
func SafeURL(text string) template.URL {
|
||||
return template.URL(text)
|
||||
}
|
||||
|
||||
// SafeHTML returns a given string as html/template HTML content.
|
||||
func SafeHTML(a string) template.HTML { return template.HTML(a) }
|
||||
|
||||
// SafeJS returns the given string as a template.JS type from html/template.
|
||||
// SafeJS returns the given string as a html/template JS content.
|
||||
func SafeJS(a string) template.JS { return template.JS(a) }
|
||||
|
||||
func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
||||
|
|
@ -1307,9 +1328,8 @@ func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
|||
if bv.Kind() == reflect.String && op == '+' {
|
||||
bs := bv.String()
|
||||
return as + bs, nil
|
||||
} else {
|
||||
return nil, errors.New("Can't apply the operator to the values")
|
||||
}
|
||||
return nil, errors.New("Can't apply the operator to the values")
|
||||
default:
|
||||
return nil, errors.New("Can't apply the operator to the values")
|
||||
}
|
||||
|
|
@ -1322,9 +1342,8 @@ func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
|||
return af + bf, nil
|
||||
} else if au != 0 || bu != 0 {
|
||||
return au + bu, nil
|
||||
} else {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, nil
|
||||
case '-':
|
||||
if ai != 0 || bi != 0 {
|
||||
return ai - bi, nil
|
||||
|
|
@ -1332,9 +1351,8 @@ func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
|||
return af - bf, nil
|
||||
} else if au != 0 || bu != 0 {
|
||||
return au - bu, nil
|
||||
} else {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, nil
|
||||
case '*':
|
||||
if ai != 0 || bi != 0 {
|
||||
return ai * bi, nil
|
||||
|
|
@ -1342,9 +1360,8 @@ func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
|||
return af * bf, nil
|
||||
} else if au != 0 || bu != 0 {
|
||||
return au * bu, nil
|
||||
} else {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, nil
|
||||
case '/':
|
||||
if bi != 0 {
|
||||
return ai / bi, nil
|
||||
|
|
@ -1352,14 +1369,14 @@ func doArithmetic(a, b interface{}, op rune) (interface{}, error) {
|
|||
return af / bf, nil
|
||||
} else if bu != 0 {
|
||||
return au / bu, nil
|
||||
} else {
|
||||
return nil, errors.New("Can't divide the value by 0")
|
||||
}
|
||||
return nil, errors.New("Can't divide the value by 0")
|
||||
default:
|
||||
return nil, errors.New("There is no such an operation")
|
||||
}
|
||||
}
|
||||
|
||||
// Mod returns a % b.
|
||||
func Mod(a, b interface{}) (int64, error) {
|
||||
av := reflect.ValueOf(a)
|
||||
bv := reflect.ValueOf(b)
|
||||
|
|
@ -1386,6 +1403,7 @@ func Mod(a, b interface{}) (int64, error) {
|
|||
return ai % bi, nil
|
||||
}
|
||||
|
||||
// ModBool returns the boolean of a % b. If a % b == 0, return true.
|
||||
func ModBool(a, b interface{}) (bool, error) {
|
||||
res, err := Mod(a, b)
|
||||
if err != nil {
|
||||
|
|
@ -1394,6 +1412,7 @@ func ModBool(a, b interface{}) (bool, error) {
|
|||
return res == int64(0), nil
|
||||
}
|
||||
|
||||
// Base64Decode returns the base64 decoding of the given content.
|
||||
func Base64Decode(content interface{}) (string, error) {
|
||||
conv, err := cast.ToStringE(content)
|
||||
|
||||
|
|
@ -1410,6 +1429,7 @@ func Base64Decode(content interface{}) (string, error) {
|
|||
return string(dec), nil
|
||||
}
|
||||
|
||||
// Base64Encode returns the base64 encoding of the given content.
|
||||
func Base64Encode(content interface{}) (string, error) {
|
||||
conv, err := cast.ToStringE(content)
|
||||
|
||||
|
|
@ -1420,6 +1440,7 @@ func Base64Encode(content interface{}) (string, error) {
|
|||
return base64.StdEncoding.EncodeToString([]byte(conv)), nil
|
||||
}
|
||||
|
||||
// CountWords returns the approximate word count of the given content.
|
||||
func CountWords(content interface{}) (int, error) {
|
||||
conv, err := cast.ToStringE(content)
|
||||
|
||||
|
|
@ -1440,6 +1461,7 @@ func CountWords(content interface{}) (int, error) {
|
|||
return counter, nil
|
||||
}
|
||||
|
||||
// CountRunes returns the approximate rune count of the given content.
|
||||
func CountRunes(content interface{}) (int, error) {
|
||||
conv, err := cast.ToStringE(content)
|
||||
|
||||
|
|
@ -1457,83 +1479,100 @@ func CountRunes(content interface{}) (int, error) {
|
|||
return counter, nil
|
||||
}
|
||||
|
||||
func init() {
|
||||
funcMap = template.FuncMap{
|
||||
"urlize": helpers.URLize,
|
||||
"sanitizeURL": helpers.SanitizeURL,
|
||||
"sanitizeurl": helpers.SanitizeURL,
|
||||
"eq": Eq,
|
||||
"ne": Ne,
|
||||
"gt": Gt,
|
||||
"ge": Ge,
|
||||
"lt": Lt,
|
||||
"le": Le,
|
||||
"dict": Dictionary,
|
||||
"in": In,
|
||||
"slicestr": Slicestr,
|
||||
"substr": Substr,
|
||||
"split": Split,
|
||||
"intersect": Intersect,
|
||||
"isSet": IsSet,
|
||||
"isset": IsSet,
|
||||
"echoParam": ReturnWhenSet,
|
||||
"safeHTML": SafeHTML,
|
||||
"safeCSS": SafeCSS,
|
||||
"safeJS": SafeJS,
|
||||
"safeURL": SafeURL,
|
||||
"absURL": func(a string) template.HTML { return template.HTML(helpers.AbsURL(a)) },
|
||||
"relURL": func(a string) template.HTML { return template.HTML(helpers.RelURL(a)) },
|
||||
"markdownify": Markdownify,
|
||||
"first": First,
|
||||
"last": Last,
|
||||
"after": After,
|
||||
"shuffle": Shuffle,
|
||||
"where": Where,
|
||||
"delimit": Delimit,
|
||||
"sort": Sort,
|
||||
"highlight": Highlight,
|
||||
"add": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '+') },
|
||||
"sub": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '-') },
|
||||
"div": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '/') },
|
||||
"mod": Mod,
|
||||
"mul": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '*') },
|
||||
"modBool": ModBool,
|
||||
"lower": func(a string) string { return strings.ToLower(a) },
|
||||
"upper": func(a string) string { return strings.ToUpper(a) },
|
||||
"title": func(a string) string { return strings.Title(a) },
|
||||
"hasPrefix": func(a, b string) bool { return strings.HasPrefix(a, b) },
|
||||
"partial": Partial,
|
||||
"ref": Ref,
|
||||
"relref": RelRef,
|
||||
"apply": Apply,
|
||||
"chomp": Chomp,
|
||||
"int": func(v interface{}) int { return cast.ToInt(v) },
|
||||
"string": func(v interface{}) string { return cast.ToString(v) },
|
||||
"replace": Replace,
|
||||
"trim": Trim,
|
||||
"dateFormat": DateFormat,
|
||||
"getJSON": GetJSON,
|
||||
"getCSV": GetCSV,
|
||||
"readDir": ReadDir,
|
||||
"seq": helpers.Seq,
|
||||
"getenv": func(varName string) string { return os.Getenv(varName) },
|
||||
"base64Decode": Base64Decode,
|
||||
"base64Encode": Base64Encode,
|
||||
"countwords": CountWords,
|
||||
"countrunes": CountRunes,
|
||||
"pluralize": func(in interface{}) (string, error) {
|
||||
// Humanize returns the humanized form of a single word.
|
||||
// Example: "my-first-post" -> "My first post"
|
||||
func Humanize(in interface{}) (string, error) {
|
||||
word, err := cast.ToStringE(in)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return inflect.Humanize(word), nil
|
||||
}
|
||||
|
||||
// Pluralize returns the plural form of a single word.
|
||||
func Pluralize(in interface{}) (string, error) {
|
||||
word, err := cast.ToStringE(in)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return inflect.Pluralize(word), nil
|
||||
},
|
||||
"singularize": func(in interface{}) (string, error) {
|
||||
}
|
||||
|
||||
// Singularize returns the singular form of a single word.
|
||||
func Singularize(in interface{}) (string, error) {
|
||||
word, err := cast.ToStringE(in)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return inflect.Singularize(word), nil
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
funcMap = template.FuncMap{
|
||||
"absURL": func(a string) template.HTML { return template.HTML(helpers.AbsURL(a)) },
|
||||
"add": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '+') },
|
||||
"after": After,
|
||||
"apply": Apply,
|
||||
"base64Decode": Base64Decode,
|
||||
"base64Encode": Base64Encode,
|
||||
"chomp": Chomp,
|
||||
"countrunes": CountRunes,
|
||||
"countwords": CountWords,
|
||||
"dateFormat": DateFormat,
|
||||
"delimit": Delimit,
|
||||
"dict": Dictionary,
|
||||
"div": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '/') },
|
||||
"echoParam": ReturnWhenSet,
|
||||
"eq": Eq,
|
||||
"first": First,
|
||||
"ge": Ge,
|
||||
"getCSV": GetCSV,
|
||||
"getJSON": GetJSON,
|
||||
"getenv": func(varName string) string { return os.Getenv(varName) },
|
||||
"gt": Gt,
|
||||
"hasPrefix": func(a, b string) bool { return strings.HasPrefix(a, b) },
|
||||
"highlight": Highlight,
|
||||
"humanize": Humanize,
|
||||
"in": In,
|
||||
"int": func(v interface{}) int { return cast.ToInt(v) },
|
||||
"intersect": Intersect,
|
||||
"isSet": IsSet,
|
||||
"isset": IsSet,
|
||||
"last": Last,
|
||||
"le": Le,
|
||||
"lower": func(a string) string { return strings.ToLower(a) },
|
||||
"lt": Lt,
|
||||
"markdownify": Markdownify,
|
||||
"mod": Mod,
|
||||
"modBool": ModBool,
|
||||
"mul": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '*') },
|
||||
"ne": Ne,
|
||||
"partial": Partial,
|
||||
"pluralize": Pluralize,
|
||||
"readDir": ReadDir,
|
||||
"ref": Ref,
|
||||
"relURL": func(a string) template.HTML { return template.HTML(helpers.RelURL(a)) },
|
||||
"relref": RelRef,
|
||||
"replace": Replace,
|
||||
"safeCSS": SafeCSS,
|
||||
"safeHTML": SafeHTML,
|
||||
"safeJS": SafeJS,
|
||||
"safeURL": SafeURL,
|
||||
"sanitizeURL": helpers.SanitizeURL,
|
||||
"sanitizeurl": helpers.SanitizeURL,
|
||||
"seq": helpers.Seq,
|
||||
"shuffle": Shuffle,
|
||||
"singularize": Singularize,
|
||||
"slicestr": Slicestr,
|
||||
"sort": Sort,
|
||||
"split": Split,
|
||||
"string": func(v interface{}) string { return cast.ToString(v) },
|
||||
"sub": func(a, b interface{}) (interface{}, error) { return doArithmetic(a, b, '-') },
|
||||
"substr": Substr,
|
||||
"title": func(a string) string { return strings.Title(a) },
|
||||
"trim": Trim,
|
||||
"upper": func(a string) string { return strings.ToUpper(a) },
|
||||
"urlize": helpers.URLize,
|
||||
"where": Where,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import (
|
|||
"errors"
|
||||
"fmt"
|
||||
"github.com/spf13/cast"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"html/template"
|
||||
"math/rand"
|
||||
"path"
|
||||
|
|
@ -26,8 +27,6 @@ import (
|
|||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
type tstNoStringer struct {
|
||||
|
|
@ -70,7 +69,6 @@ func TestCompare(t *testing.T) {
|
|||
} {
|
||||
doTestCompare(t, this.tstCompareType, this.funcUnderTest)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func doTestCompare(t *testing.T, tp tstCompareType, funcUnderTest func(a, b interface{}) bool) {
|
||||
|
|
@ -490,7 +488,6 @@ func TestSlicestr(t *testing.T) {
|
|||
{tstNoStringer{}, 0, 1, false},
|
||||
{"ĀĀĀ", 0, 1, "Ā"}, // issue #1333
|
||||
} {
|
||||
|
||||
var result string
|
||||
if this.v2 == nil {
|
||||
result, err = Slicestr(this.v1)
|
||||
|
|
@ -618,7 +615,6 @@ func TestSplit(t *testing.T) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestIntersect(t *testing.T) {
|
||||
|
|
@ -1456,7 +1452,6 @@ func TestReturnWhenSet(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestMarkdownify(t *testing.T) {
|
||||
|
||||
result := Markdownify("Hello **World!**")
|
||||
|
||||
expect := template.HTML("Hello <strong>World!</strong>")
|
||||
|
|
@ -1470,8 +1465,6 @@ func TestApply(t *testing.T) {
|
|||
strings := []interface{}{"a\n", "b\n"}
|
||||
noStringers := []interface{}{tstNoStringer{}, tstNoStringer{}}
|
||||
|
||||
var nilErr *error = nil
|
||||
|
||||
chomped, _ := Apply(strings, "chomp", ".")
|
||||
assert.Equal(t, []interface{}{"a", "b"}, chomped)
|
||||
|
||||
|
|
@ -1486,6 +1479,7 @@ func TestApply(t *testing.T) {
|
|||
t.Errorf("apply with apply should fail")
|
||||
}
|
||||
|
||||
var nilErr *error
|
||||
_, err = Apply(nilErr, "chomp", ".")
|
||||
if err == nil {
|
||||
t.Errorf("apply with nil in seq should fail")
|
||||
|
|
@ -1505,7 +1499,6 @@ func TestApply(t *testing.T) {
|
|||
if err == nil {
|
||||
t.Errorf("apply with non-sequence should fail")
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestChomp(t *testing.T) {
|
||||
|
|
@ -1529,6 +1522,22 @@ func TestChomp(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestHumanize(t *testing.T) {
|
||||
for _, e := range []struct {
|
||||
in, exp string
|
||||
}{
|
||||
{"MyCamelPost", "My camel post"},
|
||||
{"myLowerCamelPost", "My lower camel post"},
|
||||
{"my-dash-post", "My dash post"},
|
||||
{"my_underscore_post", "My underscore post"},
|
||||
{"posts/my-first-post", "Posts/my first post"},
|
||||
} {
|
||||
res, err := Humanize(e.in)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, e.exp, res)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplace(t *testing.T) {
|
||||
v, _ := Replace("aab", "a", "b")
|
||||
assert.Equal(t, "bbb", v)
|
||||
|
|
|
|||
Loading…
Reference in a new issue