Change to variadic int args in Slicestr

Makes for a better template api.

diff --git a/tpl/template.go b/tpl/template.go
index 89c522a4f3e936cbff58e70df3d9c630510765ce..c94f657250ff286a7c24c7885cf676a002115315 100644 (file)
--- a/tpl/template.go
+++ b/tpl/template.go
@@ -190,22 +190,23 @@ func compareGetFloat(a interface{}, b interface{}) (float64, float64) {
 
 // Slicing in Slicestr is done by specifying a half-open range with
 // two indices, start and end. 1 and 4 creates a slice including elements 1 through 3.
-// The start and/or end indices can be omitted by setting one or both of them to -1;
-// they default to zero and the slice's length respectively
-func Slicestr(a interface{}, start, end int) (string, error) {
+// The end index can be omitted, it defaults to the string's length.
+func Slicestr(a interface{}, startEnd ...int) (string, error) {
        aStr, err := cast.ToStringE(a)
        if err != nil {
                return "", err
        }
 
-       if start != -1 && end != -1 {
-               return aStr[start:end], nil
-       } else if start == -1 && end == -1 {
-               return aStr[:], nil
-       } else if start == -1 {
-               return aStr[:end], nil
+       if len(startEnd) > 2 {
+               return "", errors.New("too many arguments")
+       }
+
+       if len(startEnd) == 2 {
+               return aStr[startEnd[0]:startEnd[1]], nil
+       } else if len(startEnd) == 1 {
+               return aStr[startEnd[0]:], nil
        } else {
-               return aStr[start:], nil
+               return aStr[:], nil
        }
 
 }

diff --git a/tpl/template_test.go b/tpl/template_test.go
index b3764e7373ae9321c1a86194b45cf851851ad79c..20a887b1cb71370a4c83b20a4dcc7b07eeccab94 100644 (file)
--- a/tpl/template_test.go
+++ b/tpl/template_test.go
@@ -279,20 +279,21 @@ func TestIn(t *testing.T) {
 func TestSlicestr(t *testing.T) {
        for i, this := range []struct {
                v1     interface{}
-               v2     int
-               v3     int
+               v2     []int
                expect interface{}
        }{
-               {"abc", 1, 2, "b"},
-               {"abc", 1, 3, "bc"},
-               {"abc", 0, 1, "a"},
-               {"abcdef", -1, -1, "abcdef"},
-               {"abcdef", -1, 2, "ab"},
-               {"abcdef", 2, -1, "cdef"},
-               {123, 1, 3, "23"},
-               {tstNoStringer{}, 0, 1, false},
+               {"abc", []int{1, 2}, "b"},
+               {"abc", []int{1, 3}, "bc"},
+               {"abc", []int{0, 1}, "a"},
+               {"abcdef", []int{}, "abcdef"},
+               {"abcdef", []int{0, 6}, "abcdef"},
+               {"abcdef", []int{0, 2}, "ab"},
+               {"abcdef", []int{2}, "cdef"},
+               {123, []int{1, 3}, "23"},
+               {123, []int{1, 2, 3}, false},
+               {tstNoStringer{}, []int{0, 1}, false},
        } {
-               result, err := Slicestr(this.v1, this.v2, this.v3)
+               result, err := Slicestr(this.v1, this.v2...)
 
                if b, ok := this.expect.(bool); ok && !b {
                        if err == nil {