418 lines
11 KiB
Go
418 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"cmp"
|
|
"maps"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"text/template"
|
|
|
|
core "dappco.re/go/core"
|
|
coreio "dappco.re/go/core/io"
|
|
)
|
|
|
|
// typeGrouping maps type name prefixes to output file names.
|
|
var typeGrouping = map[string]string{
|
|
"Repository": "repo",
|
|
"Repo": "repo",
|
|
"Issue": "issue",
|
|
"PullRequest": "pr",
|
|
"Pull": "pr",
|
|
"User": "user",
|
|
"Organization": "org",
|
|
"Org": "org",
|
|
"Team": "team",
|
|
"Label": "label",
|
|
"Milestone": "milestone",
|
|
"Release": "release",
|
|
"Tag": "tag",
|
|
"Branch": "branch",
|
|
"Hook": "hook",
|
|
"Deploy": "key",
|
|
"PublicKey": "key",
|
|
"GPGKey": "key",
|
|
"Key": "key",
|
|
"Notification": "notification",
|
|
"Package": "package",
|
|
"Action": "action",
|
|
"Commit": "commit",
|
|
"Git": "git",
|
|
"Contents": "content",
|
|
"File": "content",
|
|
"Wiki": "wiki",
|
|
"Comment": "comment",
|
|
"Review": "review",
|
|
"Reaction": "reaction",
|
|
"Topic": "topic",
|
|
"Status": "status",
|
|
"Combined": "status",
|
|
"Cron": "admin",
|
|
"Quota": "quota",
|
|
"OAuth2": "oauth",
|
|
"AccessToken": "oauth",
|
|
"API": "error",
|
|
"Forbidden": "error",
|
|
"NotFound": "error",
|
|
"NodeInfo": "federation",
|
|
"Activity": "activity",
|
|
"Feed": "activity",
|
|
"StopWatch": "time_tracking",
|
|
"TrackedTime": "time_tracking",
|
|
"Blocked": "user",
|
|
"Email": "user",
|
|
"Settings": "settings",
|
|
"GeneralAPI": "settings",
|
|
"GeneralAttachment": "settings",
|
|
"GeneralRepo": "settings",
|
|
"GeneralUI": "settings",
|
|
"Markdown": "misc",
|
|
"Markup": "misc",
|
|
"License": "misc",
|
|
"Gitignore": "misc",
|
|
"Annotated": "git",
|
|
"Note": "git",
|
|
"ChangedFile": "git",
|
|
"ExternalTracker": "repo",
|
|
"ExternalWiki": "repo",
|
|
"InternalTracker": "repo",
|
|
"Permission": "common",
|
|
"RepoTransfer": "repo",
|
|
"PayloadCommit": "hook",
|
|
"Dispatch": "action",
|
|
"Secret": "action",
|
|
"Variable": "action",
|
|
"Push": "repo",
|
|
"Mirror": "repo",
|
|
"Attachment": "common",
|
|
"EditDeadline": "issue",
|
|
"IssueDeadline": "issue",
|
|
"IssueLabels": "issue",
|
|
"IssueMeta": "issue",
|
|
"IssueTemplate": "issue",
|
|
"StateType": "common",
|
|
"TimeStamp": "common",
|
|
"Rename": "admin",
|
|
"Unadopted": "admin",
|
|
}
|
|
|
|
// classifyType determines which output file a type belongs to.
|
|
// It checks for a direct match first, then tries prefix matching,
|
|
// then strips Create/Edit/Delete/Update prefixes and Option suffix
|
|
// to find the base type's grouping.
|
|
func classifyType(name string) string {
|
|
// Direct match.
|
|
if group, ok := typeGrouping[name]; ok {
|
|
return group
|
|
}
|
|
|
|
// Prefix match — longest prefix wins.
|
|
bestKey := ""
|
|
bestGroup := ""
|
|
for key, group := range typeGrouping {
|
|
if core.HasPrefix(name, key) && len(key) > len(bestKey) {
|
|
bestKey = key
|
|
bestGroup = group
|
|
}
|
|
}
|
|
if bestGroup != "" {
|
|
return bestGroup
|
|
}
|
|
|
|
// Strip CRUD prefixes and Option suffix, then retry.
|
|
base := name
|
|
for _, prefix := range []string{"Create", "Edit", "Delete", "Update", "Add", "Submit", "Replace", "Set", "Transfer"} {
|
|
base = core.TrimPrefix(base, prefix)
|
|
}
|
|
base = core.TrimSuffix(base, "Option")
|
|
base = core.TrimSuffix(base, "Options")
|
|
|
|
if base != name && base != "" {
|
|
if group, ok := typeGrouping[base]; ok {
|
|
return group
|
|
}
|
|
// Prefix match on the stripped base.
|
|
bestKey = ""
|
|
bestGroup = ""
|
|
for key, group := range typeGrouping {
|
|
if core.HasPrefix(base, key) && len(key) > len(bestKey) {
|
|
bestKey = key
|
|
bestGroup = group
|
|
}
|
|
}
|
|
if bestGroup != "" {
|
|
return bestGroup
|
|
}
|
|
}
|
|
|
|
return "misc"
|
|
}
|
|
|
|
// sanitiseLine collapses a multi-line string into a single line,
|
|
// replacing newlines and consecutive whitespace with a single space.
|
|
func sanitiseLine(s string) string {
|
|
return core.Join(" ", splitFields(s)...)
|
|
}
|
|
|
|
// enumConstName generates a Go constant name for an enum value.
|
|
func enumConstName(typeName, value string) string {
|
|
return typeName + pascalCase(value)
|
|
}
|
|
|
|
// templateFuncs provides helper functions for the file template.
|
|
var templateFuncs = template.FuncMap{
|
|
"sanitise": sanitiseLine,
|
|
"enumConstName": enumConstName,
|
|
}
|
|
|
|
// fileHeader is the template for generating a single Go source file.
|
|
var fileHeader = template.Must(template.New("file").Funcs(templateFuncs).Parse(`// Code generated by forgegen from swagger.v1.json — DO NOT EDIT.
|
|
|
|
package types
|
|
{{if .NeedTime}}
|
|
import "time"
|
|
{{end}}
|
|
{{range .Types}}{{$t := .}}
|
|
{{- if .Description}}
|
|
// {{.Name}} — {{sanitise .Description}}
|
|
{{- end}}
|
|
{{- if .Usage}}
|
|
//
|
|
// Usage:
|
|
//
|
|
// opts := {{.Usage}}
|
|
{{- end}}
|
|
{{- if .IsEnum}}
|
|
type {{.Name}} string
|
|
|
|
const (
|
|
{{- range .EnumValues}}
|
|
{{enumConstName $t.Name .}} {{$t.Name}} = "{{.}}"
|
|
{{- end}}
|
|
)
|
|
{{- else if .IsAlias}}
|
|
type {{.Name}} {{.AliasType}}
|
|
{{- else if (eq (len .Fields) 0)}}
|
|
// {{.Name}} has no fields in the swagger spec.
|
|
type {{.Name}} struct{}
|
|
{{- else}}
|
|
type {{.Name}} struct {
|
|
{{- range .Fields}}
|
|
{{.GoName}} {{.GoType}} ` + "`" + `json:"{{.JSONName}}{{if not .Required}},omitempty{{end}}"` + "`" + `{{if .Comment}} // {{sanitise .Comment}}{{end}}
|
|
{{- end}}
|
|
}
|
|
{{- end}}
|
|
{{end}}
|
|
`))
|
|
|
|
// templateData is the data passed to the file template.
|
|
type templateData struct {
|
|
NeedTime bool
|
|
Types []*GoType
|
|
}
|
|
|
|
// Generate writes Go source files for the extracted types, grouped by logical domain.
|
|
//
|
|
// Usage:
|
|
//
|
|
// err := Generate(types, pairs, "types")
|
|
// _ = err
|
|
func Generate(types map[string]*GoType, pairs []CRUDPair, outDir string) error {
|
|
if err := coreio.Local.EnsureDir(outDir); err != nil {
|
|
return core.E("Generate", "create output directory", err)
|
|
}
|
|
|
|
populateUsageExamples(types)
|
|
|
|
// Group types by output file.
|
|
groups := make(map[string][]*GoType)
|
|
for _, gt := range types {
|
|
file := classifyType(gt.Name)
|
|
groups[file] = append(groups[file], gt)
|
|
}
|
|
|
|
// Sort types within each group for deterministic output.
|
|
for file := range groups {
|
|
slices.SortFunc(groups[file], func(a, b *GoType) int {
|
|
return cmp.Compare(a.Name, b.Name)
|
|
})
|
|
}
|
|
|
|
// Write each group to its own file.
|
|
fileNames := slices.Collect(maps.Keys(groups))
|
|
slices.Sort(fileNames)
|
|
|
|
for _, file := range fileNames {
|
|
outPath := core.JoinPath(outDir, file+".go")
|
|
if err := writeFile(outPath, groups[file]); err != nil {
|
|
return core.E("Generate", "write "+outPath, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func populateUsageExamples(types map[string]*GoType) {
|
|
for _, gt := range types {
|
|
gt.Usage = usageExample(gt)
|
|
}
|
|
}
|
|
|
|
func usageExample(gt *GoType) string {
|
|
switch {
|
|
case gt.IsEnum && len(gt.EnumValues) > 0:
|
|
return enumConstName(gt.Name, gt.EnumValues[0])
|
|
case gt.IsAlias:
|
|
return gt.Name + "(" + exampleTypeExpression(gt.AliasType) + ")"
|
|
default:
|
|
example := exampleTypeLiteral(gt)
|
|
if example == "" {
|
|
example = gt.Name + "{}"
|
|
}
|
|
return example
|
|
}
|
|
}
|
|
|
|
func exampleTypeLiteral(gt *GoType) string {
|
|
if len(gt.Fields) == 0 {
|
|
return gt.Name + "{}"
|
|
}
|
|
|
|
field := chooseUsageField(gt.Fields)
|
|
if field.GoName == "" {
|
|
return gt.Name + "{}"
|
|
}
|
|
|
|
return gt.Name + "{" + field.GoName + ": " + exampleValue(field) + "}"
|
|
}
|
|
|
|
func exampleTypeExpression(typeName string) string {
|
|
switch {
|
|
case typeName == "string":
|
|
return strconv.Quote("example")
|
|
case typeName == "bool":
|
|
return "true"
|
|
case typeName == "int", typeName == "int32", typeName == "int64", typeName == "uint", typeName == "uint32", typeName == "uint64":
|
|
return "1"
|
|
case typeName == "float32", typeName == "float64":
|
|
return "1.0"
|
|
case typeName == "time.Time":
|
|
return "time.Now()"
|
|
case core.HasPrefix(typeName, "[]string"):
|
|
return "[]string{\"example\"}"
|
|
case core.HasPrefix(typeName, "[]int64"):
|
|
return "[]int64{1}"
|
|
case core.HasPrefix(typeName, "[]int"):
|
|
return "[]int{1}"
|
|
case core.HasPrefix(typeName, "map["):
|
|
return typeName + "{\"key\": \"value\"}"
|
|
default:
|
|
return typeName + "{}"
|
|
}
|
|
}
|
|
|
|
func chooseUsageField(fields []GoField) GoField {
|
|
best := fields[0]
|
|
bestScore := usageFieldScore(best)
|
|
for _, field := range fields[1:] {
|
|
score := usageFieldScore(field)
|
|
if score < bestScore || (score == bestScore && field.GoName < best.GoName) {
|
|
best = field
|
|
bestScore = score
|
|
}
|
|
}
|
|
return best
|
|
}
|
|
|
|
func usageFieldScore(field GoField) int {
|
|
score := 100
|
|
if field.Required {
|
|
score -= 50
|
|
}
|
|
switch {
|
|
case core.HasSuffix(field.GoType, "string"):
|
|
score -= 30
|
|
case core.Contains(field.GoType, "time.Time"):
|
|
score -= 25
|
|
case core.HasSuffix(field.GoType, "bool"):
|
|
score -= 20
|
|
case core.Contains(field.GoType, "int"):
|
|
score -= 15
|
|
case core.HasPrefix(field.GoType, "[]"):
|
|
score -= 10
|
|
}
|
|
if core.Contains(field.GoName, "Name") || core.Contains(field.GoName, "Title") || core.Contains(field.GoName, "Body") || core.Contains(field.GoName, "Description") {
|
|
score -= 10
|
|
}
|
|
return score
|
|
}
|
|
|
|
func exampleValue(field GoField) string {
|
|
switch {
|
|
case core.HasPrefix(field.GoType, "*"):
|
|
return "&" + core.TrimPrefix(field.GoType, "*") + "{}"
|
|
case field.GoType == "string":
|
|
return exampleStringValue(field.GoName)
|
|
case field.GoType == "time.Time":
|
|
return "time.Now()"
|
|
case field.GoType == "bool":
|
|
return "true"
|
|
case core.HasSuffix(field.GoType, "int64"), core.HasSuffix(field.GoType, "int"), core.HasSuffix(field.GoType, "uint64"), core.HasSuffix(field.GoType, "uint"):
|
|
return "1"
|
|
case core.HasPrefix(field.GoType, "[]string"):
|
|
return "[]string{\"example\"}"
|
|
case core.HasPrefix(field.GoType, "[]int64"):
|
|
return "[]int64{1}"
|
|
case core.HasPrefix(field.GoType, "[]int"):
|
|
return "[]int{1}"
|
|
case core.HasPrefix(field.GoType, "map["):
|
|
return field.GoType + "{\"key\": \"value\"}"
|
|
default:
|
|
return "{}"
|
|
}
|
|
}
|
|
|
|
func exampleStringValue(fieldName string) string {
|
|
switch {
|
|
case core.Contains(fieldName, "URL"):
|
|
return "\"https://example.com\""
|
|
case core.Contains(fieldName, "Email"):
|
|
return "\"alice@example.com\""
|
|
case core.Contains(fieldName, "Tag"):
|
|
return "\"v1.0.0\""
|
|
case core.Contains(fieldName, "Branch"), core.Contains(fieldName, "Ref"):
|
|
return "\"main\""
|
|
default:
|
|
return "\"example\""
|
|
}
|
|
}
|
|
|
|
// writeFile renders and writes a single Go source file for the given types.
|
|
func writeFile(path string, types []*GoType) error {
|
|
needTime := slices.ContainsFunc(types, func(gt *GoType) bool {
|
|
if core.Contains(gt.AliasType, "time.Time") {
|
|
return true
|
|
}
|
|
return slices.ContainsFunc(gt.Fields, func(f GoField) bool {
|
|
return core.Contains(f.GoType, "time.Time")
|
|
})
|
|
})
|
|
|
|
data := templateData{
|
|
NeedTime: needTime,
|
|
Types: types,
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
if err := fileHeader.Execute(&buf, data); err != nil {
|
|
return core.E("writeFile", "execute template", err)
|
|
}
|
|
|
|
content := strings.TrimRight(buf.String(), "\n") + "\n"
|
|
if err := coreio.Local.Write(path, content); err != nil {
|
|
return core.E("writeFile", "write file", err)
|
|
}
|
|
|
|
return nil
|
|
}
|