podman

1
package sprig
2

3
import (
4
	"encoding/base32"
5
	"encoding/base64"
6
	"fmt"
7
	"reflect"
8
	"strconv"
9
	"strings"
10
)
11

12
func base64encode(v string) string {
13
	return base64.StdEncoding.EncodeToString([]byte(v))
14
}
15

16
func base64decode(v string) string {
17
	data, err := base64.StdEncoding.DecodeString(v)
18
	if err != nil {
19
		return err.Error()
20
	}
21
	return string(data)
22
}
23

24
func base32encode(v string) string {
25
	return base32.StdEncoding.EncodeToString([]byte(v))
26
}
27

28
func base32decode(v string) string {
29
	data, err := base32.StdEncoding.DecodeString(v)
30
	if err != nil {
31
		return err.Error()
32
	}
33
	return string(data)
34
}
35

36
func quote(str ...interface{}) string {
37
	out := make([]string, 0, len(str))
38
	for _, s := range str {
39
		if s != nil {
40
			out = append(out, fmt.Sprintf("%q", strval(s)))
41
		}
42
	}
43
	return strings.Join(out, " ")
44
}
45

46
func squote(str ...interface{}) string {
47
	out := make([]string, 0, len(str))
48
	for _, s := range str {
49
		if s != nil {
50
			out = append(out, fmt.Sprintf("'%v'", s))
51
		}
52
	}
53
	return strings.Join(out, " ")
54
}
55

56
func cat(v ...interface{}) string {
57
	v = removeNilElements(v)
58
	r := strings.TrimSpace(strings.Repeat("%v ", len(v)))
59
	return fmt.Sprintf(r, v...)
60
}
61

62
func indent(spaces int, v string) string {
63
	pad := strings.Repeat(" ", spaces)
64
	return pad + strings.Replace(v, "\n", "\n"+pad, -1)
65
}
66

67
func nindent(spaces int, v string) string {
68
	return "\n" + indent(spaces, v)
69
}
70

71
func replace(old, new, src string) string {
72
	return strings.Replace(src, old, new, -1)
73
}
74

75
func plural(one, many string, count int) string {
76
	if count == 1 {
77
		return one
78
	}
79
	return many
80
}
81

82
func strslice(v interface{}) []string {
83
	switch v := v.(type) {
84
	case []string:
85
		return v
86
	case []interface{}:
87
		b := make([]string, 0, len(v))
88
		for _, s := range v {
89
			if s != nil {
90
				b = append(b, strval(s))
91
			}
92
		}
93
		return b
94
	default:
95
		val := reflect.ValueOf(v)
96
		switch val.Kind() {
97
		case reflect.Array, reflect.Slice:
98
			l := val.Len()
99
			b := make([]string, 0, l)
100
			for i := 0; i < l; i++ {
101
				value := val.Index(i).Interface()
102
				if value != nil {
103
					b = append(b, strval(value))
104
				}
105
			}
106
			return b
107
		default:
108
			if v == nil {
109
				return []string{}
110
			}
111

112
			return []string{strval(v)}
113
		}
114
	}
115
}
116

117
func removeNilElements(v []interface{}) []interface{} {
118
	newSlice := make([]interface{}, 0, len(v))
119
	for _, i := range v {
120
		if i != nil {
121
			newSlice = append(newSlice, i)
122
		}
123
	}
124
	return newSlice
125
}
126

127
func strval(v interface{}) string {
128
	switch v := v.(type) {
129
	case string:
130
		return v
131
	case []byte:
132
		return string(v)
133
	case error:
134
		return v.Error()
135
	case fmt.Stringer:
136
		return v.String()
137
	default:
138
		return fmt.Sprintf("%v", v)
139
	}
140
}
141

142
func trunc(c int, s string) string {
143
	if c < 0 && len(s)+c > 0 {
144
		return s[len(s)+c:]
145
	}
146
	if c >= 0 && len(s) > c {
147
		return s[:c]
148
	}
149
	return s
150
}
151

152
func join(sep string, v interface{}) string {
153
	return strings.Join(strslice(v), sep)
154
}
155

156
func split(sep, orig string) map[string]string {
157
	parts := strings.Split(orig, sep)
158
	res := make(map[string]string, len(parts))
159
	for i, v := range parts {
160
		res["_"+strconv.Itoa(i)] = v
161
	}
162
	return res
163
}
164

165
func splitn(sep string, n int, orig string) map[string]string {
166
	parts := strings.SplitN(orig, sep, n)
167
	res := make(map[string]string, len(parts))
168
	for i, v := range parts {
169
		res["_"+strconv.Itoa(i)] = v
170
	}
171
	return res
172
}
173

174
// substring creates a substring of the given string.
175
//
176
// If start is < 0, this calls string[:end].
177
//
178
// If start is >= 0 and end < 0 or end bigger than s length, this calls string[start:]
179
//
180
// Otherwise, this calls string[start, end].
181
func substring(start, end int, s string) string {
182
	if start < 0 {
183
		return s[:end]
184
	}
185
	if end < 0 || end > len(s) {
186
		return s[start:]
187
	}
188
	return s[start:end]
189
}
190