docprocessor.go

package doc

import (
	"go/ast"
	"go/build"
	"go/doc"
	"go/parser"
	"go/token"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"

	"github.com/k0kubun/pp"
)

func removeSpecialComment(comment string) string {
	lines := strings.Split(comment, "\n")
	cleanComment := ""
	for _, line := range lines {
		if strings.HasPrefix(strings.ToLower(line), "@default ") {
			continue
		}
		if strings.HasPrefix(strings.ToLower(line), "@examplels ") {
			continue
		}
		if strings.HasPrefix(strings.ToLower(line), "@type ") {
			continue
		}
		if strings.HasPrefix(strings.ToLower(line), "@enum ") {
			continue
		}
		if strings.HasPrefix(line, "go:generate") {
			continue
		}
		if strings.HasPrefix(line, "Code generated by") {
			continue
		}
		cleanComment = cleanComment + "\n" + line
	}
	return strings.TrimSpace(cleanComment)
}

func NewProcessor(pkgPath string) (*Processor, error) {
	dp := &Processor{}

	fset := token.NewFileSet()
	filter := isGoFile
	pkgs, e := parser.ParseDir(fset, pkgPath, filter, parser.ParseComments)
	if e != nil {
		return nil, e
	}

	// astf := make([]*ast.File, 0)
	// for _, pkg := range pkgs {
	// 	fmt.Printf("package %v\n", pkg.Name)
	// 	for fn, f := range pkg.Files {
	// 		fmt.Printf("file %v\n", fn)

	// 		astf = append(astf, f)
	// 	}
	// }
	var astPkg *ast.Package

	for _, pkg := range pkgs {
		astPkg = pkg
	}

	docPkg := doc.New(astPkg, pkgPath, doc.AllDecls)
	dp.Name = docPkg.Name
	p := string(os.PathSeparator)
	dp.ImportPath = strings.Replace(strings.TrimPrefix(docPkg.ImportPath, build.Default.GOPATH+p+"src"+p), "\\", "/", -1)
	dp.Doc = removeSpecialComment(docPkg.Doc)

	for _, typ := range docPkg.Types {
		docPkg.Consts = append(docPkg.Consts, typ.Consts...)
		docPkg.Vars = append(docPkg.Vars, typ.Vars...)
		docPkg.Funcs = append(docPkg.Funcs, typ.Funcs...)
	}

	// Constants PORT_
	for _, c := range docPkg.Consts {
		for _, speca := range c.Decl.Specs {
			spec := speca.(*ast.ValueSpec)
			splits := strings.SplitN(spec.Names[0].String(), "_", 2)
			if splits[0] != "PORT" {
				continue
			}

			dpp := &ProcessorPort{}
			dpp.Doc = removeSpecialComment(spec.Doc.Text())
			dpp.Name = spec.Names[0].String()

			numberStr := spec.Values[0].(*ast.BasicLit).Value
			dpp.Number, _ = strconv.Atoi(numberStr)
			if dpp.Number == 0 {
				dpp.Default = true
			}

			dp.Ports = append(dp.Ports, dpp)
		}
	}

	for _, v := range docPkg.Types {
		if v.Name == "processor" {
			dp.DocShort = removeSpecialComment(v.Doc)
			continue
		}

		if v.Name != "options" {
			continue
		}

		dp.Options = &ProcessorOptions{}
		dp.Options.Doc = removeSpecialComment(v.Doc)
		dp.Options.Options = []*ProcessorOption{}
		for _, si := range v.Decl.Specs {
			s := si.(*ast.TypeSpec)

			typ := s.Type.(*ast.StructType)
			for _, field := range typ.Fields.List {
				dpo := &ProcessorOption{}

				var fieldType string
				fieldTags := map[string]string{}

				customType := ""
				if field.Doc != nil {
					for _, c := range field.Doc.List {
						if strings.HasPrefix(c.Text, "// @Default ") {
							dpo.DefaultValue = strings.TrimPrefix(c.Text, "// @Default ")
						}
						if strings.HasPrefix(c.Text, "// @ExampleLS ") {
							dpo.ExampleLS = strings.TrimPrefix(c.Text, "// @ExampleLS ")
						}
						if strings.HasPrefix(c.Text, "// @Type ") {
							customType = strings.ToLower(strings.TrimPrefix(c.Text, "// @Type "))
						}

						if strings.HasPrefix(c.Text, "// @Enum ") {
							st := strings.ToLower(strings.TrimPrefix(c.Text, "// @Enum "))
							dpo.PossibleValues = strings.Split(st, ",")
						}
					}
				}

				switch t := field.Type.(type) {
				case *ast.MapType:
					fieldType = "map"
					keyKind := t.Key.(*ast.Ident).Name
					valueKind := "string"
					fieldType = "map[" + keyKind + "]" + valueKind
					fieldType = "hash"
				case *ast.ArrayType:
					fieldType = "array of " + t.Elt.(*ast.Ident).Name
					fieldType = "array"
				case *ast.Ident:
					fieldType = t.Name
				case *ast.SelectorExpr:
					xKind := t.X.(*ast.Ident).Name
					selKind := t.Sel.String()
					fieldType = xKind + "." + selKind
				default:
					fieldType = "unknow"
					pp.Println("field-->", field.Type)
				}

				dpo.Doc = removeSpecialComment(field.Doc.Text())
				if len(field.Names) == 0 {
					dpo.Name = fieldType
				} else {
					dpo.Name = field.Names[0].String()
				}

				if field.Tag != nil {
					if field.Tag.Value != "" {
						r, _ := regexp.Compile(`([a-z]*):"([a-z_0-9,]*)"`)
						for _, match := range r.FindAllStringSubmatch(field.Tag.Value, 5) {
							fieldTags[match[1]] = match[2]
						}
					}
				}
				// pp.Println("field tag-->", field.Tag.Value)
				dpo.Type = fieldType
				if customType != "" {
					dpo.Type = customType
				}

				if _, ok := fieldTags["mapstructure"]; ok {
					dpo.Alias = fieldTags["mapstructure"]
				}
				if _, ok := fieldTags["validate"]; ok {
					validationTagValues := strings.Split(fieldTags["validate"], ",")
					for _, validationTagValue := range validationTagValues {
						if validationTagValue == "required" {
							dpo.Required = true
						}
					}
				}

				dp.Options.Options = append(dp.Options.Options, dpo)
			}
		}
	}
	return dp, nil

}

func isGoFile(fi os.FileInfo) bool {
	name := fi.Name()
	return !fi.IsDir() &&
		len(name) > 0 && name[0] != '.' && // ignore .files
		filepath.Ext(name) == ".go"
}