Skip to content

Commit

Permalink
Merge pull request #629 from wsnotify/issue-225
Browse files Browse the repository at this point in the history 
Conflicting package + struct name
  • Loading branch information
@sdghchj
sdghchj committed Feb 23, 2020
2 parents f150c13 + 2c8dd22 commit 5cd03f0
Show file tree
Hide file tree
Showing 3 changed files with 52 additions and 64 deletions.
9 changes: 5 additions & 4 deletions parser.go
View file
Expand Up @@ -516,7 +516,8 @@ func (parser *Parser) ParseType(astFile *ast.File) {
typeName := fmt.Sprintf("%v", typeSpec.Type)
// check if its a custom primitive type
if IsGolangPrimitiveType(typeName) {
parser.CustomPrimitiveTypes[typeSpec.Name.String()] = TransToValidSchemeType(typeName)
var typeSpecFullName = fmt.Sprintf("%s.%s", astFile.Name.String(), typeSpec.Name.String())
parser.CustomPrimitiveTypes[typeSpecFullName] = TransToValidSchemeType(typeName)
} else {
parser.TypeDefinitions[astFile.Name.String()][typeSpec.Name.String()] = typeSpec
}
Expand Down Expand Up @@ -860,7 +861,7 @@ func (parser *Parser) parseStructField(pkgName string, field *ast.Field) (map[st
return properties, nil, nil
}

structField, err := parser.parseField(field)
structField, err := parser.parseField(pkgName, field)
if err != nil {
return properties, nil, err
}
Expand Down Expand Up @@ -1117,8 +1118,8 @@ func getFieldType(field interface{}) (string, error) {
return "", fmt.Errorf("unknown field type %#v", field)
}

func (parser *Parser) parseField(field *ast.Field) (*structField, error) {
prop, err := getPropertyName(field.Type, parser)
func (parser *Parser) parseField(pkgName string, field *ast.Field) (*structField, error) {
prop, err := getPropertyName(pkgName, field.Type, parser)
if err != nil {
return nil, err
}
Expand Down
79 changes: 33 additions & 46 deletions property.go
View file
Expand Up @@ -73,7 +73,8 @@ func parseFieldSelectorExpr(astTypeSelectorExpr *ast.SelectorExpr, parser *Parse
}
}
}
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[astTypeSelectorExpr.Sel.Name]; isCustomType {
name := fmt.Sprintf("%s.%v", pkgName, astTypeSelectorExpr.Sel.Name)
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[name]; isCustomType {
return propertyName{SchemaType: actualPrimitiveType, ArrayType: actualPrimitiveType}
}
}
Expand All @@ -82,70 +83,56 @@ func parseFieldSelectorExpr(astTypeSelectorExpr *ast.SelectorExpr, parser *Parse

// getPropertyName returns the string value for the given field if it exists
// allowedValues: array, boolean, integer, null, number, object, string
func getPropertyName(expr ast.Expr, parser *Parser) (propertyName, error) {
if astTypeSelectorExpr, ok := expr.(*ast.SelectorExpr); ok {
return parseFieldSelectorExpr(astTypeSelectorExpr, parser, newProperty), nil
}

// check if it is a custom type
typeName := fmt.Sprintf("%v", expr)
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[typeName]; isCustomType {
return propertyName{SchemaType: actualPrimitiveType, ArrayType: actualPrimitiveType}, nil
}

if astTypeIdent, ok := expr.(*ast.Ident); ok {
name := astTypeIdent.Name
schemeType := TransToValidSchemeType(name)
return propertyName{SchemaType: schemeType, ArrayType: schemeType}, nil
}

if ptr, ok := expr.(*ast.StarExpr); ok {
return getPropertyName(ptr.X, parser)
}

if astTypeArray, ok := expr.(*ast.ArrayType); ok { // if array
return getArrayPropertyName(astTypeArray.Elt, parser), nil
}

if _, ok := expr.(*ast.MapType); ok { // if map
return propertyName{SchemaType: "object", ArrayType: "object"}, nil
}

if _, ok := expr.(*ast.StructType); ok { // if struct
return propertyName{SchemaType: "object", ArrayType: "object"}, nil
}

if _, ok := expr.(*ast.InterfaceType); ok { // if interface{}
func getPropertyName(pkgName string, expr ast.Expr, parser *Parser) (propertyName, error) {
switch tp := expr.(type) {
case *ast.SelectorExpr:
return parseFieldSelectorExpr(tp, parser, newProperty), nil
case *ast.StarExpr:
return getPropertyName(pkgName, tp.X, parser)
case *ast.ArrayType:
return getArrayPropertyName(pkgName, tp.Elt, parser), nil
case *ast.MapType, *ast.StructType, *ast.InterfaceType:
return propertyName{SchemaType: "object", ArrayType: "object"}, nil
}

if _, ok := expr.(*ast.FuncType); ok { // if func()
case *ast.FuncType:
return propertyName{SchemaType: "func", ArrayType: ""}, nil
}
case *ast.Ident:
name := tp.Name
// check if it is a custom type
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[pkgName+"."+name]; isCustomType {
return propertyName{SchemaType: actualPrimitiveType, ArrayType: actualPrimitiveType}, nil
}

return propertyName{}, errors.New("not supported" + fmt.Sprint(expr))
name = TransToValidSchemeType(name)
return propertyName{SchemaType: name, ArrayType: name}, nil
default:
return propertyName{}, errors.New("not supported" + fmt.Sprint(expr))
}
}

func getArrayPropertyName(astTypeArrayElt ast.Expr, parser *Parser) propertyName {
func getArrayPropertyName(pkgName string, astTypeArrayElt ast.Expr, parser *Parser) propertyName {
switch elt := astTypeArrayElt.(type) {
case *ast.StructType, *ast.MapType, *ast.InterfaceType:
return propertyName{SchemaType: "array", ArrayType: "object"}
case *ast.ArrayType:
return propertyName{SchemaType: "array", ArrayType: "array"}
case *ast.StarExpr:
return getArrayPropertyName(elt.X, parser)
return getArrayPropertyName(pkgName, elt.X, parser)
case *ast.SelectorExpr:
return parseFieldSelectorExpr(elt, parser, newArrayProperty)
case *ast.Ident:
name := TransToValidSchemeType(elt.Name)
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[name]; isCustomType {
name := elt.Name
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[pkgName+"."+name]; isCustomType {
name = actualPrimitiveType
} else {
name = TransToValidSchemeType(elt.Name)
}
return propertyName{SchemaType: "array", ArrayType: name}
default:
name := TransToValidSchemeType(fmt.Sprintf("%s", astTypeArrayElt))
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[name]; isCustomType {
name := fmt.Sprintf("%s", astTypeArrayElt)
if actualPrimitiveType, isCustomType := parser.CustomPrimitiveTypes[pkgName+"."+name]; isCustomType {
name = actualPrimitiveType
} else {
name = TransToValidSchemeType(name)
}
return propertyName{SchemaType: "array", ArrayType: name}
}
Expand Down
28 changes: 14 additions & 14 deletions property_test.go
View file
Expand Up @@ -25,7 +25,7 @@ func TestGetPropertyNameSelectorExpr(t *testing.T) {
"string",
"",
}
propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -49,7 +49,7 @@ func TestGetPropertyNameIdentObjectId(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -73,7 +73,7 @@ func TestGetPropertyNameIdentUUID(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -96,7 +96,7 @@ func TestGetPropertyNameIdentDecimal(t *testing.T) {
"string",
"",
}
propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -120,7 +120,7 @@ func TestGetPropertyNameIdentTime(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, nil)
propertyName, err := getPropertyName("test", input, nil)
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -140,7 +140,7 @@ func TestGetPropertyNameStarExprIdent(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand Down Expand Up @@ -168,7 +168,7 @@ func TestGetPropertyNameStarExprMap(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -190,7 +190,7 @@ func TestGetPropertyNameArrayStarExpr(t *testing.T) {
"string",
"",
}
propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand Down Expand Up @@ -220,7 +220,7 @@ func TestGetPropertyNameArrayStarExprSelector(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -237,7 +237,7 @@ func TestGetPropertyNameArrayStructType(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -257,7 +257,7 @@ func TestGetPropertyNameMap(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -270,7 +270,7 @@ func TestGetPropertyNameStruct(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}
Expand All @@ -283,14 +283,14 @@ func TestGetPropertyNameInterface(t *testing.T) {
"",
}

propertyName, err := getPropertyName(input, New())
propertyName, err := getPropertyName("test", input, New())
assert.NoError(t, err)
assert.Equal(t, expected, propertyName)
}

func TestGetPropertyNameChannel(t *testing.T) {
input := &ast.ChanType{}
_, err := getPropertyName(input, New())
_, err := getPropertyName("test", input, New())
assert.Error(t, err)
}

Expand Down

0 comments on commit 5cd03f0

Please sign in to comment.