1 files changed, 0 insertions, 464 deletions
diff --git a/vendor/github.com/Masterminds/sprig/v3/list.go b/vendor/github.com/Masterminds/sprig/v3/list.go
deleted file mode 100644
index ca0fbb789..000000000
--- a/vendor/github.com/Masterminds/sprig/v3/list.go
+++ /dev/null
@@ -1,464 +0,0 @@
-package sprig
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"sort"
-)
-
-// Reflection is used in these functions so that slices and arrays of strings,
-// ints, and other types not implementing []interface{} can be worked with.
-// For example, this is useful if you need to work on the output of regexs.
-
-func list(v ...interface{}) []interface{} {
-	return v
-}
-
-func push(list interface{}, v interface{}) []interface{} {
-	l, err := mustPush(list, v)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustPush(list interface{}, v interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		nl := make([]interface{}, l)
-		for i := 0; i < l; i++ {
-			nl[i] = l2.Index(i).Interface()
-		}
-
-		return append(nl, v), nil
-
-	default:
-		return nil, fmt.Errorf("Cannot push on type %s", tp)
-	}
-}
-
-func prepend(list interface{}, v interface{}) []interface{} {
-	l, err := mustPrepend(list, v)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustPrepend(list interface{}, v interface{}) ([]interface{}, error) {
-	//return append([]interface{}{v}, list...)
-
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		nl := make([]interface{}, l)
-		for i := 0; i < l; i++ {
-			nl[i] = l2.Index(i).Interface()
-		}
-
-		return append([]interface{}{v}, nl...), nil
-
-	default:
-		return nil, fmt.Errorf("Cannot prepend on type %s", tp)
-	}
-}
-
-func chunk(size int, list interface{}) [][]interface{} {
-	l, err := mustChunk(size, list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustChunk(size int, list interface{}) ([][]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-
-		cs := int(math.Floor(float64(l-1)/float64(size)) + 1)
-		nl := make([][]interface{}, cs)
-
-		for i := 0; i < cs; i++ {
-			clen := size
-			if i == cs-1 {
-				clen = int(math.Floor(math.Mod(float64(l), float64(size))))
-				if clen == 0 {
-					clen = size
-				}
-			}
-
-			nl[i] = make([]interface{}, clen)
-
-			for j := 0; j < clen; j++ {
-				ix := i*size + j
-				nl[i][j] = l2.Index(ix).Interface()
-			}
-		}
-
-		return nl, nil
-
-	default:
-		return nil, fmt.Errorf("Cannot chunk type %s", tp)
-	}
-}
-
-func last(list interface{}) interface{} {
-	l, err := mustLast(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustLast(list interface{}) (interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil, nil
-		}
-
-		return l2.Index(l - 1).Interface(), nil
-	default:
-		return nil, fmt.Errorf("Cannot find last on type %s", tp)
-	}
-}
-
-func first(list interface{}) interface{} {
-	l, err := mustFirst(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustFirst(list interface{}) (interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil, nil
-		}
-
-		return l2.Index(0).Interface(), nil
-	default:
-		return nil, fmt.Errorf("Cannot find first on type %s", tp)
-	}
-}
-
-func rest(list interface{}) []interface{} {
-	l, err := mustRest(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustRest(list interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil, nil
-		}
-
-		nl := make([]interface{}, l-1)
-		for i := 1; i < l; i++ {
-			nl[i-1] = l2.Index(i).Interface()
-		}
-
-		return nl, nil
-	default:
-		return nil, fmt.Errorf("Cannot find rest on type %s", tp)
-	}
-}
-
-func initial(list interface{}) []interface{} {
-	l, err := mustInitial(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustInitial(list interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil, nil
-		}
-
-		nl := make([]interface{}, l-1)
-		for i := 0; i < l-1; i++ {
-			nl[i] = l2.Index(i).Interface()
-		}
-
-		return nl, nil
-	default:
-		return nil, fmt.Errorf("Cannot find initial on type %s", tp)
-	}
-}
-
-func sortAlpha(list interface{}) []string {
-	k := reflect.Indirect(reflect.ValueOf(list)).Kind()
-	switch k {
-	case reflect.Slice, reflect.Array:
-		a := strslice(list)
-		s := sort.StringSlice(a)
-		s.Sort()
-		return s
-	}
-	return []string{strval(list)}
-}
-
-func reverse(v interface{}) []interface{} {
-	l, err := mustReverse(v)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustReverse(v interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(v).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(v)
-
-		l := l2.Len()
-		// We do not sort in place because the incoming array should not be altered.
-		nl := make([]interface{}, l)
-		for i := 0; i < l; i++ {
-			nl[l-i-1] = l2.Index(i).Interface()
-		}
-
-		return nl, nil
-	default:
-		return nil, fmt.Errorf("Cannot find reverse on type %s", tp)
-	}
-}
-
-func compact(list interface{}) []interface{} {
-	l, err := mustCompact(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustCompact(list interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		nl := []interface{}{}
-		var item interface{}
-		for i := 0; i < l; i++ {
-			item = l2.Index(i).Interface()
-			if !empty(item) {
-				nl = append(nl, item)
-			}
-		}
-
-		return nl, nil
-	default:
-		return nil, fmt.Errorf("Cannot compact on type %s", tp)
-	}
-}
-
-func uniq(list interface{}) []interface{} {
-	l, err := mustUniq(list)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustUniq(list interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		dest := []interface{}{}
-		var item interface{}
-		for i := 0; i < l; i++ {
-			item = l2.Index(i).Interface()
-			if !inList(dest, item) {
-				dest = append(dest, item)
-			}
-		}
-
-		return dest, nil
-	default:
-		return nil, fmt.Errorf("Cannot find uniq on type %s", tp)
-	}
-}
-
-func inList(haystack []interface{}, needle interface{}) bool {
-	for _, h := range haystack {
-		if reflect.DeepEqual(needle, h) {
-			return true
-		}
-	}
-	return false
-}
-
-func without(list interface{}, omit ...interface{}) []interface{} {
-	l, err := mustWithout(list, omit...)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustWithout(list interface{}, omit ...interface{}) ([]interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		res := []interface{}{}
-		var item interface{}
-		for i := 0; i < l; i++ {
-			item = l2.Index(i).Interface()
-			if !inList(omit, item) {
-				res = append(res, item)
-			}
-		}
-
-		return res, nil
-	default:
-		return nil, fmt.Errorf("Cannot find without on type %s", tp)
-	}
-}
-
-func has(needle interface{}, haystack interface{}) bool {
-	l, err := mustHas(needle, haystack)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustHas(needle interface{}, haystack interface{}) (bool, error) {
-	if haystack == nil {
-		return false, nil
-	}
-	tp := reflect.TypeOf(haystack).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(haystack)
-		var item interface{}
-		l := l2.Len()
-		for i := 0; i < l; i++ {
-			item = l2.Index(i).Interface()
-			if reflect.DeepEqual(needle, item) {
-				return true, nil
-			}
-		}
-
-		return false, nil
-	default:
-		return false, fmt.Errorf("Cannot find has on type %s", tp)
-	}
-}
-
-// $list := [1, 2, 3, 4, 5]
-// slice $list     -> list[0:5] = list[:]
-// slice $list 0 3 -> list[0:3] = list[:3]
-// slice $list 3 5 -> list[3:5]
-// slice $list 3   -> list[3:5] = list[3:]
-func slice(list interface{}, indices ...interface{}) interface{} {
-	l, err := mustSlice(list, indices...)
-	if err != nil {
-		panic(err)
-	}
-
-	return l
-}
-
-func mustSlice(list interface{}, indices ...interface{}) (interface{}, error) {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil, nil
-		}
-
-		var start, end int
-		if len(indices) > 0 {
-			start = toInt(indices[0])
-		}
-		if len(indices) < 2 {
-			end = l
-		} else {
-			end = toInt(indices[1])
-		}
-
-		return l2.Slice(start, end).Interface(), nil
-	default:
-		return nil, fmt.Errorf("list should be type of slice or array but %s", tp)
-	}
-}
-
-func concat(lists ...interface{}) interface{} {
-	var res []interface{}
-	for _, list := range lists {
-		tp := reflect.TypeOf(list).Kind()
-		switch tp {
-		case reflect.Slice, reflect.Array:
-			l2 := reflect.ValueOf(list)
-			for i := 0; i < l2.Len(); i++ {
-				res = append(res, l2.Index(i).Interface())
-			}
-		default:
-			panic(fmt.Sprintf("Cannot concat type %s as list", tp))
-		}
-	}
-	return res
-}