Debian Codegraph @

pkg/format/node.go

raw
1 package format
2
3 import (
4 "fmt"
5 "reflect"
6 "sort"
7 "strconv"
8 "strings"
9
10 "github.com/nicholas-fedor/shoutrrr/pkg/types"
11 "github.com/nicholas-fedor/shoutrrr/pkg/util"
12 )
13
14 // Node is the generic config tree item.
15 type Node interface {
16 Field() *FieldInfo
17 TokenType() NodeTokenType
18 Update(tv reflect.Value)
19 }
20
21 // NodeTokenType is used to represent the type of value that a node has for syntax highlighting.
22 type NodeTokenType int
23
24 // ContainerNode is a Node with child items.
25 type ContainerNode struct {
26 *FieldInfo
27
28 Items []Node
29 MaxKeyLength int
30 }
31
32 // ValueNode is a Node without any child items.
33 type ValueNode struct {
34 *FieldInfo
35
36 Value string
37 tokenType NodeTokenType
38 }
39
40 const (
41 // UnknownToken represents all unknown/unspecified tokens.
42 UnknownToken NodeTokenType = iota
43 // NumberToken represents all numbers.
44 NumberToken
45 // StringToken represents strings and keys.
46 StringToken
47 // EnumToken represents enum values.
48 EnumToken
49 // TrueToken represent boolean true.
50 TrueToken
51 // FalseToken represent boolean false.
52 FalseToken
53 // PropToken represent a serializable struct prop.
54 PropToken
55 // ErrorToken represent a value that was not serializable or otherwise invalid.
56 ErrorToken
57 // ContainerToken is used for Array/Slice and Map tokens.
58 ContainerToken
59 )
60
61 // Constants for number bases.
62 const (
63 BaseDecimalLen = 10
64 BaseHexLen = 16
65 )
66
67 // Field returns the inner FieldInfo.
68 func (n *ValueNode) Field() *FieldInfo {
69 return n.FieldInfo
70 }
71
72 // TokenType returns a NodeTokenType that matches the value.
73 func (n *ValueNode) TokenType() NodeTokenType {
74 return n.tokenType
75 }
76
77 // Update updates the value string from the provided value.
78 func (n *ValueNode) Update(tv reflect.Value) {
79 value, token := getValueNodeValue(tv, n.FieldInfo)
80 n.Value = value
81 n.tokenType = token
82 }
83
84 // Field returns the inner FieldInfo.
85 func (n *ContainerNode) Field() *FieldInfo {
86 return n.FieldInfo
87 }
88
89 // TokenType always returns ContainerToken for ContainerNode.
90 func (n *ContainerNode) TokenType() NodeTokenType {
91 return ContainerToken
92 }
93
94 // Update updates the items to match the provided value.
95 func (n *ContainerNode) Update(tv reflect.Value) {
96 switch n.Type.Kind() {
97 case reflect.Array, reflect.Slice:
98 n.updateArrayNode(tv)
99 case reflect.Map:
100 n.updateMapNode(tv)
101 case reflect.Invalid,
102 reflect.Bool,
103 reflect.Int,
104 reflect.Int8,
105 reflect.Int16,
106 reflect.Int32,
107 reflect.Int64,
108 reflect.Uint,
109 reflect.Uint8,
110 reflect.Uint16,
111 reflect.Uint32,
112 reflect.Uint64,
113 reflect.Uintptr,
114 reflect.Float32,
115 reflect.Float64,
116 reflect.Complex64,
117 reflect.Complex128,
118 reflect.Chan,
119 reflect.Func,
120 reflect.Interface,
121 reflect.Pointer,
122 reflect.String,
123 reflect.Struct,
124 reflect.UnsafePointer:
125 // No-op for unsupported kinds
126 default:
127 // No-op for any remaining kinds
128 }
129 }
130
131 func (n *ContainerNode) updateArrayNode(arrayValue reflect.Value) {
132 itemCount := arrayValue.Len()
133 n.Items = make([]Node, 0, itemCount)
134
135 elemType := arrayValue.Type().Elem()
136
137 for i := range itemCount {
138 key := strconv.Itoa(i)
139 val := arrayValue.Index(i)
140 n.Items = append(n.Items, getValueNode(val, &FieldInfo{
141 Name: key,
142 Type: elemType,
143 EnumFormatter: nil,
144 Description: "",
145 DefaultValue: "",
146 Template: "",
147 Required: false,
148 URLParts: nil,
149 Title: false,
150 Base: 0,
151 Keys: nil,
152 ItemSeparator: 0,
153 }))
154 }
155 }
156
157 func getArrayNode(arrayValue reflect.Value, fieldInfo *FieldInfo) *ContainerNode {
158 node := &ContainerNode{
159 FieldInfo: fieldInfo,
160 Items: nil,
161 MaxKeyLength: 0,
162 }
163 node.updateArrayNode(arrayValue)
164
165 return node
166 }
167
168 func sortNodeItems(nodeItems []Node) {
169 sort.Slice(nodeItems, func(i, j int) bool {
170 return nodeItems[i].Field().Name < nodeItems[j].Field().Name
171 })
172 }
173
174 func (n *ContainerNode) updateMapNode(mapValue reflect.Value) {
175 base := n.Base
176 if base == 0 {
177 base = BaseDecimalLen
178 }
179
180 elemType := mapValue.Type().Elem()
181 mapKeys := mapValue.MapKeys()
182 nodeItems := make([]Node, len(mapKeys))
183 maxKeyLength := 0
184
185 for i, keyVal := range mapKeys {
186 // The keys will always be strings
187 key := keyVal.String()
188 val := mapValue.MapIndex(keyVal)
189 nodeItems[i] = getValueNode(val, &FieldInfo{
190 Name: key,
191 Type: elemType,
192 EnumFormatter: nil,
193 Description: "",
194 DefaultValue: "",
195 Template: "",
196 Required: false,
197 URLParts: nil,
198 Title: false,
199 Base: base,
200 Keys: nil,
201 ItemSeparator: 0,
202 })
203 maxKeyLength = util.Max(len(key), maxKeyLength)
204 }
205
206 sortNodeItems(nodeItems)
207
208 n.Items = nodeItems
209 n.MaxKeyLength = maxKeyLength
210 }
211
212 func getMapNode(mapValue reflect.Value, fieldInfo *FieldInfo) *ContainerNode {
213 if mapValue.Kind() == reflect.Pointer {
214 mapValue = mapValue.Elem()
215 }
216
217 node := &ContainerNode{
218 FieldInfo: fieldInfo,
219 Items: nil,
220 MaxKeyLength: 0,
221 }
222 node.updateMapNode(mapValue)
223
224 return node
225 }
226
227 func getNode(fieldVal reflect.Value, fieldInfo *FieldInfo) Node {
228 switch fieldInfo.Type.Kind() {
229 case reflect.Array, reflect.Slice:
230 return getArrayNode(fieldVal, fieldInfo)
231 case reflect.Map:
232 return getMapNode(fieldVal, fieldInfo)
233 case reflect.Invalid,
234 reflect.Bool,
235 reflect.Int,
236 reflect.Int8,
237 reflect.Int16,
238 reflect.Int32,
239 reflect.Int64,
240 reflect.Uint,
241 reflect.Uint8,
242 reflect.Uint16,
243 reflect.Uint32,
244 reflect.Uint64,
245 reflect.Uintptr,
246 reflect.Float32,
247 reflect.Float64,
248 reflect.Complex64,
249 reflect.Complex128,
250 reflect.Chan,
251 reflect.Func,
252 reflect.Interface,
253 reflect.Pointer,
254 reflect.String,
255 reflect.Struct,
256 reflect.UnsafePointer:
257 return getValueNode(fieldVal, fieldInfo)
258 default:
259 return getValueNode(fieldVal, fieldInfo)
260 }
261 }
262
263 func getRootNode(value any) *ContainerNode {
264 structValue := reflect.ValueOf(value)
265 if structValue.Kind() == reflect.Pointer {
266 structValue = structValue.Elem()
267 }
268
269 structType := structValue.Type()
270
271 enums := map[string]types.EnumFormatter{}
272 if enummer, isEnummer := value.(types.Enummer); isEnummer {
273 enums = enummer.Enums()
274 }
275
276 infoFields := getStructFieldInfo(structType, enums)
277 nodeItems := make([]Node, 0, len(infoFields))
278 maxKeyLength := 0
279
280 for i := range infoFields {
281 fieldValue := structValue.FieldByName(infoFields[i].Name)
282 if !fieldValue.IsValid() {
283 fieldValue = reflect.Zero(infoFields[i].Type)
284 }
285
286 nodeItems = append(nodeItems, getNode(fieldValue, &infoFields[i]))
287 maxKeyLength = util.Max(len(infoFields[i].Name), maxKeyLength)
288 }
289
290 sortNodeItems(nodeItems)
291
292 return &ContainerNode{
293 FieldInfo: &FieldInfo{
294 Name: "",
295 Type: structType,
296 EnumFormatter: nil,
297 Description: "",
298 DefaultValue: "",
299 Template: "",
300 Required: false,
301 URLParts: nil,
302 Title: false,
303 Base: 0,
304 Keys: nil,
305 ItemSeparator: 0,
306 },
307 Items: nodeItems,
308 MaxKeyLength: maxKeyLength,
309 }
310 }
311
312 func getValueNode(fieldVal reflect.Value, fieldInfo *FieldInfo) *ValueNode {
313 value, tokenType := getValueNodeValue(fieldVal, fieldInfo)
314
315 return &ValueNode{
316 FieldInfo: fieldInfo,
317 Value: value,
318 tokenType: tokenType,
319 }
320 }
321
322 func getValueNodeValue(fieldValue reflect.Value, fieldInfo *FieldInfo) (string, NodeTokenType) {
323 kind := fieldValue.Kind()
324
325 base := fieldInfo.Base
326 if base == 0 {
327 base = BaseDecimalLen
328 }
329
330 if fieldInfo.IsEnum() {
331 return fieldInfo.EnumFormatter.Print(int(fieldValue.Int())), EnumToken
332 }
333
334 switch kind {
335 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
336 val := strconv.FormatUint(fieldValue.Uint(), base)
337 if base == BaseHexLen {
338 val = "0x" + val
339 }
340
341 return val, NumberToken
342 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
343 return strconv.FormatInt(fieldValue.Int(), base), NumberToken
344 case reflect.String:
345 return fieldValue.String(), StringToken
346 case reflect.Bool:
347 val := fieldValue.Bool()
348 if val {
349 return PrintBool(val), TrueToken
350 }
351
352 return PrintBool(val), FalseToken
353 case reflect.Array, reflect.Slice, reflect.Map:
354 return getContainerValueString(fieldValue, fieldInfo), UnknownToken
355 case reflect.Pointer, reflect.Struct:
356 if val, err := GetConfigPropString(fieldValue); err == nil {
357 return val, PropToken
358 }
359
360 return "<ERR>", ErrorToken
361 case reflect.Invalid,
362 reflect.Uintptr,
363 reflect.Float32,
364 reflect.Float64,
365 reflect.Complex64,
366 reflect.Complex128,
367 reflect.Chan,
368 reflect.Func,
369 reflect.Interface,
370 reflect.UnsafePointer:
371 return fmt.Sprintf("<?%s>", kind.String()), UnknownToken
372 default:
373 return fmt.Sprintf("<?%s>", kind.String()), UnknownToken
374 }
375 }
376
377 func getContainerValueString(fieldValue reflect.Value, fieldInfo *FieldInfo) string {
378 itemSeparator := fieldInfo.ItemSeparator
379 sliceLength := fieldValue.Len()
380
381 var mapKeys []reflect.Value
382 if fieldInfo.Type.Kind() == reflect.Map {
383 mapKeys = fieldValue.MapKeys()
384 sort.Slice(mapKeys, func(a, b int) bool {
385 return mapKeys[a].String() < mapKeys[b].String()
386 })
387 }
388
389 stringBuilder := strings.Builder{}
390
391 var itemFieldInfo *FieldInfo
392
393 for i := range sliceLength {
394 var itemValue reflect.Value
395
396 if i > 0 {
397 stringBuilder.WriteRune(itemSeparator)
398 }
399
400 if mapKeys != nil {
401 mapKey := mapKeys[i]
402 stringBuilder.WriteString(mapKey.String())
403 stringBuilder.WriteRune(':')
404
405 itemValue = fieldValue.MapIndex(mapKey)
406 } else {
407 itemValue = fieldValue.Index(i)
408 }
409
410 if i == 0 {
411 itemFieldInfo = &FieldInfo{
412 Name: "",
413 Type: itemValue.Type(),
414 EnumFormatter: nil,
415 Description: "",
416 DefaultValue: "",
417 Template: "",
418 Required: false,
419 URLParts: nil,
420 Title: false,
421 // Inherit the base from the container
422 Base: fieldInfo.Base,
423 Keys: nil,
424 ItemSeparator: 0,
425 }
426
427 if itemFieldInfo.Base == 0 {
428 itemFieldInfo.Base = BaseDecimalLen
429 }
430 }
431
432 strVal, _ := getValueNodeValue(itemValue, itemFieldInfo)
433 stringBuilder.WriteString(strVal)
434 }
435
436 return stringBuilder.String()
437 }