130 lines
2.6 KiB
Go
130 lines
2.6 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"go/ast"
|
|
"go/parser"
|
|
"go/token"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
var (
|
|
customLogs = flag.String("funcs", "", "Custom functions to export delimited by ','.")
|
|
directory = flag.String("dir", "", "Source code directory.")
|
|
methodsToSearchOnce = &sync.Once{}
|
|
methodsToSearch = []string{"Debug", "Info", "Warn", "Error"}
|
|
)
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
|
|
if len(*directory) == 0 {
|
|
log.Fatalln("directory must be provided")
|
|
}
|
|
|
|
directories, err := getAllSubdirectories(*directory)
|
|
if err != nil {
|
|
log.Fatalf("failed to list subdirs: %v", err)
|
|
}
|
|
|
|
for _, dir := range directories {
|
|
fset := token.NewFileSet()
|
|
packages, err := parser.ParseDir(fset, dir, nil, 0)
|
|
if err != nil {
|
|
log.Fatalf("failed to parse directory %s: %v", dir, err)
|
|
}
|
|
for _, p := range packages {
|
|
for _, f := range p.Files {
|
|
ast.Inspect(f, func(n ast.Node) bool {
|
|
expr, ok := n.(*ast.CallExpr)
|
|
if !ok {
|
|
return true
|
|
}
|
|
isLog, logMethod := isLogDot(expr.Fun)
|
|
if isLog && len(expr.Args) > 0 && isStringValue(expr.Args[0]) {
|
|
position := fset.Position(expr.Pos())
|
|
fmt.Printf("%v %s:%s\n", position, logMethod, stringValue(expr.Args[0]))
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func getAllSubdirectories(dir string) ([]string, error) {
|
|
result := make([]string, 0)
|
|
|
|
stack := make([]string, 0)
|
|
stack = append(stack, dir)
|
|
|
|
for len(stack) > 0 {
|
|
current := stack[len(stack)-1]
|
|
stack = stack[:len(stack)-1]
|
|
|
|
entities, err := os.ReadDir(current)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, e := range entities {
|
|
if e.IsDir() {
|
|
path := filepath.Join(current, e.Name())
|
|
result = append(result, path)
|
|
stack = append(stack, path)
|
|
}
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func isLogDot(expr ast.Expr) (bool, string) {
|
|
sel, ok := expr.(*ast.SelectorExpr)
|
|
if !ok {
|
|
return false, ""
|
|
}
|
|
methodsToSearchOnce.Do(func() {
|
|
for _, cl := range strings.Split(*customLogs, ",") {
|
|
cl = strings.Trim(cl, " ")
|
|
if len(cl) > 0 {
|
|
methodsToSearch = append(methodsToSearch, cl)
|
|
}
|
|
}
|
|
})
|
|
|
|
for _, method := range methodsToSearch {
|
|
if isIdent(sel.Sel, method) {
|
|
return true, method
|
|
}
|
|
}
|
|
return false, ""
|
|
}
|
|
|
|
func isIdent(expr ast.Expr, ident string) bool {
|
|
id, ok := expr.(*ast.Ident)
|
|
if !ok {
|
|
return false
|
|
}
|
|
if id.Name == ident {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isStringValue(expr ast.Expr) bool {
|
|
basicLit, ok := expr.(*ast.BasicLit)
|
|
return ok && basicLit.Kind == token.STRING
|
|
}
|
|
|
|
func stringValue(expr ast.Expr) string {
|
|
basicLit, _ := expr.(*ast.BasicLit)
|
|
return basicLit.Value
|
|
}
|