"github.com/spf13/hugo/tpl/compare"
)
+var comp = compare.New()
+
// Sort returns a sorted sequence.
func (ns *Namespace) Sort(seq interface{}, args ...interface{}) (interface{}, error) {
if seq == nil {
if iv.IsValid() {
if jv.IsValid() {
// can only call Interface() on valid reflect Values
- return compare.Lt(iv.Interface(), jv.Interface())
+ return comp.Lt(iv.Interface(), jv.Interface())
}
// if j is invalid, test i against i's zero value
- return compare.Lt(iv.Interface(), reflect.Zero(iv.Type()))
+ return comp.Lt(iv.Interface(), reflect.Zero(iv.Type()))
}
if jv.IsValid() {
// if i is invalid, test j against j's zero value
- return compare.Lt(reflect.Zero(jv.Type()), jv.Interface())
+ return comp.Lt(reflect.Zero(jv.Type()), jv.Interface())
}
return false
"time"
)
+// New returns a new instance of the compare-namespaced template functions.
+func New() *Namespace {
+ return &Namespace{}
+}
+
+// Namespace provides template functions for the "compare" namespace.
+type Namespace struct {
+}
+
// Default checks whether a given value is set and returns a default value if it
// is not. "Set" in this context means non-zero for numeric types and times;
// non-zero length for strings, arrays, slices, and maps;
// any boolean or struct value; or non-nil for any other types.
-func Default(dflt interface{}, given ...interface{}) (interface{}, error) {
+func (*Namespace) Default(dflt interface{}, given ...interface{}) (interface{}, error) {
// given is variadic because the following construct will not pass a piped
// argument when the key is missing: {{ index . "key" | default "foo" }}
// The Go template will complain that we got 1 argument when we expectd 2.
}
// Eq returns the boolean truth of arg1 == arg2.
-func Eq(x, y interface{}) bool {
+func (*Namespace) Eq(x, y interface{}) bool {
normalize := func(v interface{}) interface{} {
vv := reflect.ValueOf(v)
switch vv.Kind() {
}
// Ne returns the boolean truth of arg1 != arg2.
-func Ne(x, y interface{}) bool {
- return !Eq(x, y)
+func (n *Namespace) Ne(x, y interface{}) bool {
+ return !n.Eq(x, y)
}
// Ge returns the boolean truth of arg1 >= arg2.
-func Ge(a, b interface{}) bool {
- left, right := compareGetFloat(a, b)
+func (n *Namespace) Ge(a, b interface{}) bool {
+ left, right := n.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)
+func (n *Namespace) Gt(a, b interface{}) bool {
+ left, right := n.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)
+func (n *Namespace) Le(a, b interface{}) bool {
+ left, right := n.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)
+func (n *Namespace) Lt(a, b interface{}) bool {
+ left, right := n.compareGetFloat(a, b)
return left < right
}
-func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
+func (*Namespace) compareGetFloat(a interface{}, b interface{}) (float64, float64) {
var left, right float64
var leftStr, rightStr *string
av := reflect.ValueOf(a)
then := time.Now()
now := time.Now()
+ ns := New()
for i, test := range []struct {
dflt interface{}
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
- result, err := Default(test.dflt, test.given)
+ result, err := ns.Default(test.dflt, test.given)
require.NoError(t, err, errMsg)
assert.Equal(t, result, test.expect, errMsg)
func TestCompare(t *testing.T) {
t.Parallel()
+ n := New()
+
for _, test := range []struct {
tstCompareType
funcUnderTest func(a, b interface{}) bool
}{
- {tstGt, Gt},
- {tstLt, Lt},
- {tstGe, Ge},
- {tstLe, Le},
- {tstEq, Eq},
- {tstNe, Ne},
+ {tstGt, n.Gt},
+ {tstLt, n.Lt},
+ {tstGe, n.Ge},
+ {tstLe, n.Le},
+ {tstEq, n.Eq},
+ {tstNe, n.Ne},
} {
doTestCompare(t, test.tstCompareType, test.funcUnderTest)
}
--- /dev/null
+// 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 compare
+
+import (
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/tpl/internal"
+)
+
+const name = "compare"
+
+func init() {
+ f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
+ ctx := New()
+
+ examples := [][2]string{
+ {`eq: {{ if eq .Section "blog" }}current{{ end }}`, `eq: current`},
+ }
+
+ return &internal.TemplateFuncsNamespace{
+ Name: name,
+ Context: func() interface{} { return ctx },
+ Aliases: map[string]interface{}{
+ "default": ctx.Default,
+ "eq": ctx.Eq,
+ "ge": ctx.Ge,
+ "gt": ctx.Gt,
+ "le": ctx.Le,
+ "lt": ctx.Lt,
+ "ne": ctx.Ne,
+ },
+ Examples: examples,
+ }
+
+ }
+
+ internal.AddTemplateFuncsNamespace(f)
+}
"sync"
"github.com/spf13/cast"
- "github.com/spf13/hugo/tpl/compare"
"github.com/spf13/hugo/tpl/internal"
// Init the namespaces
+ _ "github.com/spf13/hugo/tpl/compare"
_ "github.com/spf13/hugo/tpl/data"
_ "github.com/spf13/hugo/tpl/lang"
_ "github.com/spf13/hugo/tpl/math"
"apply": t.collections.Apply,
"base64Decode": t.encoding.Base64Decode,
"base64Encode": t.encoding.Base64Encode,
- "default": compare.Default,
"dateFormat": t.time.Format,
"delimit": t.collections.Delimit,
"dict": t.collections.Dictionary,
"echoParam": t.collections.EchoParam,
"emojify": t.transform.Emojify,
- "eq": compare.Eq,
"first": t.collections.First,
- "ge": compare.Ge,
"getenv": t.os.Getenv,
- "gt": compare.Gt,
"highlight": t.transform.Highlight,
"htmlEscape": t.transform.HTMLEscape,
"htmlUnescape": t.transform.HTMLUnescape,
"isset": t.collections.IsSet,
"jsonify": t.encoding.Jsonify,
"last": t.collections.Last,
- "le": compare.Le,
- "lt": compare.Lt,
"markdownify": t.transform.Markdownify,
"md5": t.crypto.MD5,
- "ne": compare.Ne,
"now": t.time.Now,
"partial": t.partial,
"partialCached": t.partialCached,
delimit: {{ delimit (slice "A" "B" "C") ", " " and " }}
echoParam: {{ echoParam .Params "langCode" }}
emojify: {{ "I :heart: Hugo" | emojify }}
-eq: {{ if eq .Section "blog" }}current{{ end }}
htmlEscape 1: {{ htmlEscape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | safeHTML}}
htmlEscape 2: {{ htmlEscape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>"}}
htmlUnescape 1: {{htmlUnescape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | safeHTML}}
delimit: A, B and C
echoParam: en
emojify: I ❤️ Hugo
-eq: current
htmlEscape 1: Cathal Garvey & The Sunshine Band <cathal@foo.bar>
htmlEscape 2: Cathal Garvey &amp; The Sunshine Band &lt;cathal@foo.bar&gt;
htmlUnescape 1: Cathal Garvey & The Sunshine Band <cathal@foo.bar>
projects / brevno-suite / hugo / commitdiff