func (m *Generator) generateToolSourceCode(pkg *codegen.Package) {
file := pkg.CreateSourceFile("main.go")
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("_", filepath.ToSlash(codegen.DesignPackagePath)),
)
file.WriteHeader("Code Generator", "main", imports)
tmpl, err := template.New("generator").Parse(mainTmpl)
if err != nil {
panic(err) // bug
}
pkgName, err := codegen.PackageName(pkg.Abs())
if err != nil {
panic(err)
}
context := map[string]string{
"Genfunc": m.Genfunc,
"DesignPackage": codegen.DesignPackagePath,
"PkgName": pkgName,
}
err = tmpl.Execute(file, context)
if err != nil {
panic(err) // bug
}
if codegen.Debug {
src, _ := ioutil.ReadFile(file.Abs())
fmt.Printf("goagen source:\n%s\n", src)
}
}
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)
}
}
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, 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)
}
// 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,
"okResp": okResp,
"newControllerVersion": newControllerVersion,
"targetPkg": func() string { return TargetPackage },
}
if err != nil {
file, err := codegen.SourceFileFor(mainFile)
if err != nil {
return nil, err
}
var outPkg string
outPkg, err = codegen.PackagePath(codegen.OutputDir)
if err != nil {
return nil, err
}
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))
}
file.WriteHeader("", "main", imports)
data := map[string]interface{}{
"Name": AppName,
"API": api,
}
if err = file.ExecuteTemplate("main", mainT, funcs, data); err != nil {
return nil, err
}
if err = file.FormatCode(); err != nil {
return nil, err
}
}
imp, err := codegen.PackagePath(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.VersionPackage(v.Version)))
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 {
file, err := codegen.SourceFileFor(filename)
if err != nil {
return err
}
file.WriteHeader("", "main", imports)
err = file.ExecuteTemplate("controller", ctrlT, funcs, r)
if err != nil {
return err
}
if err := file.FormatCode(); err != nil {
return err
}
}
return nil
})
if err != nil {
return
}
return g.genfiles, nil
}