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)
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")
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() {
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()
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()
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) {
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
}
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 {
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
}
}
+// 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)
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")
}
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")
}
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")
}
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")
}
}
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)
}
}
-// 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
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 {
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)
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)
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 {
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)
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)
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 {
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) {
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")
}
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
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
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
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)
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 {
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)
return string(dec), nil
}
+// Base64Encode returns the base64 encoding of the given content.
func Base64Encode(content interface{}) (string, error) {
conv, err := cast.ToStringE(content)
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)
return counter, nil
}
+// CountRunes returns the approximate rune count of the given content.
func CountRunes(content interface{}) (int, error) {
conv, err := cast.ToStringE(content)
return counter, nil
}
+// 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 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{
- "urlize": helpers.URLize,
- "sanitizeURL": helpers.SanitizeURL,
- "sanitizeurl": helpers.SanitizeURL,
+ "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,
- "ne": Ne,
- "gt": Gt,
+ "first": First,
"ge": Ge,
- "lt": Lt,
- "le": Le,
- "dict": Dictionary,
+ "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,
- "slicestr": Slicestr,
- "substr": Substr,
- "split": Split,
+ "int": func(v interface{}) int { return cast.ToInt(v) },
"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, '/') },
+ "le": Le,
+ "lower": func(a string) string { return strings.ToLower(a) },
+ "lt": Lt,
+ "markdownify": Markdownify,
"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) },
+ "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,
- "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,
+ "safeCSS": SafeCSS,
+ "safeHTML": SafeHTML,
+ "safeJS": SafeJS,
+ "safeURL": SafeURL,
+ "sanitizeURL": helpers.SanitizeURL,
+ "sanitizeurl": helpers.SanitizeURL,
"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) {
- word, err := cast.ToStringE(in)
- if err != nil {
- return "", err
- }
- return inflect.Pluralize(word), nil
- },
- "singularize": func(in interface{}) (string, error) {
- word, err := cast.ToStringE(in)
- if err != nil {
- return "", err
- }
- return inflect.Singularize(word), nil
- },
+ "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,
}
}
projects / brevno-suite / hugo / commitdiff