/
main.go
109 lines (88 loc) · 2.5 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
105
106
107
108
109
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0
package main
import (
"flag"
"fmt"
"log"
"os"
"golang.org/x/tools/go/packages"
)
func main() {
if err := run(os.Args); err != nil {
fmt.Fprintln(os.Stderr, "ERROR", err.Error())
os.Exit(1)
}
}
func run(args []string) error {
flags, opts := setupFlags(args[0])
err := flags.Parse(args[1:])
switch {
case err == flag.ErrHelp:
return nil
case err != nil:
return err
}
log.SetFlags(0)
return runMog(*opts)
}
type options struct {
source string
ignorePackageLoadErrors bool
tags string
}
func (o options) handlePackageLoadErrors(pkg *packages.Package) error {
if o.ignorePackageLoadErrors {
// TODO: setup logger
for _, err := range pkg.Errors {
log.Println(err.Error())
}
return nil
}
return packageLoadErrors(pkg)
}
func setupFlags(name string) (*flag.FlagSet, *options) {
flags := flag.NewFlagSet(name, flag.ContinueOnError)
opts := &options{}
// TODO: make this a positional arg, set a Usage func to document it
flags.StringVar(&opts.source, "source", ".", "package path for source structs")
// TODO: make this a positional arg, set a Usage func to document it
flags.StringVar(&opts.tags, "tags", ".", "build tags to be passed when parsing the packages")
flags.BoolVar(&opts.ignorePackageLoadErrors, "ignore-package-load-errors", false,
"ignore any syntax errors encountered while loading source")
return flags, opts
}
func runMog(opts options) error {
if opts.source == "" {
return fmt.Errorf("missing required source package")
}
sources, err := loadSourceStructs(opts.source, opts.tags, opts.handlePackageLoadErrors)
if err != nil {
return fmt.Errorf("failed to load source from %s: %w", opts.source, err)
}
cfg, err := configsFromAnnotations(sources)
if err != nil {
return fmt.Errorf("failed to parse annotations: %w", err)
}
if len(cfg.Structs) == 0 {
log.Printf("no source structs found in %v", opts.source)
return nil
}
targets, err := loadTargetStructs(targetPackages(cfg.Structs), opts.tags)
if err != nil {
return fmt.Errorf("failed to load targets: %w", err)
}
cfg.Structs = applyAutoConvertFunctions(cfg.Structs)
log.Printf("Generating code for %d structs", len(cfg.Structs))
return generateFiles(cfg, targets)
}
func targetPackages(cfgs []structConfig) []string {
result := make([]string, 0, len(cfgs))
for _, cfg := range cfgs {
if cfg.Target.Package == "" {
continue
}
result = append(result, cfg.Target.Package)
}
return result
}