github.com/profzone/eden-framework@v1.0.10/internal/generator/scanner/utils.go (about)

     1  package scanner
     2  
     3  import (
     4  	"github.com/go-courier/oas"
     5  	"github.com/profzone/eden-framework/pkg/courier"
     6  	"github.com/profzone/eden-framework/pkg/courier/httpx"
     7  	"github.com/profzone/eden-framework/pkg/courier/transport_http"
     8  	"github.com/profzone/eden-framework/pkg/reflectx"
     9  	"go/ast"
    10  	"go/constant"
    11  	"go/types"
    12  	"reflect"
    13  	"regexp"
    14  	"strconv"
    15  	"strings"
    16  )
    17  
    18  const (
    19  	XID           = "x-id"
    20  	XGoVendorType = `x-go-vendor-type`
    21  	XGoStarLevel  = `x-go-star-level`
    22  	XGoFieldName  = `x-go-field-name`
    23  
    24  	XTagValidate = `x-tag-validate`
    25  	XTagMime     = `x-tag-mime`
    26  	XTagJSON     = `x-tag-json`
    27  	XTagXML      = `x-tag-xml`
    28  	XTagName     = `x-tag-name`
    29  
    30  	XEnumOptions = `x-enum-options`
    31  	XStatusErrs  = `x-status-errors`
    32  )
    33  
    34  var (
    35  	pkgImportPathHttpTransport = reflectx.ImportGoPath(reflect.TypeOf(transport_http.HttpRouteMeta{}).PkgPath())
    36  	pkgImportPathHttpx         = reflectx.ImportGoPath(reflect.TypeOf(httpx.MethodGet{}).PkgPath())
    37  	pkgImportPathCourier       = reflectx.ImportGoPath(reflect.TypeOf(courier.Router{}).PkgPath())
    38  )
    39  
    40  var (
    41  	rxEnum   = regexp.MustCompile(`api:enum`)
    42  	rxStrFmt = regexp.MustCompile(`api:stringFormat\s+(\S+)([\s\S]+)?$`)
    43  )
    44  
    45  var positionOrders = map[oas.Position]string{
    46  	"path":   "1",
    47  	"header": "2",
    48  	"query":  "3",
    49  	"cookie": "4",
    50  }
    51  
    52  func valueOf(v constant.Value) interface{} {
    53  	if v == nil {
    54  		return nil
    55  	}
    56  
    57  	switch v.Kind() {
    58  	case constant.Float:
    59  		v, _ := strconv.ParseFloat(v.String(), 10)
    60  		return v
    61  	case constant.Bool:
    62  		v, _ := strconv.ParseBool(v.String())
    63  		return v
    64  	case constant.String:
    65  		v, _ := strconv.Unquote(v.String())
    66  		return v
    67  	case constant.Int:
    68  		v, _ := strconv.ParseInt(v.String(), 10, 64)
    69  		return v
    70  	}
    71  
    72  	return nil
    73  }
    74  
    75  func isRouterType(typ types.Type) bool {
    76  	return strings.HasSuffix(typ.String(), pkgImportPathCourier+".Router")
    77  }
    78  
    79  func isFromHttpTransport(typ types.Type) bool {
    80  	return strings.Contains(typ.String(), pkgImportPathHttpTransport+".")
    81  }
    82  
    83  func filterMarkedLines(comments []string) []string {
    84  	lines := make([]string, 0)
    85  	for _, line := range comments {
    86  		if !strings.HasPrefix(line, "@") {
    87  			lines = append(lines, line)
    88  		}
    89  	}
    90  	return lines
    91  }
    92  
    93  func tagValueAndFlagsByTagString(tagString string) (string, map[string]bool) {
    94  	valueAndFlags := strings.Split(tagString, ",")
    95  	v := valueAndFlags[0]
    96  	tagFlags := map[string]bool{}
    97  	if len(valueAndFlags) > 1 {
    98  		for _, flag := range valueAndFlags[1:] {
    99  			tagFlags[flag] = true
   100  		}
   101  	}
   102  	return v, tagFlags
   103  }
   104  
   105  func dropMarkedLines(lines []string) string {
   106  	return strings.Join(filterMarkedLines(lines), "\n")
   107  }
   108  
   109  func fullTypeName(typeName *types.TypeName) string {
   110  	pkg := typeName.Pkg()
   111  	if pkg != nil {
   112  		return pkg.Path() + "." + typeName.Name()
   113  	}
   114  	return typeName.Name()
   115  }
   116  
   117  func ParseEnum(doc string) (string, bool) {
   118  	if rxEnum.MatchString(doc) {
   119  		return strings.TrimSpace(strings.Replace(doc, "api:enum", "", -1)), true
   120  	}
   121  	return doc, false
   122  }
   123  
   124  func ParseType(typeExpr ast.Expr) (keyType, pkgName string, pointer bool) {
   125  	switch typeExpr.(type) {
   126  	case *ast.Ident:
   127  		keyType = typeExpr.(*ast.Ident).Name
   128  	case *ast.StarExpr:
   129  		starExpr := typeExpr.(*ast.StarExpr)
   130  		keyType, pkgName, _ = ParseType(starExpr.X)
   131  		keyType = "*" + keyType
   132  		pointer = true
   133  	case *ast.SelectorExpr:
   134  		selectorExpr := typeExpr.(*ast.SelectorExpr)
   135  		pkgName, _, pointer = ParseType(selectorExpr.X)
   136  		keyType = selectorExpr.Sel.Name
   137  	case *ast.ArrayType:
   138  		arrayType := typeExpr.(*ast.ArrayType)
   139  		keyType, pkgName, pointer = ParseType(arrayType.Elt)
   140  		keyType = "[]" + keyType
   141  	}
   142  
   143  	return
   144  }
   145  
   146  func ParseStringFormat(doc string) (string, string) {
   147  	matched := rxStrFmt.FindAllStringSubmatch(doc, -1)
   148  	if len(matched) > 0 {
   149  		return strings.TrimSpace(matched[0][2]), matched[0][1]
   150  	}
   151  	return doc, ""
   152  }
   153  
   154  func RetrievePackageName(path string) string {
   155  	path = strings.Trim(path, "\"")
   156  	paths := strings.Split(path, "/")
   157  	return strings.Replace(paths[len(paths)-1], "-", "_", -1)
   158  }