Debian Codegraph @

v2/generator/execute.go

raw
1 /*
2 Copyright 2015 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package generator
18
19 import (
20 "bytes"
21 "errors"
22 "fmt"
23 "io"
24 "os"
25 "path/filepath"
26 "strings"
27
28 "golang.org/x/tools/imports"
29
30 "k8s.io/gengo/v2/namer"
31 "k8s.io/gengo/v2/types"
32 "k8s.io/klog/v2"
33 )
34
35 // ExecuteTargets runs the generators for the provided targets.
36 func (c *Context) ExecuteTargets(targets []Target) error {
37 klog.V(5).Infof("ExecuteTargets: %d targets", len(targets))
38
39 var errs []error
40 for _, tgt := range targets {
41 if err := c.ExecuteTarget(tgt); err != nil {
42 errs = append(errs, err)
43 }
44 }
45 if len(errs) > 0 {
46 return fmt.Errorf("some targets had errors: %w", errors.Join(errs...))
47 }
48 return nil
49 }
50
51 type DefaultFileType struct {
52 Format func([]byte) ([]byte, error)
53 Assemble func(io.Writer, *File)
54 }
55
56 func (ft DefaultFileType) AssembleFile(f *File, pathname string) error {
57 klog.V(5).Infof("Assembling file %q", pathname)
58
59 destFile, err := os.Create(pathname)
60 if err != nil {
61 return err
62 }
63 defer destFile.Close()
64
65 b := &bytes.Buffer{}
66 et := NewErrorTracker(b)
67 ft.Assemble(et, f)
68 if et.Error() != nil {
69 return et.Error()
70 }
71 if formatted, err := ft.Format(b.Bytes()); err != nil {
72 err = fmt.Errorf("unable to format file %q (%v)", pathname, err)
73 // Write the file anyway, so they can see what's going wrong and fix the generator.
74 if _, err2 := destFile.Write(b.Bytes()); err2 != nil {
75 return err2
76 }
77 return err
78 } else {
79 _, err = destFile.Write(formatted)
80 return err
81 }
82 }
83
84 func assembleGoFile(w io.Writer, f *File) {
85 w.Write(f.Header)
86 fmt.Fprintf(w, "package %v\n\n", f.PackageName)
87
88 if len(f.Imports) > 0 {
89 fmt.Fprint(w, "import (\n")
90 for i := range f.Imports {
91 if strings.Contains(i, "\"") {
92 // they included quotes, or are using the
93 // `name "path/to/pkg"` format.
94 fmt.Fprintf(w, "\t%s\n", i)
95 } else {
96 fmt.Fprintf(w, "\t%q\n", i)
97 }
98 }
99 fmt.Fprint(w, ")\n\n")
100 }
101
102 if f.Vars.Len() > 0 {
103 fmt.Fprint(w, "var (\n")
104 w.Write(f.Vars.Bytes())
105 fmt.Fprint(w, ")\n\n")
106 }
107
108 if f.Consts.Len() > 0 {
109 fmt.Fprint(w, "const (\n")
110 w.Write(f.Consts.Bytes())
111 fmt.Fprint(w, ")\n\n")
112 }
113
114 w.Write(f.Body.Bytes())
115 }
116
117 func importsWrapper(src []byte) ([]byte, error) {
118 opt := imports.Options{
119 Comments: true,
120 TabIndent: true,
121 TabWidth: 8,
122 FormatOnly: true, // Disable the insertion and deletion of imports
123 }
124 return imports.Process("", src, &opt)
125 }
126
127 func NewGoFile() *DefaultFileType {
128 return &DefaultFileType{
129 Format: importsWrapper,
130 Assemble: assembleGoFile,
131 }
132 }
133
134 // format should be one line only, and not end with \n.
135 func addIndentHeaderComment(b *bytes.Buffer, format string, args ...interface{}) {
136 if b.Len() > 0 {
137 fmt.Fprintf(b, "\n// "+format+"\n", args...)
138 } else {
139 fmt.Fprintf(b, "// "+format+"\n", args...)
140 }
141 }
142
143 func (c *Context) filteredBy(f func(*Context, *types.Type) bool) *Context {
144 c2 := *c
145 c2.Order = []*types.Type{}
146 for _, t := range c.Order {
147 if f(c, t) {
148 c2.Order = append(c2.Order, t)
149 }
150 }
151 return &c2
152 }
153
154 // make a new context; inheret c.Namers, but add on 'namers'. In case of a name
155 // collision, the namer in 'namers' wins.
156 func (c *Context) addNameSystems(namers namer.NameSystems) *Context {
157 if namers == nil {
158 return c
159 }
160 c2 := *c
161 // Copy the existing name systems so we don't corrupt a parent context
162 c2.Namers = namer.NameSystems{}
163 for k, v := range c.Namers {
164 c2.Namers[k] = v
165 }
166
167 for name, namer := range namers {
168 c2.Namers[name] = namer
169 }
170 return &c2
171 }
172
173 // ExecuteTarget runs the generators for a single target.
174 func (c *Context) ExecuteTarget(tgt Target) error {
175 tgtDir := tgt.Dir()
176 if tgtDir == "" {
177 return fmt.Errorf("no directory for target %s", tgt.Path())
178 }
179 klog.V(5).Infof("Executing target %q (%q)", tgt.Name(), tgtDir)
180
181 // Filter out any types the *package* doesn't care about.
182 packageContext := c.filteredBy(tgt.Filter)
183
184 if err := os.MkdirAll(tgtDir, 0755); err != nil {
185 return err
186 }
187
188 files := map[string]*File{}
189 for _, g := range tgt.Generators(packageContext) {
190 // Filter out types the *generator* doesn't care about.
191 genContext := packageContext.filteredBy(g.Filter)
192 // Now add any extra name systems defined by this generator
193 genContext = genContext.addNameSystems(g.Namers(genContext))
194
195 fileType := g.FileType()
196 if len(fileType) == 0 {
197 return fmt.Errorf("generator %q must specify a file type", g.Name())
198 }
199 f := files[g.Filename()]
200 if f == nil {
201 // This is the first generator to reference this file, so start it.
202 f = &File{
203 Name: g.Filename(),
204 FileType: fileType,
205 PackageName: tgt.Name(),
206 PackagePath: tgt.Path(),
207 PackageDir: tgt.Dir(),
208 Header: tgt.Header(g.Filename()),
209 Imports: map[string]struct{}{},
210 }
211 files[f.Name] = f
212 } else if f.FileType != g.FileType() {
213 return fmt.Errorf("file %q already has type %q, but generator %q wants to use type %q", f.Name, f.FileType, g.Name(), g.FileType())
214 }
215
216 if vars := g.PackageVars(genContext); len(vars) > 0 {
217 addIndentHeaderComment(&f.Vars, "Package-wide variables from generator %q.", g.Name())
218 for _, v := range vars {
219 if _, err := fmt.Fprintf(&f.Vars, "%s\n", v); err != nil {
220 return err
221 }
222 }
223 }
224 if consts := g.PackageConsts(genContext); len(consts) > 0 {
225 addIndentHeaderComment(&f.Consts, "Package-wide consts from generator %q.", g.Name())
226 for _, v := range consts {
227 if _, err := fmt.Fprintf(&f.Consts, "%s\n", v); err != nil {
228 return err
229 }
230 }
231 }
232 if err := genContext.executeBody(&f.Body, g); err != nil {
233 return err
234 }
235 if imports := g.Imports(genContext); len(imports) > 0 {
236 for _, i := range imports {
237 f.Imports[i] = struct{}{}
238 }
239 }
240 }
241
242 var errs []error
243 for _, f := range files {
244 finalPath := filepath.Join(tgtDir, f.Name)
245 assembler, ok := c.FileTypes[f.FileType]
246 if !ok {
247 return fmt.Errorf("the file type %q registered for file %q does not exist in the context", f.FileType, f.Name)
248 }
249 if err := assembler.AssembleFile(f, finalPath); err != nil {
250 errs = append(errs, err)
251 }
252 }
253 if len(errs) > 0 {
254 return fmt.Errorf("errors in target %q: %w", tgt.Path(), errors.Join(errs...))
255 }
256 return nil
257 }
258
259 func (c *Context) executeBody(w io.Writer, generator Generator) error {
260 et := NewErrorTracker(w)
261 if err := generator.Init(c, et); err != nil {
262 return err
263 }
264 for _, t := range c.Order {
265 if err := generator.GenerateType(c, t, et); err != nil {
266 return err
267 }
268 }
269 if err := generator.Finalize(c, et); err != nil {
270 return err
271 }
272 return et.Error()
273 }