/
flags.go
114 lines (107 loc) · 2.34 KB
/
flags.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package main
import (
"encoding/json"
"io"
"io/fs"
"log"
"regexp"
"strings"
)
type flagInfo struct {
Country string `json:"country"`
Image string `json:"image"`
Description string `json:"description"`
Keywords []string `json:"keywords"`
}
func reduceResult(files fs.FS, input string) (success bool, result []flagInfo) {
flags, flagKeywords, err := reduceFlags(files)
if err != nil {
success = true
return
}
input = strings.TrimSpace(input)
input = strings.ToLower(input)
input = strings.ReplaceAll(input, "-", " ")
input = regexp.MustCompile(`/[^a-z0-9]/g`).ReplaceAllString(input, "")
terms := strings.Split(input, " ")
terms = unique(terms)
terms = intersects(flagKeywords, terms)
terms = unique(terms)
if len(terms) == 0 {
success = false
return
}
for _, flag := range flags {
includes := true
for _, term := range terms {
if !contains(flag.Keywords, term) {
includes = false
}
}
if includes {
result = append(result, flag)
}
}
success = true
return
}
func unique(input []string) (output []string) {
if len(input) == 0 {
return input
}
for _, key := range input {
if !contains(output, key) {
output = append(output, key)
}
}
return output
}
func contains(input []string, key string) bool {
for _, k := range input {
if k == key {
return true
}
}
return false
}
func intersects(u1 []string, u2 []string) (output []string) {
if len(u1) > len(u2) {
for _, t := range u1 {
if contains(u2, t) {
output = append(output, t)
}
}
} else {
for _, t := range u2 {
if contains(u1, t) {
output = append(output, t)
}
}
}
return output
}
func reduceFlags(files fs.FS) ([]flagInfo, []string, error) {
flags := make([]flagInfo, 0)
flagKeywords := make([]string, 0)
file, err := files.Open("flags.json")
if err != nil {
log.Printf("Unable to open flags.json: %s", err)
return flags, flagKeywords, err
}
flagBytes, err := io.ReadAll(file)
if err != nil {
log.Printf("Unable to read flags.json: %s", err)
return flags, flagKeywords, err
}
err = json.Unmarshal(flagBytes, &flags)
if err != nil {
log.Printf("Unable to unmarshall flags.json: %s", err)
return flags, flagKeywords, err
}
for _, flag := range flags {
for _, flagKeyword := range flag.Keywords {
flagKeywords = append(flagKeywords, flagKeyword)
}
}
return flags, flagKeywords, nil
}