-
Notifications
You must be signed in to change notification settings - Fork 0
/
verbeage.go
142 lines (118 loc) · 3.07 KB
/
verbeage.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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package verbeage
import (
"bytes"
_ "embed"
"encoding/json"
"html/template"
"github.com/zaptross/countula/internal/utils"
)
type Verbeage struct {
Fail []Response `json:"fail"`
Count []Response `json:"count"`
Awaken []Response `json:"awaken"`
Rules []Response `json:"rules"`
Help []Response `json:"help"`
OnConfigure []Response `json:"on_configure"`
}
type Response struct {
Reply *string `json:"reply"`
Message *string `json:"message,omitempty"`
}
type ExecutableTemplate func(TemplateFields) (string, error)
type ResponseParts struct {
Reply ExecutableTemplate
Message ExecutableTemplate
}
type ResponseTemplate struct {
Fail []ResponseParts
Count []ResponseParts
Awaken []ResponseParts
Rules []ResponseParts
Help []ResponseParts
OnConfigure []ResponseParts
}
type TemplateFields struct {
Username string
}
//go:embed verbeage.json
var rawVerbeage string
var verbeage ResponseTemplate
func getVerbeage() Verbeage {
var v Verbeage
json.Unmarshal([]byte(rawVerbeage), &v)
return v
}
func loadTemplates() {
if verbeage.Fail != nil {
return
}
v := getVerbeage()
verbeage = ResponseTemplate{
Fail: []ResponseParts{},
Count: []ResponseParts{},
Awaken: []ResponseParts{},
Rules: []ResponseParts{},
Help: []ResponseParts{},
OnConfigure: []ResponseParts{},
}
for _, f := range v.Fail {
verbeage.Fail = append(verbeage.Fail, createResponseParts(f))
}
for _, c := range v.Count {
verbeage.Count = append(verbeage.Count, createResponseParts(c))
}
for _, a := range v.Awaken {
verbeage.Awaken = append(verbeage.Awaken, createResponseParts(a))
}
for _, r := range v.Rules {
verbeage.Rules = append(verbeage.Rules, createResponseParts(r))
}
for _, h := range v.Help {
verbeage.Help = append(verbeage.Help, createResponseParts(h))
}
for _, o := range v.OnConfigure {
verbeage.OnConfigure = append(verbeage.OnConfigure, createResponseParts(o))
}
}
func createExecutableTemplate(t string) ExecutableTemplate {
executableTemplate := template.Must(template.New("").Parse(t))
return func(tf TemplateFields) (string, error) {
var buf bytes.Buffer
err := executableTemplate.Execute(&buf, tf)
return buf.String(), err
}
}
func createResponseParts(r Response) ResponseParts {
rp := ResponseParts{}
if r.Reply != nil {
rp.Reply = createExecutableTemplate(*r.Reply)
}
if r.Message != nil {
rp.Message = createExecutableTemplate(*r.Message)
}
return rp
}
func GetRandomFail() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.Fail)
}
func GetRandomCount() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.Count)
}
func GetRandomAwaken() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.Awaken)
}
func GetRandomRuleMessage() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.Rules)
}
func GetRandomHelpMessage() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.Help)
}
func GetRandomOnConfigureMessage() ResponseParts {
loadTemplates()
return utils.RandFrom(verbeage.OnConfigure)
}