func (a *appGenerator) Generate() error { app := a.makeCodegenApp() if a.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(app), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } if err := a.generateAPIBuilder(&app); err != nil { return err } importPath := filepath.ToSlash(filepath.Join(baseImport(a.Target), a.ServerPackage, a.APIPackage)) app.DefaultImports = append(app.DefaultImports, importPath) if err := a.generateConfigureAPI(&app); err != nil { return err } if err := a.generateMain(&app); err != nil { return err } return nil }
// Validate validates the data against the schema func (s *SchemaValidator) Validate(data interface{}) *Result { if data == nil { v := s.validators[0].Validate(data) v.Merge(s.validators[6].Validate(data)) return v } result := new(Result) tpe := reflect.TypeOf(data) kind := tpe.Kind() for kind == reflect.Ptr { tpe = tpe.Elem() kind = tpe.Kind() } d := data if kind == reflect.Struct { d = swag.ToDynamicJSON(data) } for _, v := range s.validators { if !v.Applies(s.Schema, kind) { continue } err := v.Validate(d) result.Merge(err) result.Inc() } result.Inc() return result }
func (t *testGenerator) GenerateTest() error { test := t.makeCodegenTest() if t.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(test), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } test.DefaultImports = append(test.DefaultImports, filepath.Join(baseImport(t.Target), t.ServerPackage, t.APIPackage)) if t.IncludeTCK { if err := t.generateTCK(&test); err != nil { return err } } if err := t.generateSuiteTest(&test); err != nil { return err } for _, operation := range test.Operations { test.OperationID = operation.Name if err := t.generateTest(&operation, &test); err != nil { return err } } return nil }
func (m *modelGenerator) Generate() error { mod := makeCodegenModel(m.Name, m.Target, m.Model, m.SpecDoc) if m.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(mod), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } m.Data = mod if m.IncludeModel { if err := m.generateModel(); err != nil { return fmt.Errorf("model: %s", err) } } log.Println("generated model", m.Name) if m.IncludeValidator { if err := m.generateValidator(); err != nil { return fmt.Errorf("validator: %s", err) } } log.Println("generated validator", m.Name) return nil }
func (c *clientGenerator) Generate() error { app, err := c.makeCodegenApp() app.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ModelsPackage))} if err != nil { return err } if c.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(app), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } for _, mod := range app.Models { mod.IncludeValidator = true // a.GenOpts.IncludeValidator gen := &definitionGenerator{ Name: mod.Name, SpecDoc: c.SpecDoc, Target: filepath.Join(c.Target, c.ModelsPackage), Data: &mod, } if err := gen.generateModel(); err != nil { return err } } for i := range app.OperationGroups { opGroup := app.OperationGroups[i] opGroup.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ModelsPackage))} opGroup.RootPackage = c.ClientPackage app.OperationGroups[i] = opGroup sort.Sort(opGroup.Operations) for _, op := range opGroup.Operations { if op.Package == "" { op.Package = c.Package } if err := c.generateParameters(&op); err != nil { return err } if err := c.generateResponses(&op); err != nil { return err } } app.DefaultImports = append(app.DefaultImports, filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ClientPackage, opGroup.Name))) if err := c.generateGroupClient(opGroup); err != nil { return err } } sort.Sort(app.OperationGroups) if err := c.generateFacade(&app); err != nil { return err } return nil }
func (a *appGenerator) Generate() error { app, err := a.makeCodegenApp() if err != nil { return err } if a.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(app), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } if a.GenOpts.IncludeModel { log.Printf("rendering %d models", len(app.Models)) for _, mod := range app.Models { mod.IncludeValidator = true // a.GenOpts.IncludeValidator gen := &definitionGenerator{ Name: mod.Name, SpecDoc: a.SpecDoc, Target: filepath.Join(a.Target, a.ModelsPackage), Data: &mod, } if err := gen.generateModel(); err != nil { return err } } } if a.GenOpts.IncludeHandler { for _, opg := range app.OperationGroups { for _, op := range opg.Operations { gen := &opGen{ data: &op, pkg: opg.Name, cname: swag.ToGoName(op.Name), IncludeHandler: a.GenOpts.IncludeHandler, IncludeParameters: a.GenOpts.IncludeParameters, IncludeResponses: a.GenOpts.IncludeResponses, Doc: a.SpecDoc, Target: filepath.Join(a.Target, a.ServerPackage), APIPackage: a.APIPackage, } if err := gen.Generate(); err != nil { return err } } } } if a.GenOpts.IncludeSupport { return a.GenerateSupport(&app) } return nil }
func (o *operationGenerator) Generate() error { // Build a list of codegen operations based on the tags, // the tag decides the actual package for an operation // the user specified package serves as root for generating the directory structure var operations []genOperation authed := len(o.SecurityRequirements) > 0 for _, tag := range o.Operation.Tags { if len(o.Tags) == 0 { operations = append(operations, makeCodegenOperation(o.Name, tag, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed)) continue } for _, ft := range o.Tags { if ft == tag { operations = append(operations, makeCodegenOperation(o.Name, tag, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed)) break } } } if len(operations) == 0 { operations = append(operations, makeCodegenOperation(o.Name, o.APIPackage, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed)) } for _, op := range operations { if o.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(op), "", " ") fmt.Fprintln(os.Stdout, string(bb)) continue } o.data = op o.pkg = op.Package o.cname = op.ClassName if o.IncludeHandler { if err := o.generateHandler(); err != nil { return fmt.Errorf("handler: %s", err) } log.Println("generated handler", op.Package+"."+op.ClassName) } if o.IncludeParameters && len(o.Operation.Parameters) > 0 { if err := o.generateParameterModel(); err != nil { return fmt.Errorf("parameters: %s", err) } log.Println("generated parameters", op.Package+"."+op.ClassName+"Parameters") } if len(o.Operation.Parameters) == 0 { log.Println("no parameters for operation", op.Package+"."+op.ClassName) } } return nil }
func (c *clientGenerator) Generate() error { app, err := c.makeCodegenApp() app.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ModelsPackage))} if err != nil { return err } if c.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(app), "", " ") fmt.Fprintln(os.Stdout, string(bb)) return nil } opsGroupedByTag := make(map[string]GenOperations) for _, operation := range app.Operations { if operation.Package == "" { operation.Package = c.Package } if err := c.generateParameters(&operation); err != nil { return err } if err := c.generateResponses(&operation); err != nil { return err } opsGroupedByTag[operation.Package] = append(opsGroupedByTag[operation.Package], operation) } for k, v := range opsGroupedByTag { sort.Sort(v) opGroup := GenOperationGroup{ Name: k, Operations: v, DefaultImports: []string{filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ModelsPackage))}, } app.OperationGroups = append(app.OperationGroups, opGroup) app.DefaultImports = append(app.DefaultImports, filepath.ToSlash(filepath.Join(baseImport(c.Target), c.ClientPackage, k))) if err := c.generateGroupClient(opGroup); err != nil { return err } } sort.Sort(app.OperationGroups) if err := c.generateEmbeddedSwaggerJSON(&app); err != nil { return err } if err := c.generateFacade(&app); err != nil { return err } return nil }
func (m *definitionGenerator) generateModel() error { buf := bytes.NewBuffer(nil) if Debug { log.Printf("rendering model template: %s", m.Name) bb, _ := json.MarshalIndent(swag.ToDynamicJSON(m.Data), "", " ") fmt.Fprintln(os.Stdout, string(bb)) } if err := modelTemplate.Execute(buf, m.Data); err != nil { return err } log.Println("rendered model template:", m.Name) return writeToFile(m.Target, m.Name, buf.Bytes()) }
func (o *operationGenerator) Generate() error { // Build a list of codegen operations based on the tags, // the tag decides the actual package for an operation // the user specified package serves as root for generating the directory structure var operations GenOperations authed := len(o.SecurityRequirements) > 0 var bldr codeGenOpBuilder bldr.Name = o.Name bldr.Method = o.Method bldr.Path = o.Path bldr.ModelsPackage = o.ModelsPackage bldr.Principal = o.Principal bldr.Target = o.Target bldr.Operation = o.Operation bldr.Authed = authed bldr.Doc = o.Doc bldr.DefaultScheme = o.DefaultScheme bldr.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(o.Base), o.ModelsPackage))} for _, tag := range o.Operation.Tags { if len(o.Tags) == 0 { bldr.APIPackage = mangleName(swag.ToFileName(tag), o.APIPackage) op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) continue } for _, ft := range o.Tags { if ft == tag { bldr.APIPackage = mangleName(swag.ToFileName(tag), o.APIPackage) op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) break } } } if len(operations) == 0 { bldr.APIPackage = o.APIPackage op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) } sort.Sort(operations) for _, op := range operations { if o.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(op), "", " ") fmt.Fprintln(os.Stdout, string(bb)) continue } o.data = op o.pkg = op.Package o.cname = swag.ToGoName(op.Name) if o.IncludeHandler { if err := o.generateHandler(); err != nil { return fmt.Errorf("handler: %s", err) } log.Println("generated handler", op.Package+"."+o.cname) } opParams := o.Doc.ParametersFor(o.Operation.ID) if o.IncludeParameters && len(opParams) > 0 { if err := o.generateParameterModel(); err != nil { return fmt.Errorf("parameters: %s", err) } log.Println("generated parameters", op.Package+"."+o.cname+"Parameters") } if o.IncludeResponses && len(op.Responses) > 0 { if err := o.generateResponses(); err != nil { return fmt.Errorf("responses: %s", err) } log.Println("generated responses", op.Package+"."+o.cname+"Responses") } if len(opParams) == 0 { log.Println("no parameters for operation", op.Package+"."+o.cname) } } return nil }
func (o *operationGenerator) Generate() error { // Build a list of codegen operations based on the tags, // the tag decides the actual package for an operation // the user specified package serves as root for generating the directory structure var operations GenOperations authed := len(o.SecurityRequirements) > 0 var bldr codeGenOpBuilder bldr.Name = o.Name bldr.Method = o.Method bldr.Path = o.Path bldr.ModelsPackage = o.ModelsPackage bldr.Principal = o.Principal bldr.Target = o.Target bldr.Operation = o.Operation bldr.Authed = authed bldr.Doc = o.Doc bldr.DefaultScheme = o.DefaultScheme bldr.DefaultProduces = o.DefaultProduces bldr.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(o.Base), o.ModelsPackage))} bldr.RootAPIPackage = o.APIPackage for _, tag := range o.Operation.Tags { if len(o.Tags) == 0 { bldr.APIPackage = mangleName(swag.ToFileName(tag), o.APIPackage) op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) continue } for _, ft := range o.Tags { if ft == tag { bldr.APIPackage = mangleName(swag.ToFileName(tag), o.APIPackage) op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) break } } } if len(operations) == 0 { bldr.APIPackage = o.APIPackage op, err := bldr.MakeOperation() if err != nil { return err } operations = append(operations, op) } sort.Sort(operations) for _, op := range operations { if o.DumpData { bb, _ := json.MarshalIndent(swag.ToDynamicJSON(op), "", " ") fmt.Fprintln(os.Stdout, string(bb)) continue } og := new(opGen) og.IncludeHandler = o.IncludeHandler og.IncludeParameters = o.IncludeParameters og.IncludeResponses = o.IncludeResponses og.data = &op og.pkg = op.Package og.cname = swag.ToGoName(op.Name) og.Doc = o.Doc og.Target = o.Target og.APIPackage = o.APIPackage return og.Generate() } return nil }
// Execute this command func (s *Spec) Execute(args []string) error { targetPath := "." if len(args) > 0 { targetPath = args[0] } realPath, err := filepath.Abs(targetPath) if err != nil { return err } var file *os.File switch s.Format { case "json": file, err = os.Create(filepath.Join(realPath, "swagger.json")) if err != nil { return err } case "yaml", "yml": file, err = os.Create(filepath.Join(realPath, "swagger.yml")) if err != nil { return err } default: return fmt.Errorf("invalid format: %s", s.Format) } defer file.Close() log.Println("creating specification document in", filepath.Join(targetPath, file.Name())) var doc spec.Swagger info := new(spec.Info) doc.Info = info doc.Swagger = "2.0" doc.Paths = new(spec.Paths) doc.Definitions = make(spec.Definitions) info.Title = s.Title if info.Title == "" { info.Title = swag.ToHumanNameTitle(filepath.Base(realPath)) } info.Description = s.Description info.Version = s.Version info.TermsOfService = s.Terms if s.Contact.Name != "" || s.Contact.Email != "" || s.Contact.URL != "" { var contact spec.ContactInfo contact.Name = s.Contact.Name contact.Email = s.Contact.Email contact.URL = s.Contact.URL info.Contact = &contact } if s.License.Name != "" || s.License.URL != "" { var license spec.License license.Name = s.License.Name license.URL = s.License.URL info.License = &license } for _, cons := range s.Consumes { doc.Consumes = append(doc.Consumes, cons) } for _, prods := range s.Produces { doc.Produces = append(doc.Produces, prods) } for _, scheme := range s.Schemes { doc.Schemes = append(doc.Schemes, scheme) } if s.Format == "json" { enc := json.NewEncoder(file) if err := enc.Encode(doc); err != nil { return err } return nil } b, err := yaml.Marshal(swag.ToDynamicJSON(doc)) if err != nil { return err } if _, err := file.Write(b); err != nil { return err } return nil }