// generateUserTypes iterates through the user types and generates the data structures and
// marshaling code.
func (g *Generator) generateUserTypes(verdir string, version *design.APIVersionDefinition) error {
utFile := filepath.Join(verdir, "user_types.go")
utWr, err := NewUserTypesWriter(utFile)
if err != nil {
panic(err) // bug
}
title := fmt.Sprintf("%s: Application User Types", version.Context())
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport("fmt"),
}
utWr.WriteHeader(title, packageName(version), imports)
err = version.IterateUserTypes(func(t *design.UserTypeDefinition) error {
data := &UserTypeTemplateData{
UserType: t,
Versioned: version.Version != "",
DefaultPkg: TargetPackage,
}
return utWr.Execute(data)
})
g.genfiles = append(g.genfiles, utFile)
if err != nil {
return err
}
return utWr.FormatCode()
}
// generateMediaTypes iterates through the media types and generate the data structures and
// marshaling code.
func (g *Generator) generateMediaTypes(verdir string, version *design.APIVersionDefinition) error {
mtFile := filepath.Join(verdir, "media_types.go")
mtWr, err := NewMediaTypesWriter(mtFile)
if err != nil {
panic(err) // bug
}
title := fmt.Sprintf("%s: Application Media Types", version.Context())
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/raphael/goa"),
codegen.SimpleImport("fmt"),
}
mtWr.WriteHeader(title, packageName(version), imports)
err = version.IterateMediaTypes(func(mt *design.MediaTypeDefinition) error {
data := &MediaTypeTemplateData{
MediaType: mt,
Versioned: version.Version != "",
DefaultPkg: TargetPackage,
}
if mt.Type.IsObject() || mt.Type.IsArray() {
return mtWr.Execute(data)
}
return nil
})
g.genfiles = append(g.genfiles, mtFile)
if err != nil {
return err
}
return mtWr.FormatCode()
}
// Trait defines an API trait. A trait encapsulates arbitrary DSL that gets executed wherever the
// trait is called via the UseTrait function.
func Trait(name string, val ...func()) {
var ver *design.APIVersionDefinition
if a, ok := apiDefinition(false); ok {
ver = a.APIVersionDefinition
} else if v, ok := versionDefinition(true); ok {
ver = v
}
if len(val) < 1 {
ReportError("missing trait DSL for %s", name)
return
} else if len(val) > 1 {
ReportError("too many arguments given to Trait")
return
}
if ver == nil {
return
}
if _, ok := ver.Traits[name]; ok {
ReportError("multiple definitions for trait %s%s", name, ver.Context())
return
}
trait := &design.TraitDefinition{Name: name, DSLFunc: val[0]}
if ver.Traits == nil {
ver.Traits = make(map[string]*design.TraitDefinition)
}
ver.Traits[name] = trait
}
// generateControllers iterates through the version resources and generates the low level
// controllers.
func (g *Generator) generateControllers(verdir string, version *design.APIVersionDefinition) error {
ctlFile := filepath.Join(verdir, "controllers.go")
ctlWr, err := NewControllersWriter(ctlFile)
if err != nil {
panic(err) // bug
}
title := fmt.Sprintf("%s: Application Controllers", version.Context())
imports := []*codegen.ImportSpec{
codegen.SimpleImport("github.com/julienschmidt/httprouter"),
codegen.SimpleImport("github.com/raphael/goa"),
}
if !version.IsDefault() {
appPkg, err := AppPackagePath()
if err != nil {
return err
}
imports = append(imports, codegen.SimpleImport(appPkg))
}
ctlWr.WriteHeader(title, packageName(version), imports)
var controllersData []*ControllerTemplateData
version.IterateResources(func(r *design.ResourceDefinition) error {
if !r.SupportsVersion(version.Version) {
return nil
}
data := &ControllerTemplateData{Resource: codegen.Goify(r.Name, true)}
err := r.IterateActions(func(a *design.ActionDefinition) error {
context := fmt.Sprintf("%s%sContext", codegen.Goify(a.Name, true), codegen.Goify(r.Name, true))
unmarshal := fmt.Sprintf("unmarshal%s%sPayload", codegen.Goify(a.Name, true), codegen.Goify(r.Name, true))
action := map[string]interface{}{
"Name": codegen.Goify(a.Name, true),
"Routes": a.Routes,
"Context": context,
"Unmarshal": unmarshal,
"Payload": a.Payload,
}
data.Actions = append(data.Actions, action)
return nil
})
if err != nil {
return err
}
if len(data.Actions) > 0 {
data.Version = version
controllersData = append(controllersData, data)
}
return nil
})
g.genfiles = append(g.genfiles, ctlFile)
if err = ctlWr.Execute(controllersData); err != nil {
return err
}
return ctlWr.FormatCode()
}
// generateContexts iterates through the version resources and actions and generates the action
// contexts.
func (g *Generator) generateContexts(verdir string, api *design.APIDefinition, version *design.APIVersionDefinition) error {
ctxFile := filepath.Join(verdir, "contexts.go")
ctxWr, err := NewContextsWriter(ctxFile)
if err != nil {
panic(err) // bug
}
title := fmt.Sprintf("%s: Application Contexts", version.Context())
imports := []*codegen.ImportSpec{
codegen.SimpleImport("fmt"),
codegen.SimpleImport("strconv"),
codegen.SimpleImport("github.com/raphael/goa"),
}
if !version.IsDefault() {
appPkg, err := AppPackagePath()
if err != nil {
return err
}
imports = append(imports, codegen.SimpleImport(filepath.ToSlash(appPkg)))
}
ctxWr.WriteHeader(title, packageName(version), imports)
var appPackage string
if !version.IsDefault() {
appPackage = TargetPackage
}
err = version.IterateResources(func(r *design.ResourceDefinition) error {
if !r.SupportsVersion(version.Version) {
return nil
}
return r.IterateActions(func(a *design.ActionDefinition) error {
ctxName := codegen.Goify(a.Name, true) + codegen.Goify(a.Parent.Name, true) + "Context"
ctxData := ContextTemplateData{
Name: ctxName,
ResourceName: r.Name,
ActionName: a.Name,
Payload: a.Payload,
Params: a.AllParams(),
Headers: r.Headers.Merge(a.Headers),
Routes: a.Routes,
Responses: MergeResponses(r.Responses, a.Responses),
API: api,
Version: version,
AppPackage: appPackage,
}
return ctxWr.Execute(&ctxData)
})
})
g.genfiles = append(g.genfiles, ctxFile)
if err != nil {
return err
}
return ctxWr.FormatCode()
}
// generateHrefs iterates through the version resources and generates the href factory methods.
func (g *Generator) generateHrefs(verdir string, version *design.APIVersionDefinition) error {
hrefFile := filepath.Join(verdir, "hrefs.go")
resWr, err := NewResourcesWriter(hrefFile)
if err != nil {
panic(err) // bug
}
title := fmt.Sprintf("%s: Application Resource Href Factories", version.Context())
resWr.WriteHeader(title, packageName(version), nil)
err = version.IterateResources(func(r *design.ResourceDefinition) error {
if !r.SupportsVersion(version.Version) {
return nil
}
m := design.Design.MediaTypeWithIdentifier(r.MediaType)
var identifier string
if m != nil {
identifier = m.Identifier
} else {
identifier = "plain/text"
}
canoTemplate := r.URITemplate(version)
canoTemplate = design.WildcardRegex.ReplaceAllLiteralString(canoTemplate, "/%v")
var canoParams []string
if ca := r.CanonicalAction(); ca != nil {
if len(ca.Routes) > 0 {
canoParams = ca.Routes[0].Params(version)
}
}
data := ResourceData{
Name: codegen.Goify(r.Name, true),
Identifier: identifier,
Description: r.Description,
Type: m,
CanonicalTemplate: canoTemplate,
CanonicalParams: canoParams,
}
return resWr.Execute(&data)
})
g.genfiles = append(g.genfiles, hrefFile)
if err != nil {
return err
}
return resWr.FormatCode()
}