@@ -358,34 +358,22 @@ func fullTypeName(pkgName, typeName string) string {
358358 return typeName
359359}
360360
361- func (parser * Parser ) getTypeSchema (typeName string , file * ast.File , field * ast. Field , parentSchema * TypeSchema ) (* TypeSchema , error ) {
361+ func (parser * Parser ) getTypeSchema (typeName string , file * ast.File , parentSchema * TypeSchema ) (* TypeSchema , error ) {
362362 if IsGolangPrimitiveType (typeName ) {
363- if field != nil {
364- name := field .Names [0 ].Name
365- return & TypeSchema {
366- Name : name ,
367- FullName : name ,
368- Type : typeName ,
369- Comment : strings .TrimSuffix (field .Comment .Text (), "\n " ),
370- Parent : parentSchema ,
371- TagValue : getAllTagValue (field ),
372- }, nil
373- } else {
374- return & TypeSchema {
375- Name : "" ,
376- FullName : typeName ,
377- Type : typeName ,
378- Parent : parentSchema ,
379- }, nil
380- }
363+ return & TypeSchema { //root type
364+ Name : typeName ,
365+ FullName : typeName ,
366+ Type : typeName ,
367+ Parent : parentSchema ,
368+ }, nil
381369 }
382370
383371 typeSpecDef := parser .packages .FindTypeSpec (typeName , file , true )
384372 if typeSpecDef == nil {
385373 return nil , fmt .Errorf ("cannot find type definition: %s" , typeName )
386374 }
387375
388- schema , err := parser .ParseDefinition (typeSpecDef , field , parentSchema )
376+ schema , err := parser .ParseDefinition (typeSpecDef , parentSchema )
389377 if err != nil {
390378 return nil , err
391379 }
@@ -394,45 +382,32 @@ func (parser *Parser) getTypeSchema(typeName string, file *ast.File, field *ast.
394382
395383// ParseDefinition parses given type spec that corresponds to the type under
396384// given name and package
397- func (parser * Parser ) ParseDefinition (typeSpecDef * TypeSpecDef , field * ast. Field , parentSchema * TypeSchema ) (* TypeSchema , error ) {
385+ func (parser * Parser ) ParseDefinition (typeSpecDef * TypeSpecDef , parentSchema * TypeSchema ) (* TypeSchema , error ) {
398386 typeName := typeSpecDef .FullName ()
399-
400387 if parentSchema != nil && parentSchema .isInTypeChain (typeSpecDef ) {
401388 fmt .Printf ("Skipping '%s', recursion detected.\n " , typeName )
402389 return & TypeSchema {
403- Name : typeName ,
390+ Name : typeSpecDef . Name () ,
404391 FullName : typeName ,
405392 Type : OBJECT ,
406393 PkgPath : typeSpecDef .PkgPath ,
407394 Parent : parentSchema ,
408- TagValue : getAllTagValue (field ),
395+ Comment : fmt .Sprintf ("%s(Recursion...)" , strings .TrimSuffix (typeSpecDef .TypeSpec .Comment .Text (), "\n " )),
396+ // TagValue: getAllTagValue(field),
409397 }, nil
410398 }
411399
412400 fmt .Printf ("Generating %s\n " , typeName )
413401
414- // return parser.parseTypeExpr(typeSpecDef.File, field, typeSpecDef.TypeSpec.Type, parentSchema)
415-
416402 switch expr := typeSpecDef .TypeSpec .Type .(type ) {
417403 // type Foo struct {...}
418404 case * ast.StructType :
419- schema , err := parser .parseStruct (typeSpecDef , typeSpecDef .File , expr .Fields , parentSchema )
420- if err != nil {
421- return nil , err
422- }
423- if field != nil {
424- if field .Names != nil {
425- schema .Name = field .Names [0 ].Name
426- }
427- schema .TagValue = getAllTagValue (field )
428- schema .Comment = strings .TrimSuffix (field .Comment .Text (), "\n " )
429- }
430- return schema , err
405+ return parser .parseStruct (typeSpecDef , typeSpecDef .File , expr .Fields , parentSchema )
431406 case * ast.Ident :
432- return parser .getTypeSchema (expr .Name , typeSpecDef .File , field , parentSchema )
407+ return parser .getTypeSchema (expr .Name , typeSpecDef .File , parentSchema )
433408 case * ast.SelectorExpr :
434409 if xIdent , ok := expr .X .(* ast.Ident ); ok {
435- return parser .getTypeSchema (fullTypeName (xIdent .Name , expr .Sel .Name ), typeSpecDef .File , field , parentSchema )
410+ return parser .getTypeSchema (fullTypeName (xIdent .Name , expr .Sel .Name ), typeSpecDef .File , parentSchema )
436411 }
437412 case * ast.MapType :
438413 if keyIdent , ok := expr .Key .(* ast.Ident ); ok {
@@ -443,7 +418,7 @@ func (parser *Parser) ParseDefinition(typeSpecDef *TypeSpecDef, field *ast.Field
443418 Properties : map [string ]* TypeSchema {},
444419 Parent : parentSchema ,
445420 }
446- schema , err := parser .parseTypeExpr (typeSpecDef .File , field , expr .Value , mapSchema )
421+ schema , err := parser .parseTypeExpr (typeSpecDef .File , expr .Value , mapSchema )
447422 if err != nil {
448423 return nil , err
449424 }
@@ -471,51 +446,32 @@ func (parser *Parser) ParseDefinition(typeSpecDef *TypeSpecDef, field *ast.Field
471446 return & sch , nil
472447}
473448
474- func (parser * Parser ) parseTypeExpr (file * ast.File , field * ast. Field , typeExpr ast.Expr , parentSchema * TypeSchema ) (* TypeSchema , error ) {
449+ func (parser * Parser ) parseTypeExpr (file * ast.File , typeExpr ast.Expr , parentSchema * TypeSchema ) (* TypeSchema , error ) {
475450 switch expr := typeExpr .(type ) {
476451 // type Foo interface{}
477452 case * ast.InterfaceType :
478453 return & TypeSchema {
479- Name : field . Names [ 0 ]. Name ,
454+ Name : "" ,
480455 Type : ANY ,
481456 FullName : ANY ,
482457 Parent : parentSchema ,
483- TagValue : getAllTagValue (field ),
484458 }, nil
485459
486- // type Foo struct {...}
487- case * ast.StructType :
488- schema , err := parser .parseStruct (nil , file , expr .Fields , parentSchema )
489- if err != nil {
490- return nil , err
491- }
492- schema .Name = field .Names [0 ].Name
493- schema .TagValue = getAllTagValue (field )
494- return schema , err
495-
496460 // type Foo Baz
497461 case * ast.Ident :
498- schema , err := parser .getTypeSchema (expr .Name , file , field , parentSchema )
499- if err != nil {
500- return nil , err
501- }
502- if field != nil && field .Names != nil {
503- schema .Name = field .Names [0 ].Name
504- schema .TagValue = getAllTagValue (field )
505- }
506- return schema , err
462+ return parser .getTypeSchema (expr .Name , file , parentSchema )
507463 // type Foo *Baz
508464 case * ast.StarExpr :
509- return parser .parseTypeExpr (file , field , expr .X , parentSchema )
465+ return parser .parseTypeExpr (file , expr .X , parentSchema )
510466
511467 // type Foo pkg.Bar
512468 case * ast.SelectorExpr :
513469 if xIdent , ok := expr .X .(* ast.Ident ); ok {
514- return parser .getTypeSchema (fullTypeName (xIdent .Name , expr .Sel .Name ), file , field , parentSchema )
470+ return parser .getTypeSchema (fullTypeName (xIdent .Name , expr .Sel .Name ), file , parentSchema )
515471 }
516472 // type Foo []Baz
517473 case * ast.ArrayType :
518- itemSchema , err := parser .parseTypeExpr (file , field , expr .Elt , parentSchema )
474+ itemSchema , err := parser .parseTypeExpr (file , expr .Elt , parentSchema )
519475 if err != nil {
520476 return nil , err
521477 }
@@ -530,7 +486,7 @@ func (parser *Parser) parseTypeExpr(file *ast.File, field *ast.Field, typeExpr a
530486 Properties : map [string ]* TypeSchema {},
531487 Parent : parentSchema ,
532488 }
533- schema , err := parser .parseTypeExpr (file , field , expr .Value , mapSchema )
489+ schema , err := parser .parseTypeExpr (file , expr .Value , mapSchema )
534490 if err != nil {
535491 return nil , err
536492 }
@@ -542,11 +498,12 @@ func (parser *Parser) parseTypeExpr(file *ast.File, field *ast.Field, typeExpr a
542498 schema .TagValue = ""
543499 mapSchema .Properties [example ] = schema
544500 return mapSchema , nil
501+ } else {
502+ return nil , fmt .Errorf ("error: map key type %s, just support string or int" , keyIdent .Name )
545503 }
546504 }
547-
548- // case *ast.FuncType:
549- // return nil, ErrFuncTypeField
505+ case * ast.FuncType :
506+ return nil , errors .New ("filed type can't be func" )
550507 // ...
551508 default :
552509 fmt .Printf ("Type definition of type '%T' is not supported yet. Using 'object' instead.\n " , typeExpr )
@@ -569,13 +526,26 @@ func (parser *Parser) parseStruct(typeSpecDef *TypeSpecDef, file *ast.File, fiel
569526 }
570527
571528 for _ , field := range fields .List {
572- schema , err := parser .parseStructField (file , field , structSchema )
529+ if field .Names != nil {
530+ name := field .Names [0 ].Name
531+ if ! ast .IsExported (name ) {
532+ continue
533+ }
534+ }
535+ schema , err := parser .parseTypeExpr (file , field .Type , structSchema )
573536 if err != nil {
574537 return nil , err
575538 }
576539 if schema == nil {
577540 continue
578541 }
542+ if field != nil {
543+ if field .Names != nil {
544+ schema .Name = field .Names [0 ].Name
545+ }
546+ schema .TagValue = getAllTagValue (field )
547+ schema .Comment = strings .TrimSuffix (field .Comment .Text (), "\n " )
548+ }
579549 if field .Names == nil { //nested struct, replace with child properties
580550 for _ , p := range schema .Properties {
581551 if _ , ok := structSchema .Properties [strings .ToLower (p .Name )]; ! ok { //if not exists key
@@ -588,13 +558,3 @@ func (parser *Parser) parseStruct(typeSpecDef *TypeSpecDef, file *ast.File, fiel
588558 }
589559 return structSchema , nil
590560}
591-
592- func (parser * Parser ) parseStructField (file * ast.File , field * ast.Field , parentSchama * TypeSchema ) (* TypeSchema , error ) {
593- if field .Names != nil {
594- name := field .Names [0 ].Name
595- if ! ast .IsExported (name ) {
596- return nil , nil
597- }
598- }
599- return parser .parseTypeExpr (file , field , field .Type , parentSchama )
600- }
0 commit comments