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
175
176
177
178
179
180
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
View as plain text