/
intermediate_definition.go
121 lines (103 loc) · 3.14 KB
/
intermediate_definition.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package main
import (
"github.com/go-openapi/spec"
"strings"
)
type DefinitionIntermediate struct {
Comment string
Documentation string
EmbeddedTypes []string
Members map[string]SchemerDefiner // map[name]schemer
Name string
PackageName string // The actual package name of this type.
PackagePath string // The actual package path of this type.
UnderlyingType string // This isn't used right now. In our test codebase, non-struct types were never used.
Enums []interface{} // If the underlying type is a primitive type, it's assumed it's an enum type, these being the values.
// While it may not strictly be equivalent from a language specification
// perspective, we're going to call a non-struct type with an underlying
// type equivalent to a struct type with a single embedded type.
//
// By doing this, we'll only need to write a single algorithm to flatten the
// types for Swagger.
}
func (this *DefinitionIntermediate) CanonicalName() string {
name := this.PackagePath + "." + this.Name
name = strings.Replace(name, "/", ".", -1)
return name
}
func (this *DefinitionIntermediate) SwaggerName() string {
var name string
switch *naming {
case "full":
name = this.CanonicalName()
case "partial":
name = this.PackageName + "." + this.Name
case "simple":
name = this.Name
}
return name
}
func (this *DefinitionIntermediate) Schema() spec.Schema {
var schema spec.Schema
schema.Title = this.SwaggerName()
if isPrimitive, t, f := IsPrimitive(this.UnderlyingType); isPrimitive {
schema.Typed(t, f)
schema.Enum = this.Enums
} else {
schema.Typed("object", "")
schema.Required = make([]string, 0)
properties := make(map[string]spec.Schema)
for _, member := range this.Members {
property := member.Schema()
properties[property.Title] = *property
if member.IsRequired() {
schema.Required = append(schema.Required, property.Title)
}
}
schema.Properties = properties
}
return schema
}
//func (this *DefinitionIntermediate) DefineDefinitions() error {
//
// var err error
// goType := this.Name
// if isPrimitive, _, _ := IsPrimitive(goType); isPrimitive {
// // This was never hit with our test code base.
// return nil
// }
//
// for _, embeddedType := range this.EmbeddedTypes {
// definition, ok := definitionStore.ExistsDefinition(this.PackagePath, embeddedType)
// if !ok {
// definition, err = findDefinition(this.PackagePath, embeddedType)
// if err != nil {
// return errors.Stack(err)
// } else if definition == nil {
// return errors.Newf("Failed to find definition for embedded member: %s:%s", goType, embeddedType)
// }
//
// definitionStore.Add(definition)
// }
//
// mergeDefinitions(this, definition)
// }
//
// for _, member := range this.Members {
// err := member.DefineDefinitions(this.PackagePath)
// if err != nil {
// return errors.Stack(err)
// }
// }
//
// return nil
//}
func mergeDefinitions(dst, src *DefinitionIntermediate) {
for srcName, srcMember := range src.Members {
_, exists := dst.Members[srcName]
if !exists {
srcMember.SetPackagePath(src.PackagePath)
dst.Members[srcName] = srcMember
}
}
}