forked from ebhomengo/niki
681 lines
14 KiB
Go
681 lines
14 KiB
Go
package swag
|
|
|
|
import (
|
|
"fmt"
|
|
"go/ast"
|
|
"reflect"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"unicode"
|
|
|
|
"github.com/go-openapi/spec"
|
|
)
|
|
|
|
var _ FieldParser = &tagBaseFieldParser{p: nil, field: nil, tag: ""}
|
|
|
|
const (
|
|
requiredLabel = "required"
|
|
optionalLabel = "optional"
|
|
swaggerTypeTag = "swaggertype"
|
|
swaggerIgnoreTag = "swaggerignore"
|
|
)
|
|
|
|
type tagBaseFieldParser struct {
|
|
p *Parser
|
|
field *ast.Field
|
|
tag reflect.StructTag
|
|
}
|
|
|
|
func newTagBaseFieldParser(p *Parser, field *ast.Field) FieldParser {
|
|
fieldParser := tagBaseFieldParser{
|
|
p: p,
|
|
field: field,
|
|
tag: "",
|
|
}
|
|
if fieldParser.field.Tag != nil {
|
|
fieldParser.tag = reflect.StructTag(strings.ReplaceAll(field.Tag.Value, "`", ""))
|
|
}
|
|
|
|
return &fieldParser
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) ShouldSkip() bool {
|
|
// Skip non-exported fields.
|
|
if ps.field.Names != nil && !ast.IsExported(ps.field.Names[0].Name) {
|
|
return true
|
|
}
|
|
|
|
if ps.field.Tag == nil {
|
|
return false
|
|
}
|
|
|
|
ignoreTag := ps.tag.Get(swaggerIgnoreTag)
|
|
if strings.EqualFold(ignoreTag, "true") {
|
|
return true
|
|
}
|
|
|
|
// json:"tag,hoge"
|
|
name := strings.TrimSpace(strings.Split(ps.tag.Get(jsonTag), ",")[0])
|
|
if name == "-" {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) FieldName() (string, error) {
|
|
var name string
|
|
|
|
if ps.field.Tag != nil {
|
|
// json:"tag,hoge"
|
|
name = strings.TrimSpace(strings.Split(ps.tag.Get(jsonTag), ",")[0])
|
|
if name != "" {
|
|
return name, nil
|
|
}
|
|
|
|
// use "form" tag over json tag
|
|
name = ps.FormName()
|
|
if name != "" {
|
|
return name, nil
|
|
}
|
|
}
|
|
|
|
if ps.field.Names == nil {
|
|
return "", nil
|
|
}
|
|
|
|
switch ps.p.PropNamingStrategy {
|
|
case SnakeCase:
|
|
return toSnakeCase(ps.field.Names[0].Name), nil
|
|
case PascalCase:
|
|
return ps.field.Names[0].Name, nil
|
|
default:
|
|
return toLowerCamelCase(ps.field.Names[0].Name), nil
|
|
}
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) firstTagValue(tag string) string {
|
|
if ps.field.Tag != nil {
|
|
return strings.TrimRight(strings.TrimSpace(strings.Split(ps.tag.Get(tag), ",")[0]), "[]")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) FormName() string {
|
|
return ps.firstTagValue(formTag)
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) HeaderName() string {
|
|
return ps.firstTagValue(headerTag)
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) PathName() string {
|
|
return ps.firstTagValue(uriTag)
|
|
}
|
|
|
|
func toSnakeCase(in string) string {
|
|
var (
|
|
runes = []rune(in)
|
|
length = len(runes)
|
|
out []rune
|
|
)
|
|
|
|
for idx := 0; idx < length; idx++ {
|
|
if idx > 0 && unicode.IsUpper(runes[idx]) &&
|
|
((idx+1 < length && unicode.IsLower(runes[idx+1])) || unicode.IsLower(runes[idx-1])) {
|
|
out = append(out, '_')
|
|
}
|
|
|
|
out = append(out, unicode.ToLower(runes[idx]))
|
|
}
|
|
|
|
return string(out)
|
|
}
|
|
|
|
func toLowerCamelCase(in string) string {
|
|
var flag bool
|
|
|
|
out := make([]rune, len(in))
|
|
|
|
runes := []rune(in)
|
|
for i, curr := range runes {
|
|
if (i == 0 && unicode.IsUpper(curr)) || (flag && unicode.IsUpper(curr)) {
|
|
out[i] = unicode.ToLower(curr)
|
|
flag = true
|
|
|
|
continue
|
|
}
|
|
|
|
out[i] = curr
|
|
flag = false
|
|
}
|
|
|
|
return string(out)
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) CustomSchema() (*spec.Schema, error) {
|
|
if ps.field.Tag == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
typeTag := ps.tag.Get(swaggerTypeTag)
|
|
if typeTag != "" {
|
|
return BuildCustomSchema(strings.Split(typeTag, ","))
|
|
}
|
|
|
|
return nil, nil
|
|
}
|
|
|
|
type structField struct {
|
|
schemaType string
|
|
arrayType string
|
|
formatType string
|
|
maximum *float64
|
|
minimum *float64
|
|
multipleOf *float64
|
|
maxLength *int64
|
|
minLength *int64
|
|
maxItems *int64
|
|
minItems *int64
|
|
exampleValue interface{}
|
|
enums []interface{}
|
|
enumVarNames []interface{}
|
|
unique bool
|
|
}
|
|
|
|
// splitNotWrapped slices s into all substrings separated by sep if sep is not
|
|
// wrapped by brackets and returns a slice of the substrings between those separators.
|
|
func splitNotWrapped(s string, sep rune) []string {
|
|
openCloseMap := map[rune]rune{
|
|
'(': ')',
|
|
'[': ']',
|
|
'{': '}',
|
|
}
|
|
|
|
var (
|
|
result = make([]string, 0)
|
|
current = strings.Builder{}
|
|
openCount = 0
|
|
openChar rune
|
|
)
|
|
|
|
for _, char := range s {
|
|
switch {
|
|
case openChar == 0 && openCloseMap[char] != 0:
|
|
openChar = char
|
|
|
|
openCount++
|
|
|
|
current.WriteRune(char)
|
|
case char == openChar:
|
|
openCount++
|
|
|
|
current.WriteRune(char)
|
|
case openCount > 0 && char == openCloseMap[openChar]:
|
|
openCount--
|
|
|
|
current.WriteRune(char)
|
|
case openCount == 0 && char == sep:
|
|
result = append(result, current.String())
|
|
|
|
openChar = 0
|
|
|
|
current = strings.Builder{}
|
|
default:
|
|
current.WriteRune(char)
|
|
}
|
|
}
|
|
|
|
if current.String() != "" {
|
|
result = append(result, current.String())
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// ComplementSchema complement schema with field properties
|
|
func (ps *tagBaseFieldParser) ComplementSchema(schema *spec.Schema) error {
|
|
types := ps.p.GetSchemaTypePath(schema, 2)
|
|
if len(types) == 0 {
|
|
return fmt.Errorf("invalid type for field: %s", ps.field.Names[0])
|
|
}
|
|
|
|
if IsRefSchema(schema) {
|
|
var newSchema = spec.Schema{}
|
|
err := ps.complementSchema(&newSchema, types)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !reflect.ValueOf(newSchema).IsZero() {
|
|
*schema = *(newSchema.WithAllOf(*schema))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
return ps.complementSchema(schema, types)
|
|
}
|
|
|
|
// complementSchema complement schema with field properties
|
|
func (ps *tagBaseFieldParser) complementSchema(schema *spec.Schema, types []string) error {
|
|
if ps.field.Tag == nil {
|
|
if ps.field.Doc != nil {
|
|
schema.Description = strings.TrimSpace(ps.field.Doc.Text())
|
|
}
|
|
|
|
if schema.Description == "" && ps.field.Comment != nil {
|
|
schema.Description = strings.TrimSpace(ps.field.Comment.Text())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
field := &structField{
|
|
schemaType: types[0],
|
|
formatType: ps.tag.Get(formatTag),
|
|
}
|
|
|
|
if len(types) > 1 && (types[0] == ARRAY || types[0] == OBJECT) {
|
|
field.arrayType = types[1]
|
|
}
|
|
|
|
jsonTagValue := ps.tag.Get(jsonTag)
|
|
|
|
bindingTagValue := ps.tag.Get(bindingTag)
|
|
if bindingTagValue != "" {
|
|
parseValidTags(bindingTagValue, field)
|
|
}
|
|
|
|
validateTagValue := ps.tag.Get(validateTag)
|
|
if validateTagValue != "" {
|
|
parseValidTags(validateTagValue, field)
|
|
}
|
|
|
|
enumsTagValue := ps.tag.Get(enumsTag)
|
|
if enumsTagValue != "" {
|
|
err := parseEnumTags(enumsTagValue, field)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if IsNumericType(field.schemaType) || IsNumericType(field.arrayType) {
|
|
maximum, err := getFloatTag(ps.tag, maximumTag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if maximum != nil {
|
|
field.maximum = maximum
|
|
}
|
|
|
|
minimum, err := getFloatTag(ps.tag, minimumTag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if minimum != nil {
|
|
field.minimum = minimum
|
|
}
|
|
|
|
multipleOf, err := getFloatTag(ps.tag, multipleOfTag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if multipleOf != nil {
|
|
field.multipleOf = multipleOf
|
|
}
|
|
}
|
|
|
|
if field.schemaType == STRING || field.arrayType == STRING {
|
|
maxLength, err := getIntTag(ps.tag, maxLengthTag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if maxLength != nil {
|
|
field.maxLength = maxLength
|
|
}
|
|
|
|
minLength, err := getIntTag(ps.tag, minLengthTag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if minLength != nil {
|
|
field.minLength = minLength
|
|
}
|
|
}
|
|
|
|
// json:"name,string" or json:",string"
|
|
exampleTagValue, ok := ps.tag.Lookup(exampleTag)
|
|
if ok {
|
|
field.exampleValue = exampleTagValue
|
|
|
|
if !strings.Contains(jsonTagValue, ",string") {
|
|
example, err := defineTypeOfExample(field.schemaType, field.arrayType, exampleTagValue)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
field.exampleValue = example
|
|
}
|
|
}
|
|
|
|
// perform this after setting everything else (min, max, etc...)
|
|
if strings.Contains(jsonTagValue, ",string") {
|
|
// @encoding/json: "It applies only to fields of string, floating point, integer, or boolean types."
|
|
defaultValues := map[string]string{
|
|
// Zero Values as string
|
|
STRING: "",
|
|
INTEGER: "0",
|
|
BOOLEAN: "false",
|
|
NUMBER: "0",
|
|
}
|
|
|
|
defaultValue, ok := defaultValues[field.schemaType]
|
|
if ok {
|
|
field.schemaType = STRING
|
|
*schema = *PrimitiveSchema(field.schemaType)
|
|
|
|
if field.exampleValue == nil {
|
|
// if exampleValue is not defined by the user,
|
|
// we will force an example with a correct value
|
|
// (eg: int->"0", bool:"false")
|
|
field.exampleValue = defaultValue
|
|
}
|
|
}
|
|
}
|
|
|
|
if ps.field.Doc != nil {
|
|
schema.Description = strings.TrimSpace(ps.field.Doc.Text())
|
|
}
|
|
|
|
if schema.Description == "" && ps.field.Comment != nil {
|
|
schema.Description = strings.TrimSpace(ps.field.Comment.Text())
|
|
}
|
|
|
|
schema.ReadOnly = ps.tag.Get(readOnlyTag) == "true"
|
|
|
|
defaultTagValue := ps.tag.Get(defaultTag)
|
|
if defaultTagValue != "" {
|
|
value, err := defineType(field.schemaType, defaultTagValue)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
schema.Default = value
|
|
}
|
|
|
|
schema.Example = field.exampleValue
|
|
|
|
if field.schemaType != ARRAY {
|
|
schema.Format = field.formatType
|
|
}
|
|
|
|
extensionsTagValue := ps.tag.Get(extensionsTag)
|
|
if extensionsTagValue != "" {
|
|
schema.Extensions = setExtensionParam(extensionsTagValue)
|
|
}
|
|
|
|
varNamesTag := ps.tag.Get("x-enum-varnames")
|
|
if varNamesTag != "" {
|
|
varNames := strings.Split(varNamesTag, ",")
|
|
if len(varNames) != len(field.enums) {
|
|
return fmt.Errorf("invalid count of x-enum-varnames. expected %d, got %d", len(field.enums), len(varNames))
|
|
}
|
|
|
|
field.enumVarNames = nil
|
|
|
|
for _, v := range varNames {
|
|
field.enumVarNames = append(field.enumVarNames, v)
|
|
}
|
|
|
|
if field.schemaType == ARRAY {
|
|
// Add the var names in the items schema
|
|
if schema.Items.Schema.Extensions == nil {
|
|
schema.Items.Schema.Extensions = map[string]interface{}{}
|
|
}
|
|
schema.Items.Schema.Extensions[enumVarNamesExtension] = field.enumVarNames
|
|
} else {
|
|
// Add to top level schema
|
|
if schema.Extensions == nil {
|
|
schema.Extensions = map[string]interface{}{}
|
|
}
|
|
schema.Extensions[enumVarNamesExtension] = field.enumVarNames
|
|
}
|
|
}
|
|
|
|
eleSchema := schema
|
|
|
|
if field.schemaType == ARRAY {
|
|
// For Array only
|
|
schema.MaxItems = field.maxItems
|
|
schema.MinItems = field.minItems
|
|
schema.UniqueItems = field.unique
|
|
|
|
eleSchema = schema.Items.Schema
|
|
eleSchema.Format = field.formatType
|
|
}
|
|
|
|
eleSchema.Maximum = field.maximum
|
|
eleSchema.Minimum = field.minimum
|
|
eleSchema.MultipleOf = field.multipleOf
|
|
eleSchema.MaxLength = field.maxLength
|
|
eleSchema.MinLength = field.minLength
|
|
eleSchema.Enum = field.enums
|
|
|
|
return nil
|
|
}
|
|
|
|
func getFloatTag(structTag reflect.StructTag, tagName string) (*float64, error) {
|
|
strValue := structTag.Get(tagName)
|
|
if strValue == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
value, err := strconv.ParseFloat(strValue, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't parse numeric value of %q tag: %v", tagName, err)
|
|
}
|
|
|
|
return &value, nil
|
|
}
|
|
|
|
func getIntTag(structTag reflect.StructTag, tagName string) (*int64, error) {
|
|
strValue := structTag.Get(tagName)
|
|
if strValue == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
value, err := strconv.ParseInt(strValue, 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't parse numeric value of %q tag: %v", tagName, err)
|
|
}
|
|
|
|
return &value, nil
|
|
}
|
|
|
|
func (ps *tagBaseFieldParser) IsRequired() (bool, error) {
|
|
if ps.field.Tag == nil {
|
|
return false, nil
|
|
}
|
|
|
|
bindingTag := ps.tag.Get(bindingTag)
|
|
if bindingTag != "" {
|
|
for _, val := range strings.Split(bindingTag, ",") {
|
|
switch val {
|
|
case requiredLabel:
|
|
return true, nil
|
|
case optionalLabel:
|
|
return false, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
validateTag := ps.tag.Get(validateTag)
|
|
if validateTag != "" {
|
|
for _, val := range strings.Split(validateTag, ",") {
|
|
switch val {
|
|
case requiredLabel:
|
|
return true, nil
|
|
case optionalLabel:
|
|
return false, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return ps.p.RequiredByDefault, nil
|
|
}
|
|
|
|
func parseValidTags(validTag string, sf *structField) {
|
|
// `validate:"required,max=10,min=1"`
|
|
// ps. required checked by IsRequired().
|
|
for _, val := range strings.Split(validTag, ",") {
|
|
var (
|
|
valValue string
|
|
keyVal = strings.Split(val, "=")
|
|
)
|
|
|
|
switch len(keyVal) {
|
|
case 1:
|
|
case 2:
|
|
valValue = strings.ReplaceAll(strings.ReplaceAll(keyVal[1], utf8HexComma, ","), utf8Pipe, "|")
|
|
default:
|
|
continue
|
|
}
|
|
|
|
switch keyVal[0] {
|
|
case "max", "lte":
|
|
sf.setMax(valValue)
|
|
case "min", "gte":
|
|
sf.setMin(valValue)
|
|
case "oneof":
|
|
sf.setOneOf(valValue)
|
|
case "unique":
|
|
if sf.schemaType == ARRAY {
|
|
sf.unique = true
|
|
}
|
|
case "dive":
|
|
// ignore dive
|
|
return
|
|
default:
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseEnumTags(enumTag string, field *structField) error {
|
|
enumType := field.schemaType
|
|
if field.schemaType == ARRAY {
|
|
enumType = field.arrayType
|
|
}
|
|
|
|
field.enums = nil
|
|
|
|
for _, e := range strings.Split(enumTag, ",") {
|
|
value, err := defineType(enumType, e)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
field.enums = append(field.enums, value)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sf *structField) setOneOf(valValue string) {
|
|
if len(sf.enums) != 0 {
|
|
return
|
|
}
|
|
|
|
enumType := sf.schemaType
|
|
if sf.schemaType == ARRAY {
|
|
enumType = sf.arrayType
|
|
}
|
|
|
|
valValues := parseOneOfParam2(valValue)
|
|
for i := range valValues {
|
|
value, err := defineType(enumType, valValues[i])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
sf.enums = append(sf.enums, value)
|
|
}
|
|
}
|
|
|
|
func (sf *structField) setMin(valValue string) {
|
|
value, err := strconv.ParseFloat(valValue, 64)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
switch sf.schemaType {
|
|
case INTEGER, NUMBER:
|
|
sf.minimum = &value
|
|
case STRING:
|
|
intValue := int64(value)
|
|
sf.minLength = &intValue
|
|
case ARRAY:
|
|
intValue := int64(value)
|
|
sf.minItems = &intValue
|
|
}
|
|
}
|
|
|
|
func (sf *structField) setMax(valValue string) {
|
|
value, err := strconv.ParseFloat(valValue, 64)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
switch sf.schemaType {
|
|
case INTEGER, NUMBER:
|
|
sf.maximum = &value
|
|
case STRING:
|
|
intValue := int64(value)
|
|
sf.maxLength = &intValue
|
|
case ARRAY:
|
|
intValue := int64(value)
|
|
sf.maxItems = &intValue
|
|
}
|
|
}
|
|
|
|
const (
|
|
utf8HexComma = "0x2C"
|
|
utf8Pipe = "0x7C"
|
|
)
|
|
|
|
// These code copy from
|
|
// https://github.com/go-playground/validator/blob/d4271985b44b735c6f76abc7a06532ee997f9476/baked_in.go#L207
|
|
// ---.
|
|
var oneofValsCache = map[string][]string{}
|
|
var oneofValsCacheRWLock = sync.RWMutex{}
|
|
var splitParamsRegex = regexp.MustCompile(`'[^']*'|\S+`)
|
|
|
|
func parseOneOfParam2(param string) []string {
|
|
oneofValsCacheRWLock.RLock()
|
|
values, ok := oneofValsCache[param]
|
|
oneofValsCacheRWLock.RUnlock()
|
|
|
|
if !ok {
|
|
oneofValsCacheRWLock.Lock()
|
|
values = splitParamsRegex.FindAllString(param, -1)
|
|
|
|
for i := 0; i < len(values); i++ {
|
|
values[i] = strings.ReplaceAll(values[i], "'", "")
|
|
}
|
|
|
|
oneofValsCache[param] = values
|
|
|
|
oneofValsCacheRWLock.Unlock()
|
|
}
|
|
|
|
return values
|
|
}
|
|
|
|
// ---.
|