Ben Kraft
f72933fa0e
## Summary:
genqlient has some code (`imports.go`) dedicated to tracking which
imports we need and avoiding conflicts, as well as converting a
(restricted) Go expression like `map[string]github.com/me/mypkg.MyType`
to an import (`github.com/me/mypkg`) and a type-reference
(`map[string]mypkg.MyType`) to be used in the context of that import,
and at least making some attempt to track conflicts. (Right now the
conflict-avoidance is not very smart, and not very well tested, but it
comes up rarely anyway.) Sadly, that code was a bit cumbersome to use,
because you had to first register the imports (typically from
`convert.go`), then use them (often from the template).
In this commit I refactor the order we write things in order to allow a
significant simplification of how we import; in particular we no longer
have to guess in advance what imports which template will need; it can
just do `{{ref <expr>}}` as before, and it just works. To do this, I:
- changed the importer to have only one API, which adds the import if
needed, and returns the reference either way
- added a check that we don't add imports after they're written
- reorganized the toplevel templates a bit to make sure that check never
fires; we now generate all the types and operations, then write the
imports and glue it all together
This removes a bunch of silly code, and should simplify the process of
adding custom (un)marshalers (#38).
While I was at it, I put the documentation of what expressions we
support in a more visible place, and added a type-assertion that your
custom context type implements context.Context (if applicable).
## Test plan:
make check
Author: benjaminjkraft
Reviewers: StevenACoffman, dnerdy, aberkan, jvoll, mahtabsabet, MiguelCastillo
Required Reviewers:
Approved By: StevenACoffman, dnerdy
Checks: ⌛ Test (1.17), ⌛ Test (1.16), ⌛ Test (1.15), ⌛ Test (1.14), ⌛ Lint, ⌛ Test (1.17), ⌛ Test (1.16), ⌛ Test (1.15), ⌛ Test (1.14), ⌛ Lint
Pull Request URL: https://github.com/Khan/genqlient/pull/101
60 lines
1.3 KiB
Go
60 lines
1.3 KiB
Go
package generate
|
|
|
|
import (
|
|
"io"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"text/template"
|
|
)
|
|
|
|
var (
|
|
// TODO(benkraft): Embed templates into the binary, see
|
|
// https://github.com/Khan/genqlient/issues/9.
|
|
_, thisFilename, _, _ = runtime.Caller(0)
|
|
thisDir = filepath.Dir(thisFilename)
|
|
)
|
|
|
|
func repeat(n int, s string) string {
|
|
var builder strings.Builder
|
|
for i := 0; i < n; i++ {
|
|
builder.WriteString(s)
|
|
}
|
|
return builder.String()
|
|
}
|
|
|
|
func intRange(n int) []int {
|
|
ret := make([]int, n)
|
|
for i := 0; i < n; i++ {
|
|
ret[i] = i
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func sub(x, y int) int { return x - y }
|
|
|
|
// render executes the given template with the funcs from this generator.
|
|
func (g *generator) render(tmplRelFilename string, w io.Writer, data interface{}) error {
|
|
tmpl := g.templateCache[tmplRelFilename]
|
|
if tmpl == nil {
|
|
absFilename := filepath.Join(thisDir, tmplRelFilename)
|
|
funcMap := template.FuncMap{
|
|
"ref": g.ref,
|
|
"repeat": repeat,
|
|
"intRange": intRange,
|
|
"sub": sub,
|
|
}
|
|
var err error
|
|
tmpl, err = template.New(tmplRelFilename).Funcs(funcMap).ParseFiles(absFilename)
|
|
if err != nil {
|
|
return errorf(nil, "could not load template %v: %v", absFilename, err)
|
|
}
|
|
g.templateCache[tmplRelFilename] = tmpl
|
|
}
|
|
err := tmpl.Execute(w, data)
|
|
if err != nil {
|
|
return errorf(nil, "could not render template: %v", err)
|
|
}
|
|
return nil
|
|
}
|