// NewControllersWriter returns a handlers code writer.
// Handlers provide the glue between the underlying request data and the user controller.
func NewControllersWriter(filename string) (*ControllersWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["add"] = func(a, b int) int { return a + b }
funcMap["gotypename"] = codegen.GoTypeName
ctrlTmpl, err := template.New("controller").Funcs(funcMap).Parse(ctrlT)
if err != nil {
return nil, err
}
mountTmpl, err := template.New("mount").Funcs(funcMap).Parse(mountT)
if err != nil {
return nil, err
}
unmarshalTmpl, err := template.New("unmarshal").Funcs(funcMap).Parse(unmarshalT)
if err != nil {
return nil, err
}
w := ControllersWriter{
GoGenerator: cw,
CtrlTmpl: ctrlTmpl,
MountTmpl: mountTmpl,
UnmarshalTmpl: unmarshalTmpl,
}
return &w, nil
}
// NewMediaTypesWriter returns a contexts code writer.
// Media types contain the data used to render response bodies.
func NewMediaTypesWriter(filename string) (*MediaTypesWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["gotypedef"] = codegen.GoTypeDef
funcMap["gotyperef"] = codegen.GoTypeRef
funcMap["goify"] = codegen.Goify
funcMap["gotypename"] = codegen.GoTypeName
funcMap["gonative"] = codegen.GoNativeType
funcMap["typeUnmarshaler"] = codegen.TypeUnmarshaler
funcMap["typeMarshaler"] = codegen.MediaTypeMarshaler
funcMap["recursiveValidate"] = codegen.RecursiveChecker
funcMap["tempvar"] = codegen.Tempvar
funcMap["newDumpData"] = newDumpData
funcMap["userTypeUnmarshalerImpl"] = codegen.UserTypeUnmarshalerImpl
funcMap["mediaTypeMarshalerImpl"] = codegen.MediaTypeMarshalerImpl
mediaTypeTmpl, err := template.New("media type").Funcs(funcMap).Parse(mediaTypeT)
if err != nil {
return nil, err
}
w := MediaTypesWriter{
GoGenerator: cw,
MediaTypeTmpl: mediaTypeTmpl,
}
return &w, nil
}
func (g *Generator) generateClientResources(clientPkg string, funcs template.FuncMap, api *design.APIDefinition) error {
clientsTmpl := template.Must(template.New("clients").Funcs(funcs).Parse(clientsTmpl))
imports := []*codegen.ImportSpec{
codegen.SimpleImport("bytes"),
codegen.SimpleImport("encoding/json"),
codegen.SimpleImport("fmt"),
codegen.SimpleImport("net/http"),
}
return api.IterateResources(func(res *design.ResourceDefinition) error {
filename := filepath.Join(codegen.OutputDir, snakeCase(res.Name)+".go")
resGen := codegen.NewGoGenerator(filename)
if err := resGen.WriteHeader("", "client", imports); err != nil {
return err
}
g.genfiles = append(g.genfiles, filename)
if err := res.IterateActions(func(action *design.ActionDefinition) error {
return clientsTmpl.Execute(resGen, action)
}); err != nil {
return err
}
return resGen.FormatCode()
})
}
func (m *Generator) generateToolSourceCode(gendir, pkgName string) {
filename := filepath.Join(gendir, "main.go")
m.GoGenerator = codegen.NewGoGenerator(filename)
imports := append(m.Imports,
codegen.SimpleImport("fmt"),
codegen.SimpleImport("os"),
codegen.SimpleImport("strings"),
codegen.NewImport(".", "github.com/raphael/goa/design"),
codegen.NewImport(".", "github.com/raphael/goa/design/dsl"),
codegen.NewImport("_", codegen.DesignPackagePath),
)
m.WriteHeader("Code Generator", "main", imports)
tmpl, err := template.New("generator").Parse(mainTmpl)
if err != nil {
panic(err) // bug
}
context := map[string]string{
"Genfunc": m.Genfunc,
"DesignPackage": codegen.DesignPackagePath,
"PkgName": pkgName,
}
err = tmpl.Execute(m, context)
if err != nil {
panic(err) // bug
}
if codegen.Debug {
src, _ := ioutil.ReadFile(filename)
fmt.Printf("goagen source:\n%s\n", src)
}
}
// Generate is the generator entry point called by the meta generator.
func Generate(api *design.APIDefinition) (_ []string, err error) {
var genfiles []string
cleanup := func() {
for _, f := range genfiles {
os.Remove(f)
}
}
go utils.Catch(nil, cleanup)
defer func() {
if err != nil {
cleanup()
}
}()
app := kingpin.New("Swagger generator", "Swagger spec generator")
codegen.RegisterFlags(app)
_, err = app.Parse(os.Args[1:])
if err != nil {
return nil, fmt.Errorf(`invalid command line: %s. Command line was "%s"`,
err, strings.Join(os.Args, " "))
}
s, err := New(api)
if err != nil {
return
}
b, err := json.Marshal(s)
if err != nil {
return
}
swaggerDir := filepath.Join(codegen.OutputDir, "swagger")
os.RemoveAll(swaggerDir)
if err = os.MkdirAll(swaggerDir, 0755); err != nil {
return
}
genfiles = append(genfiles, swaggerDir)
swaggerFile := filepath.Join(swaggerDir, "swagger.json")
err = ioutil.WriteFile(swaggerFile, b, 0644)
if err != nil {
return
}
genfiles = append(genfiles, swaggerFile)
controllerFile := filepath.Join(swaggerDir, "swagger.go")
genfiles = append(genfiles, controllerFile)
gg := codegen.NewGoGenerator(controllerFile)
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/julienschmidt/httprouter"),
codegen.SimpleImport("github.com/raphael/goa"),
}
gg.WriteHeader(fmt.Sprintf("%s Swagger Spec", api.Name), "swagger", imports)
gg.Write([]byte(swagger))
if err = gg.FormatCode(); err != nil {
return
}
return genfiles, nil
}
// NewGenerator returns the application code generator.
func NewGenerator() (*Generator, error) {
app := kingpin.New("Code generator", "application code generator")
codegen.RegisterFlags(app)
NewCommand().RegisterFlags(app)
_, err := app.Parse(os.Args[1:])
if err != nil {
return nil, fmt.Errorf(`invalid command line: %s. Command line was "%s"`,
err, strings.Join(os.Args, " "))
}
outdir := AppOutputDir()
os.RemoveAll(outdir)
if err = os.MkdirAll(outdir, 0777); err != nil {
return nil, err
}
ctxFile := filepath.Join(outdir, "contexts.go")
ctlFile := filepath.Join(outdir, "controllers.go")
resFile := filepath.Join(outdir, "hrefs.go")
mtFile := filepath.Join(outdir, "media_types.go")
utFile := filepath.Join(outdir, "user_types.go")
ctxWr, err := NewContextsWriter(ctxFile)
if err != nil {
panic(err) // bug
}
ctlWr, err := NewControllersWriter(ctlFile)
if err != nil {
panic(err) // bug
}
resWr, err := NewResourcesWriter(resFile)
if err != nil {
panic(err) // bug
}
mtWr, err := NewMediaTypesWriter(mtFile)
if err != nil {
panic(err) // bug
}
utWr, err := NewUserTypesWriter(utFile)
if err != nil {
panic(err) // bug
}
return &Generator{
GoGenerator: codegen.NewGoGenerator(outdir),
ContextsWriter: ctxWr,
ControllersWriter: ctlWr,
ResourcesWriter: resWr,
MediaTypesWriter: mtWr,
UserTypesWriter: utWr,
contextsFilename: ctxFile,
controllersFilename: ctlFile,
resourcesFilename: resFile,
mediaTypesFilename: mtFile,
userTypesFilename: utFile,
genfiles: []string{outdir},
}, nil
}
// NewResourcesWriter returns a contexts code writer.
// Resources provide the glue between the underlying request data and the user controller.
func NewResourcesWriter(filename string) (*ResourcesWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["join"] = strings.Join
resourceTmpl, err := template.New("resource").Funcs(cw.FuncMap).Parse(resourceT)
if err != nil {
return nil, err
}
w := ResourcesWriter{
GoGenerator: cw,
ResourceTmpl: resourceTmpl,
}
return &w, nil
}
// NewContextsWriter returns a contexts code writer.
// Contexts provide the glue between the underlying request data and the user controller.
func NewContextsWriter(filename string) (*ContextsWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["gotyperef"] = codegen.GoTypeRef
funcMap["gotypedef"] = codegen.GoTypeDef
funcMap["goify"] = codegen.Goify
funcMap["gotypename"] = codegen.GoTypeName
funcMap["gopkgtypename"] = codegen.GoPackageTypeName
funcMap["typeUnmarshaler"] = codegen.TypeUnmarshaler
funcMap["userTypeUnmarshalerImpl"] = codegen.UserTypeUnmarshalerImpl
funcMap["validationChecker"] = codegen.ValidationChecker
funcMap["tabs"] = codegen.Tabs
funcMap["add"] = func(a, b int) int { return a + b }
funcMap["gopkgtyperef"] = codegen.GoPackageTypeRef
ctxTmpl, err := template.New("context").Funcs(funcMap).Parse(ctxT)
if err != nil {
return nil, err
}
ctxNewTmpl, err := template.New("new").
Funcs(cw.FuncMap).
Funcs(template.FuncMap{
"newCoerceData": newCoerceData,
"arrayAttribute": arrayAttribute,
}).Parse(ctxNewT)
if err != nil {
return nil, err
}
ctxRespTmpl, err := template.New("response").Funcs(cw.FuncMap).Parse(ctxRespT)
if err != nil {
return nil, err
}
payloadTmpl, err := template.New("payload").Funcs(funcMap).Parse(payloadT)
if err != nil {
return nil, err
}
newPayloadTmpl, err := template.New("newpayload").Funcs(cw.FuncMap).Parse(newPayloadT)
if err != nil {
return nil, err
}
w := ContextsWriter{
GoGenerator: cw,
CtxTmpl: ctxTmpl,
CtxNewTmpl: ctxNewTmpl,
CtxRespTmpl: ctxRespTmpl,
PayloadTmpl: payloadTmpl,
NewPayloadTmpl: newPayloadTmpl,
}
return &w, nil
}
// Generate is the generator entry point called by the meta generator.
func Generate(api *design.APIDefinition) ([]string, error) {
app := kingpin.New("Swagger generator", "Swagger spec generator")
codegen.RegisterFlags(app)
_, err := app.Parse(os.Args[1:])
if err != nil {
return nil, fmt.Errorf(`invalid command line: %s. Command line was "%s"`,
err, strings.Join(os.Args, " "))
}
s, err := New(api)
if err != nil {
return nil, err
}
b, err := json.Marshal(s)
if err != nil {
return nil, err
}
swaggerDir := filepath.Join(codegen.OutputDir, "swagger")
os.RemoveAll(swaggerDir)
if err = os.MkdirAll(swaggerDir, 0755); err != nil {
return nil, err
}
swaggerFile := filepath.Join(swaggerDir, "swagger.json")
err = ioutil.WriteFile(swaggerFile, b, 0644)
if err != nil {
return nil, err
}
controllerFile := filepath.Join(swaggerDir, "swagger.go")
tmpl, err := template.New("swagger").Parse(swaggerTmpl)
if err != nil {
panic(err.Error()) // bug
}
gg := codegen.NewGoGenerator(controllerFile)
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
}
gg.WriteHeader(fmt.Sprintf("%s Swagger Spec", api.Name), "swagger", imports)
data := map[string]interface{}{
"spec": string(b),
}
err = tmpl.Execute(gg, data)
if err != nil {
return nil, err
}
if err := gg.FormatCode(); err != nil {
return nil, err
}
return []string{controllerFile, swaggerFile}, nil
}
// NewUserTypesWriter returns a contexts code writer.
// User types contain custom data structured defined in the DSL with "Type".
func NewUserTypesWriter(filename string) (*UserTypesWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["gotypedef"] = codegen.GoTypeDef
funcMap["goify"] = codegen.Goify
funcMap["gotypename"] = codegen.GoTypeName
userTypeTmpl, err := template.New("user type").Funcs(funcMap).Parse(userTypeT)
if err != nil {
return nil, err
}
w := UserTypesWriter{
GoGenerator: cw,
UserTypeTmpl: userTypeTmpl,
}
return &w, nil
}
func (g *Generator) generateMain(mainFile string, clientPkg string, funcs template.FuncMap, api *design.APIDefinition) error {
gg := codegen.NewGoGenerator(mainFile)
mainTmpl := template.Must(template.New("main").Funcs(funcs).Parse(mainTmpl))
registerCmdsTmpl := template.Must(template.New("registerCmds").Funcs(funcs).Parse(registerCmdsT))
imports := []*codegen.ImportSpec{
codegen.SimpleImport("os"),
codegen.SimpleImport(clientPkg),
codegen.SimpleImport("gopkg.in/alecthomas/kingpin.v2"),
}
for _, pkg := range SignerPackages {
imports = append(imports, codegen.SimpleImport(pkg))
}
if err := gg.WriteHeader("", "main", imports); err != nil {
return err
}
g.genfiles = append(g.genfiles, mainFile)
data := map[string]interface{}{
"API": api,
"Signers": Signers,
"Version": Version,
}
if err := mainTmpl.Execute(gg, data); err != nil {
return err
}
actions := make(map[string][]*design.ActionDefinition)
api.IterateResources(func(res *design.ResourceDefinition) error {
return res.IterateActions(func(action *design.ActionDefinition) error {
if as, ok := actions[action.Name]; ok {
actions[action.Name] = append(as, action)
} else {
actions[action.Name] = []*design.ActionDefinition{action}
}
return nil
})
})
if err := registerCmdsTmpl.Execute(gg, actions); err != nil {
return err
}
return gg.FormatCode()
}
// NewGenerator returns the application code generator.
func NewGenerator() (*Generator, error) {
app := kingpin.New("Code generator", "application code generator")
codegen.RegisterFlags(app)
NewCommand().RegisterFlags(app)
_, err := app.Parse(os.Args[1:])
if err != nil {
return nil, fmt.Errorf(`invalid command line: %s. Command line was "%s"`,
err, strings.Join(os.Args, " "))
}
outdir := AppOutputDir()
os.RemoveAll(outdir)
if err = os.MkdirAll(outdir, 0777); err != nil {
return nil, err
}
return &Generator{
GoGenerator: codegen.NewGoGenerator(outdir),
genfiles: []string{outdir},
}, nil
}
// NewUserTypesWriter returns a contexts code writer.
// User types contain custom data structured defined in the DSL with "Type".
func NewUserTypesWriter(filename string) (*UserTypesWriter, error) {
cw := codegen.NewGoGenerator(filename)
funcMap := cw.FuncMap
funcMap["gotypedef"] = codegen.GoTypeDef
funcMap["gotyperef"] = codegen.GoTypeRef
funcMap["goify"] = codegen.Goify
funcMap["gotypename"] = codegen.GoTypeName
funcMap["recursiveValidate"] = codegen.RecursiveChecker
funcMap["userTypeUnmarshalerImpl"] = codegen.UserTypeUnmarshalerImpl
funcMap["userTypeMarshalerImpl"] = codegen.UserTypeMarshalerImpl
userTypeTmpl, err := template.New("user type").Funcs(funcMap).Parse(userTypeT)
if err != nil {
return nil, err
}
w := UserTypesWriter{
GoGenerator: cw,
UserTypeTmpl: userTypeTmpl,
}
return &w, nil
}
func (g *Generator) generateClient(clientFile string, clientPkg string, funcs template.FuncMap, api *design.APIDefinition) error {
gg := codegen.NewGoGenerator(clientFile)
clientTmpl := template.Must(template.New("client").Funcs(funcs).Parse(clientTmpl))
imports := []*codegen.ImportSpec{
codegen.SimpleImport("net/http"),
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport("gopkg.in/alecthomas/kingpin.v2"),
}
if err := gg.WriteHeader("", "client", imports); err != nil {
return err
}
g.genfiles = append(g.genfiles, clientFile)
if err := clientTmpl.Execute(gg, api); err != nil {
return err
}
return gg.FormatCode()
}
func (g *Generator) generateCommands(commandsFile string, clientPkg string, funcs template.FuncMap, api *design.APIDefinition) error {
gg := codegen.NewGoGenerator(commandsFile)
commandTypesTmpl := template.Must(template.New("commandTypes").Funcs(funcs).Parse(commandTypesTmpl))
commandsTmpl := template.Must(template.New("commands").Funcs(funcs).Parse(commandsTmpl))
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport(clientPkg),
codegen.NewImport("log", "gopkg.in/inconshreveable/log15.v2"),
codegen.SimpleImport("gopkg.in/alecthomas/kingpin.v2"),
}
if err := gg.WriteHeader("", "main", imports); err != nil {
return err
}
g.genfiles = append(g.genfiles, commandsFile)
gg.Write([]byte("type (\n"))
if err := api.IterateResources(func(res *design.ResourceDefinition) error {
return res.IterateActions(func(action *design.ActionDefinition) error {
return commandTypesTmpl.Execute(gg, action)
})
}); err != nil {
return err
}
gg.Write([]byte(")\n\n"))
if err := api.IterateResources(func(res *design.ResourceDefinition) error {
return res.IterateActions(func(action *design.ActionDefinition) error {
data := map[string]interface{}{
"Action": action,
"Resource": action.Parent,
"Version": design.Design.APIVersionDefinition,
}
return commandsTmpl.Execute(gg, data)
})
}); err != nil {
return err
}
return gg.FormatCode()
}
// Generate produces the skeleton main.
func (g *Generator) Generate(api *design.APIDefinition) (_ []string, err error) {
go utils.Catch(nil, func() { g.Cleanup() })
defer func() {
if err != nil {
g.Cleanup()
}
}()
os.RemoveAll(JSONSchemaDir())
os.MkdirAll(JSONSchemaDir(), 0755)
g.genfiles = append(g.genfiles, JSONSchemaDir())
s := APISchema(api)
js, err := s.JSON()
if err != nil {
return
}
schemaFile := filepath.Join(JSONSchemaDir(), "schema.json")
if err = ioutil.WriteFile(schemaFile, js, 0755); err != nil {
return
}
g.genfiles = append(g.genfiles, schemaFile)
controllerFile := filepath.Join(JSONSchemaDir(), "schema.go")
gg := codegen.NewGoGenerator(controllerFile)
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/julienschmidt/httprouter"),
codegen.SimpleImport("github.com/raphael/goa"),
}
g.genfiles = append(g.genfiles, controllerFile)
gg.WriteHeader(fmt.Sprintf("%s JSON Hyper-schema", api.Name), "schema", imports)
gg.Write([]byte(jsonSchemaCtrl))
if err = gg.FormatCode(); err != nil {
return
}
return g.genfiles, nil
}
// Generate produces the skeleton main.
func (g *Generator) Generate(api *design.APIDefinition) ([]string, error) {
os.RemoveAll(JSONSchemaDir())
os.MkdirAll(JSONSchemaDir(), 0755)
s := APISchema(api)
js, err := s.JSON()
if err != nil {
return nil, err
}
schemaFile := filepath.Join(JSONSchemaDir(), "schema.json")
if err := ioutil.WriteFile(schemaFile, js, 0755); err != nil {
return nil, err
}
g.genfiles = append(g.genfiles, schemaFile)
controllerFile := filepath.Join(JSONSchemaDir(), "schema.go")
tmpl, err := template.New("schema").Parse(jsonSchemaTmpl)
if err != nil {
panic(err.Error()) // bug
}
gg := codegen.NewGoGenerator(controllerFile)
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
}
gg.WriteHeader(fmt.Sprintf("%s JSON Hyper-schema", api.Name), "schema", imports)
data := map[string]interface{}{
"schema": string(js),
}
err = tmpl.Execute(gg, data)
if err != nil {
g.Cleanup()
return nil, err
}
if err := gg.FormatCode(); err != nil {
g.Cleanup()
return nil, err
}
g.genfiles = []string{controllerFile, schemaFile}
return g.genfiles, nil
}
func (g *Generator) generateExample(api *design.APIDefinition) error {
exampleTmpl := template.Must(template.New("exampleController").Parse(exampleCtrlT))
controllerFile := filepath.Join(codegen.OutputDir, "example.go")
gg := codegen.NewGoGenerator(controllerFile)
imports := []*codegen.ImportSpec{
codegen.SimpleImport("net/http"),
codegen.SimpleImport("github.com/julienschmidt/httprouter"),
codegen.SimpleImport("github.com/raphael/goa"),
}
if err := gg.WriteHeader(fmt.Sprintf("%s JavaScript Client Example", api.Name), "js", imports); err != nil {
return err
}
g.genfiles = append(g.genfiles, controllerFile)
data := map[string]interface{}{
"ServeDir": codegen.OutputDir,
}
if err := exampleTmpl.Execute(gg, data); err != nil {
return err
}
return gg.FormatCode()
}
// Generate produces the skeleton main.
func (g *Generator) Generate(api *design.APIDefinition) ([]string, error) {
mainFile := filepath.Join(codegen.OutputDir, "main.go")
if Force {
os.Remove(mainFile)
}
_, err := os.Stat(mainFile)
funcs := template.FuncMap{
"tempvar": tempvar,
"generateJSONSchema": generateJSONSchema,
"goify": codegen.Goify,
"okResp": okResp,
}
if err != nil {
tmpl, err := template.New("main").Funcs(funcs).Parse(mainTmpl)
if err != nil {
panic(err.Error()) // bug
}
gg := codegen.NewGoGenerator(mainFile)
g.genfiles = []string{mainFile}
outPkg, err := filepath.Rel(os.Getenv("GOPATH"), codegen.OutputDir)
if err != nil {
return nil, err
}
outPkg = strings.TrimPrefix(outPkg, "src/")
appPkg := filepath.Join(outPkg, "app")
swaggerPkg := filepath.Join(outPkg, "swagger")
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport(appPkg),
codegen.SimpleImport(swaggerPkg),
codegen.NewImport("log", "gopkg.in/inconshreveable/log15.v2"),
}
if generateJSONSchema() {
jsonSchemaPkg := filepath.Join(outPkg, "schema")
imports = append(imports, codegen.SimpleImport(jsonSchemaPkg))
}
gg.WriteHeader("", "main", imports)
data := map[string]interface{}{
"Name": AppName,
"Resources": api.Resources,
}
err = tmpl.Execute(gg, data)
if err != nil {
g.Cleanup()
return nil, err
}
if err := gg.FormatCode(); err != nil {
g.Cleanup()
return nil, err
}
}
tmpl, err := template.New("ctrl").Funcs(funcs).Parse(ctrlTmpl)
if err != nil {
panic(err.Error()) // bug
}
imp, err := filepath.Rel(filepath.Join(os.Getenv("GOPATH"), "src"), codegen.OutputDir)
if err != nil {
return nil, err
}
imp = filepath.Join(imp, "app")
imports := []*codegen.ImportSpec{codegen.SimpleImport(imp)}
err = api.IterateResources(func(r *design.ResourceDefinition) error {
filename := filepath.Join(codegen.OutputDir, snakeCase(r.Name)+".go")
if Force {
if err := os.Remove(filename); err != nil {
return err
}
}
if _, err := os.Stat(filename); err != nil {
resGen := codegen.NewGoGenerator(filename)
g.genfiles = append(g.genfiles, filename)
resGen.WriteHeader("", "main", imports)
err := tmpl.Execute(resGen, r)
if err != nil {
g.Cleanup()
return err
}
if err := resGen.FormatCode(); err != nil {
g.Cleanup()
return err
}
}
return nil
})
if err != nil {
g.Cleanup()
return nil, err
}
return g.genfiles, nil
}
// Generate produces the skeleton main.
func (g *Generator) Generate(api *design.APIDefinition) (_ []string, err error) {
go utils.Catch(nil, func() { g.Cleanup() })
defer func() {
if err != nil {
g.Cleanup()
}
}()
mainFile := filepath.Join(codegen.OutputDir, "main.go")
if Force {
os.Remove(mainFile)
}
g.genfiles = append(g.genfiles, mainFile)
_, err = os.Stat(mainFile)
funcs := template.FuncMap{
"tempvar": tempvar,
"generateSwagger": generateSwagger,
"goify": codegen.Goify,
"okResp": okResp,
"newControllerVersion": newControllerVersion,
"versionPkg": codegen.VersionPackage,
"targetPkg": func() string { return TargetPackage },
}
gopath := filepath.SplitList(os.Getenv("GOPATH"))[0]
if err != nil {
var tmpl *template.Template
tmpl, err = template.New("main").Funcs(funcs).Parse(mainTmpl)
if err != nil {
panic(err.Error()) // bug
}
gg := codegen.NewGoGenerator(mainFile)
var outPkg string
outPkg, err = filepath.Rel(gopath, codegen.OutputDir)
if err != nil {
return
}
outPkg = strings.TrimPrefix(filepath.ToSlash(outPkg), "src/")
appPkg := path.Join(outPkg, "app")
swaggerPkg := path.Join(outPkg, "swagger")
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport(appPkg),
codegen.SimpleImport(swaggerPkg),
codegen.NewImport("log", "gopkg.in/inconshreveable/log15.v2"),
}
if generateSwagger() {
jsonSchemaPkg := path.Join(outPkg, "schema")
imports = append(imports, codegen.SimpleImport(jsonSchemaPkg))
}
gg.WriteHeader("", "main", imports)
data := map[string]interface{}{
"Name": AppName,
"API": api,
}
if err = tmpl.Execute(gg, data); err != nil {
return
}
if err = gg.FormatCode(); err != nil {
return
}
}
tmpl, err := template.New("ctrl").Funcs(funcs).Parse(ctrlTmpl)
if err != nil {
panic(err.Error()) // bug
}
imp, err := filepath.Rel(filepath.Join(gopath, "src"), codegen.OutputDir)
if err != nil {
return
}
imp = path.Join(filepath.ToSlash(imp), "app")
imports := []*codegen.ImportSpec{codegen.SimpleImport(imp)}
api.IterateVersions(func(v *design.APIVersionDefinition) error {
if v.IsDefault() {
return nil
}
imports = append(imports, codegen.SimpleImport(imp+"/"+codegen.Goify(v.Version, false)))
return nil
})
err = api.IterateResources(func(r *design.ResourceDefinition) error {
filename := filepath.Join(codegen.OutputDir, snakeCase(r.Name)+".go")
if Force {
if err := os.Remove(filename); err != nil {
return err
}
}
g.genfiles = append(g.genfiles, filename)
if _, err := os.Stat(filename); err != nil {
resGen := codegen.NewGoGenerator(filename)
resGen.WriteHeader("", "main", imports)
err := tmpl.Execute(resGen, r)
if err != nil {
return err
}
if err := resGen.FormatCode(); err != nil {
return err
}
}
return nil
})
if err != nil {
return
}
return g.genfiles, nil
}
// Generate compiles and runs the generator and returns the generated filenames.
func (m *Generator) Generate() ([]string, error) {
// First make sure environment is setup correctly.
if codegen.OutputDir == "" {
return nil, fmt.Errorf("missing output directory specification")
}
if codegen.DesignPackagePath == "" {
return nil, fmt.Errorf("missing design package path specification")
}
if err := os.MkdirAll(codegen.OutputDir, 0755); err != nil {
return nil, err
}
gopath := os.Getenv("GOPATH")
if gopath == "" {
return nil, fmt.Errorf("$GOPATH not defined")
}
candidates := strings.Split(gopath, ":")
for i, c := range candidates {
candidates[i] = filepath.Join(c, "src", codegen.DesignPackagePath)
}
var designPath string
for _, path := range candidates {
if _, err := os.Stat(path); err == nil {
designPath = path
break
}
}
if designPath == "" {
if len(candidates) == 1 {
return nil, fmt.Errorf(`cannot find design package at path "%s"`, candidates[0])
}
return nil, fmt.Errorf(`cannot find design package in any of the paths %s`, strings.Join(candidates, ", "))
}
_, err := exec.LookPath("go")
if err != nil {
return nil, fmt.Errorf(`failed to find a go compiler, looked in "%s"`, os.Getenv("PATH"))
}
// Create temporary directory used for generation under the output dir.
gendir, err := ioutil.TempDir(codegen.OutputDir, "goagen")
if err != nil {
if _, ok := err.(*os.PathError); ok {
err = fmt.Errorf(`invalid output directory path "%s"`, codegen.OutputDir)
}
return nil, err
}
defer func() {
if !codegen.Debug {
os.RemoveAll(gendir)
}
}()
if codegen.Debug {
fmt.Printf("goagen source dir: %s\n", gendir)
}
// Figure out design package name from its path
fset := token.NewFileSet()
pkgs, err := parser.ParseDir(fset, designPath, nil, parser.PackageClauseOnly)
if err != nil {
return nil, err
}
pkgNames := make([]string, len(pkgs))
i := 0
for n := range pkgs {
pkgNames[i] = n
i++
}
if len(pkgs) > 1 {
return nil, fmt.Errorf("more than one Go package found in %s (%s)",
designPath, strings.Join(pkgNames, ","))
}
if len(pkgs) == 0 {
return nil, fmt.Errorf("no Go package found in %s", designPath)
}
pkgName := pkgNames[0]
// Generate tool source code.
filename := filepath.Join(gendir, "main.go")
m.GoGenerator = codegen.NewGoGenerator(filename)
imports := append(m.Imports,
codegen.SimpleImport("fmt"),
codegen.SimpleImport("os"),
codegen.SimpleImport("strings"),
codegen.NewImport(".", "github.com/raphael/goa/design"),
codegen.NewImport(".", "github.com/raphael/goa/design/dsl"),
codegen.NewImport("_", codegen.DesignPackagePath),
)
m.WriteHeader("Code Generator", "main", imports)
tmpl, err := template.New("generator").Parse(mainTmpl)
if err != nil {
panic(err) // bug
}
context := map[string]string{
"Genfunc": m.Genfunc,
"DesignPackage": codegen.DesignPackagePath,
"PkgName": pkgName,
}
err = tmpl.Execute(m, context)
if err != nil {
panic(err) // bug
}
if codegen.Debug {
src, _ := ioutil.ReadFile(filename)
fmt.Printf("goagen source:\n%s\n", src)
}
// Compile and run generated tool.
genbin, err := m.compile(gendir)
if err != nil {
return nil, err
}
return m.spawn(genbin)
}