/
main.go
104 lines (85 loc) · 2.44 KB
/
main.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
package codegen
import (
"bytes"
"encoding/json"
"fmt"
"go/format"
"io/ioutil"
"os"
"path"
"regexp"
"strings"
"text/template"
)
func ParseTemplateFromString(templatePath string) *template.Template {
tmpl := template.New(path.Base(templatePath))
tmpl.Funcs(GetTemplateFuncMap())
tmpl, tmplErr := tmpl.Parse(templatePath)
if nil != tmplErr {
fmt.Println(tmplErr)
}
return tmpl
}
func ParseTemplateFromFile(templatePath string) *template.Template {
tmpl := template.New(path.Base(templatePath))
tmpl.Funcs(GetTemplateFuncMap())
tmpl, tmplErr := tmpl.Parse(templatePath)
if nil != tmplErr {
fmt.Println(tmplErr)
}
return tmpl
}
func ExecTemplate(template *template.Template, templateParameters interface{}) []byte {
templateOutput := &bytes.Buffer{}
err := template.Execute(templateOutput, templateParameters)
if nil != err {
fmt.Println(err)
}
formatedTemplate, formatErr := format.Source(templateOutput.Bytes())
var outputTemplate []byte
if nil != formatErr {
outputTemplate = templateOutput.Bytes()
fmt.Println(formatErr)
} else {
outputTemplate = formatedTemplate
}
return outputTemplate
}
func OutputTemplate(outputPath string, byteCode []byte) {
os.WriteFile(outputPath, byteCode, 0777)
}
var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
func To_snake_case(str string) string {
snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
return strings.ToLower(snake)
}
func GetTemplateFuncMap() template.FuncMap {
funcMap := template.FuncMap{
"ToLower": strings.ToLower,
"SnakeCase": To_snake_case,
}
return funcMap
}
func GenerateFromStringTemplate(templateString string, outputPath string, parameters interface{}) {
tmpl := ParseTemplateFromString(templateString)
generateByteCode := ExecTemplate(tmpl, parameters)
OutputTemplate(outputPath, generateByteCode)
}
func GenerateFromFileTemplate(templatePath string, outputPath string, parameters interface{}) {
tmpl := ParseTemplateFromFile(templatePath)
generateByteCode := ExecTemplate(tmpl, parameters)
OutputTemplate(outputPath, generateByteCode)
}
func SchemaFileToParameter(schemaFile string) interface{} {
jsonFile, err := os.Open(schemaFile)
if nil != err {
panic(err)
}
defer jsonFile.Close()
jsonString, _ := ioutil.ReadAll(jsonFile)
var parameters interface{}
json.Unmarshal(jsonString, ¶meters)
return parameters
}