Merge pull request #162 from maximilien/refactor/149-fixup-checkup

feat(fixup): added source and resource flags to set source/translation directories

Author: maximilien

bin/validate

@@ -27,7 +27,7 @@ if [[ -z $(command -v go-bindata) ]]; then
 fi
 
 pushd $PROJ_DIR >/dev/null
-go-bindata -pkg resources -o resources -o i18n4go/resources/i18n_resources.go -nocompress i18n4go/i18n/resources/*.json
+go-bindata -pkg i18n -o i18n4go/i18n/i18n_resources.go -nocompress i18n4go/i18n/resources/*.json
 echo -e "\nCompleted."
 
 popd >/dev/null

i18n4go/cmds/checkup.go

@@ -20,13 +20,8 @@ import (
 	"io/ioutil"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 
-	"go/ast"
-	"go/parser"
-	"go/token"
-
 	"github.com/spf13/cobra"
 
 	"github.com/maximilien/i18n4go/i18n4go/common"
@@ -52,7 +47,7 @@ func NewCheckup(options *common.Options) *Checkup {
 func NewCheckupCommand(options *common.Options) *cobra.Command {
 	checkupCmd := &cobra.Command{
 		Use:   "checkup",
-		Short: i18n.T("Checks the transated files"),
+		Short: i18n.T("Checks the translated files"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return NewCheckup(options).Run()
 		},
@@ -68,15 +63,15 @@ func (cu *Checkup) Options() common.Options {
 	return cu.options
 }
 
-func (cu *Checkup) Println(a ...interface{}) (int, error) {
+func (cu *Checkup) Println(a ...any) (int, error) {
 	if cu.options.VerboseFlag {
 		return fmt.Println(a...)
 	}
 
 	return 0, nil
 }
 
-func (cu *Checkup) Printf(msg string, a ...interface{}) (int, error) {
+func (cu *Checkup) Printf(msg string, a ...any) (int, error) {
 	if cu.options.VerboseFlag {
 		return fmt.Printf(msg, a...)
 	}
@@ -89,7 +84,7 @@ func (cu *Checkup) Run() error {
 	sourceStrings, err := cu.findSourceStrings()
 
 	if err != nil {
-		cu.Println(i18n.T("Couldn't find any source strings: {{.Arg0}}", map[string]interface{}{"Arg0": err.Error()}))
+		cu.Println(i18n.T("Couldn't find any source strings: {{.Arg0}}", map[string]any{"Arg0": err.Error()}))
 		return err
 	}
 
@@ -104,7 +99,7 @@ func (cu *Checkup) Run() error {
 	englishStrings, err := cu.findI18nStrings(englishFiles)
 
 	if err != nil {
-		cu.Println(i18n.T("Couldn't find the english strings: {{.Arg0}}", map[string]interface{}{"Arg0": err.Error()}))
+		cu.Println(i18n.T("Couldn't find the english strings: {{.Arg0}}", map[string]any{"Arg0": err.Error()}))
 		return err
 	}
 
@@ -118,7 +113,7 @@ func (cu *Checkup) Run() error {
 		translatedStrings, err := cu.findI18nStrings(i18nFiles)
 
 		if err != nil {
-			cu.Println(i18n.T("Couldn't get the strings from {{.Arg0}}: {{.Arg1}}", map[string]interface{}{"Arg0": locale, "Arg1": err.Error()}))
+			cu.Println(i18n.T("Couldn't get the strings from {{.Arg0}}: {{.Arg1}}", map[string]any{"Arg0": locale, "Arg1": err.Error()}))
 			return err
 		}
 
@@ -150,125 +145,12 @@ func getGoFiles(dir string) (files []string) {
 	return
 }
 
-func (cu *Checkup) inspectAssignStmt(stmtMap map[string][]ast.AssignStmt, node *ast.AssignStmt) {
-	// use a hashmap for defined variables to a list of reassigned variables sharing the same var name
-	if assignStmt, okIdent := node.Lhs[0].(*ast.Ident); okIdent {
-		varName := assignStmt.Name
-		if node.Tok == token.DEFINE {
-			stmtMap[varName] = []ast.AssignStmt{}
-		} else if node.Tok == token.ASSIGN {
-			if _, exists := stmtMap[varName]; exists {
-				stmtMap[varName] = append(stmtMap[varName], *node)
-			}
-		}
-	}
-}
-
-func (cu *Checkup) inspectStmt(translatedStrings []string, stmtMap map[string][]ast.AssignStmt, node ast.AssignStmt) []string {
-	if strStmtArg, ok := node.Rhs[0].(*ast.BasicLit); ok {
-		varName := node.Lhs[0].(*ast.Ident).Name
-		translatedString, err := strconv.Unquote(strStmtArg.Value)
-		if err != nil {
-			panic(err.Error())
-		}
-		translatedStrings = append(translatedStrings, translatedString)
-		// apply all translation ids from reassigned variables
-		if _, exists := stmtMap[varName]; exists {
-			for _, assignStmt := range stmtMap[varName] {
-				strVarVal := assignStmt.Rhs[0].(*ast.BasicLit).Value
-				translatedString, err := strconv.Unquote(strVarVal)
-				if err != nil {
-					panic(err.Error())
-				}
-				translatedStrings = append(translatedStrings, translatedString)
-
-			}
-		}
-	}
-
-	return translatedStrings
-}
-
-func (cu *Checkup) inspectTFunc(translatedStrings []string, stmtMap map[string][]ast.AssignStmt, node ast.CallExpr) []string {
-	if stringArg, ok := node.Args[0].(*ast.BasicLit); ok {
-		translatedString, err := strconv.Unquote(stringArg.Value)
-		if err != nil {
-			panic(err.Error())
-		}
-		translatedStrings = append(translatedStrings, translatedString)
-	}
-	if idt, okIdt := node.Args[0].(*ast.Ident); okIdt {
-		if obj := idt.Obj; obj != nil {
-			if stmtArg, okStmt := obj.Decl.(*ast.AssignStmt); okStmt {
-				translatedStrings = cu.inspectStmt(translatedStrings, stmtMap, *stmtArg)
-			}
-		}
-	}
-
-	return translatedStrings
-}
-
-func (cu *Checkup) inspectCallExpr(translatedStrings []string, stmtMap map[string][]ast.AssignStmt, node *ast.CallExpr) []string {
-	switch node.Fun.(type) {
-	case *ast.Ident:
-		funName := node.Fun.(*ast.Ident).Name
-		// inspect any T() or t() method calls
-		if funName == "T" || funName == "t" {
-			translatedStrings = cu.inspectTFunc(translatedStrings, stmtMap, *node)
-		}
-
-	case *ast.SelectorExpr:
-		expr := node.Fun.(*ast.SelectorExpr)
-		if ident, ok := expr.X.(*ast.Ident); ok {
-			funName := expr.Sel.Name
-			// inspect any <MODULE>.T() or <MODULE>.t() method calls (eg. i18n.T())
-			if ident.Name == cu.options.QualifierFlag && (funName == "T" || funName == "t") {
-				translatedStrings = cu.inspectTFunc(translatedStrings, stmtMap, *node)
-			}
-		}
-	default:
-		//Skip!
-	}
-
-	return translatedStrings
-}
-
-func (cu *Checkup) inspectFile(file string) (translatedStrings []string, err error) {
-	defineAssignStmtMap := make(map[string][]ast.AssignStmt)
-	fset := token.NewFileSet()
-	astFile, err := parser.ParseFile(fset, file, nil, parser.AllErrors)
-	if err != nil {
-		cu.Println(err)
-		return
-	}
-
-	ast.Inspect(astFile, func(n ast.Node) bool {
-		switch x := n.(type) {
-		case *ast.AssignStmt:
-			// inspect any potential translation string in defined / assigned statement nodes
-			// add node to map if variable contains a translation string
-			// eg: translation := "Hello {{.FirstName}}"
-			//     T(translation)
-			//     translation = "Hello {{.LastName}}"
-			//     T(translation)
-			cu.inspectAssignStmt(defineAssignStmtMap, x)
-		case *ast.CallExpr:
-			// inspect any T()/t() or <MODULE>.T()/<MODULE>.t() (eg. i18n.T()) method calls using map
-			/// then retrieve a list of translation strings that were passed into method
-			translatedStrings = cu.inspectCallExpr(translatedStrings, defineAssignStmtMap, x)
-		}
-		return true
-	})
-
-	return
-}
-
 func (cu *Checkup) findSourceStrings() (sourceStrings map[string]string, err error) {
 	sourceStrings = make(map[string]string)
 	files := getGoFiles(".")
 
 	for _, file := range files {
-		fileStrings, err := cu.inspectFile(file)
+		fileStrings, err := common.InspectFile(file, cu.options)
 		if err != nil {
 			cu.Println(i18n.T("Error when inspecting go file: "), file)
 			return sourceStrings, err
@@ -294,7 +176,7 @@ func getI18nFile(locale, dir string) (filePath string) {
 			name := fileInfo.Name()
 
 			// assume the file path is a json file and the path contains the locale
-			if strings.HasSuffix(name, ".json") && strings.Contains(name, fmt.Sprintf("{{.Arg0}}.", map[string]interface{}{"Arg0": locale})) {
+			if strings.HasSuffix(name, ".json") && strings.Contains(name, fmt.Sprintf("{{.Arg0}}.", map[string]any{"Arg0": locale})) {
 				filePath = filepath.Join(dir, fileInfo.Name())
 				break
 			}
@@ -380,14 +262,14 @@ func (cu *Checkup) findI18nStrings(i18nFiles []string) (i18nStrings map[string]s
 func (cu *Checkup) diffStrings(sourceNameOne, sourceNameTwo string, stringsOne, stringsTwo map[string]string) (err error) {
 	for key, _ := range stringsOne {
 		if stringsTwo[key] == "" {
-			cu.Printf(i18n.T("\"{{.Arg0}}\" exists in {{.Arg1}}, but not in {{.Arg2}}\n", map[string]interface{}{"Arg0": key, "Arg1": sourceNameOne, "Arg2": sourceNameTwo}))
+			cu.Printf(i18n.T("\"{{.Arg0}}\" exists in {{.Arg1}}, but not in {{.Arg2}}\n", map[string]any{"Arg0": key, "Arg1": sourceNameOne, "Arg2": sourceNameTwo}))
 			err = errors.New(i18n.T("Strings don't match"))
 		}
 	}
 
 	for key, _ := range stringsTwo {
 		if stringsOne[key] == "" {
-			cu.Printf(i18n.T("\"{{.Arg0}}\" exists in {{.Arg1}}, but not in {{.Arg2}}\n", map[string]interface{}{"Arg0": key, "Arg1": sourceNameTwo, "Arg2": sourceNameOne}))
+			cu.Printf(i18n.T("\"{{.Arg0}}\" exists in {{.Arg1}}, but not in {{.Arg2}}\n", map[string]any{"Arg0": key, "Arg1": sourceNameTwo, "Arg2": sourceNameOne}))
 			err = errors.New(i18n.T("Strings don't match"))
 		}
 	}

i18n4go/cmds/create_translations.go

@@ -75,7 +75,7 @@ func NewCreateTranslations(options *common.Options) *createTranslations {
 func NewCreateTranslationsCommand(options *common.Options) *cobra.Command {
 	createTranslationsCmd := &cobra.Command{
 		Use:   "create-translations",
-		Short: i18n.T("Creates the transation files"),
+		Short: i18n.T("Creates the translation files"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return NewCreateTranslations(options).Run()
 		},