func (g *Generator) generateSwagger() (*spec.Swagger, error) {
contact := &spec.ContactInfo{
Name: "API Support",
URL: "api-suport.url",
Email: "*****@*****.**",
}
license := &spec.License{
Name: "APACHE-2.0",
URL: "url://to/license",
}
info := new(spec.Info)
info.Description = "API description"
info.Title = "API title"
info.TermsOfService = "url://to/tos"
info.Contact = contact
info.License = license
info.Version = "v1"
sw := new(spec.Swagger)
sw.Swagger = "2.0"
sw.Info = info
// sw.Consumes = []string{"application/x-www-form-urlencoded", "application/json", "application/x-protobuf"}
// sw.Produces = []string{"application/json", "application/x-protobuf"}
// TODO(ceram1): Make this configurable.
sw.BasePath = "/api/"
sw.Host = "authagain.appspot.com"
sw.Paths = new(spec.Paths)
sw.Paths.Paths = make(map[string]spec.PathItem)
sw.Definitions = make(map[string]spec.Schema)
sw.Schemes = []string{"https", "http"}
for _, svc := range g.file.Services {
info.Title = svc.GetName() + " API"
if cmt := g.file.GetCommentText(svc.CommentPath); cmt != nil {
info.Description = *cmt
}
for _, mtd := range svc.Methods {
for _, b := range mtd.Bindings {
var p *spec.PathItem
path := buildPath(b.PathTmpl)
if pi, ok := sw.Paths.Paths[path]; !ok {
p = new(spec.PathItem)
} else {
p = &pi
}
op := g.generateOperation(b)
if b.HTTPMethod == "GET" {
p.Get = op
} else if b.HTTPMethod == "POST" {
p.Post = op
} else if b.HTTPMethod == "PUT" {
p.Put = op
} else if b.HTTPMethod == "DELETE" {
p.Delete = op
} else {
return nil, fmt.Errorf("Unknown http method `%v`", b.HTTPMethod)
}
sw.Paths.Paths[path] = *p
}
}
}
for _, msg := range g.file.Messages {
def := g.generateDefinition(msg)
sw.Definitions[def.Title] = *def
}
sw.Info = info
return sw, nil
}
func metaTOSSetter(meta *spec.Info) func([]string) {
return func(lines []string) {
meta.TermsOfService = joinDropLast(lines)
}
}
// 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
}