gotry/gotry_generate/main.go
Theta-Dev 1cf7829749
All checks were successful
continuous-integration/drone/push Build is passing
Improved code generator
Better stack trace
Add try.CatchTrace, try.FromErr
2021-10-16 22:56:51 +02:00

150 lines
3.2 KiB
Go

package main
import (
"bufio"
"flag"
"fmt"
"os"
"os/exec"
"path"
"regexp"
"strings"
"text/template"
"code.thetadev.de/ThetaDev/gotry"
"code.thetadev.de/ThetaDev/gotry/try"
)
var variablePattern = regexp.MustCompile(`^(\w[\w\d]*)(\+s)?$`)
type line struct {
Name string
WithSlice bool
Types []string
UseExt bool
}
func parseDefinitions(defFileName, outFileName, pkgName string) (err try.Err) {
defer try.Annotate(&err, "error parsing definitions")
defFile := try.File(os.Open(defFileName))
useExt := pkgName != "try"
fileScanner := bufio.NewScanner(defFile)
fileScanner.Split(bufio.ScanLines)
ln := 0
var lines []line
imports := map[string]bool{}
for fileScanner.Scan() {
lineStr := strings.TrimSpace(fileScanner.Text())
ln++
if lineStr == "" || strings.HasPrefix(lineStr, "#") ||
strings.HasPrefix(lineStr, "/") {
continue
}
lineData, err := parseLine(lineStr, imports)
if err != nil {
fmt.Printf("[Err] line %d, %s: \"%s\n", ln, err.Error(), lineStr)
continue
}
lineData.UseExt = useExt
lines = append(lines, *lineData)
}
fmt.Printf("Parsed %d definitions\n", len(lines))
outFile := try.File(os.Create(outFileName))
tmpl := template.Must(template.New("templ").Parse(gotry.TypesTemplate))
try.Check(tmpl.Execute(outFile, struct {
Definitions []line
Imports map[string]bool
PkgName string
UseExt bool
}{
Definitions: lines,
Imports: imports,
PkgName: pkgName,
UseExt: useExt,
}))
try.Check(defFile.Close())
try.Check(outFile.Close())
try.Check(goFmt(outFileName))
return
}
func parseLine(lineStr string, imports map[string]bool) (*line, try.Err) {
lineParts := strings.Split(lineStr, ";")
lineData := line{}
if len(lineParts) < 2 {
return nil, try.NewErr("missing type name")
}
// Parse variable name
variableRaw := strings.TrimSpace(lineParts[0])
if match := variablePattern.FindStringSubmatch(variableRaw); match != nil {
lineData.Name = match[1]
lineData.WithSlice = match[2] != ""
} else {
return nil, try.NewErr("invalid variable name")
}
// Parse type name(s)
for _, typeStr := range strings.Split(lineParts[1], ",") {
typeStr = strings.TrimSpace(typeStr)
if typeStr != "" {
lineData.Types = append(lineData.Types, typeStr)
}
}
if len(lineData.Types) == 0 {
return nil, try.NewErr("invalid type name")
}
// Parse imports
for i := 2; i < len(lineParts); i++ {
pkgName := strings.TrimSpace(lineParts[i])
imports[pkgName] = true
}
return &lineData, nil
}
func goFmt(goFile string) error {
return exec.Command("gofmt", "-s", "-w", goFile).Run()
}
func main() {
defer try.CatchTrace(1)
// Read flags
var definitionFile string
var targetDir string
var typeFile string
flag.StringVar(&definitionFile, "def", path.Join("try", "types.csv"),
"Definition file")
flag.StringVar(&targetDir, "o", "try", "Target directory")
flag.StringVar(&typeFile, "of", "types", "Name of generated type definition file")
flag.Parse()
try.Check(os.MkdirAll(targetDir, 0o777))
// Generate types
if _, e := os.Stat(definitionFile); os.IsNotExist(e) {
try.Check(try.NewErr("Definition file does not exist"))
} else {
try.Check(
parseDefinitions(definitionFile, path.Join(targetDir, typeFile+".go"),
path.Base(targetDir)))
}
}