authgear · louischan-oursky · Aug 29, 2024 · Aug 26, 2024 · Aug 27, 2024 · Aug 27, 2024
diff --git a/Makefile b/Makefile
@@ -51,6 +51,10 @@ test:
 	$(MAKE) -C ./k6 go-test
 	go test ./cmd/... ./pkg/... -timeout 1m30s
 
+.PHONY: lint-translation-keys
+lint-translation-keys:
+	go run ./devtools/gotemplatelinter --ignore-rule indentation --ignore-rule eol-at-eof ./resources/authgear/templates/en/web/authflowv2
+
 .PHONY: lint
 lint:
 	golangci-lint run ./cmd/... ./pkg/... --timeout 7m
@@ -66,7 +70,7 @@ lint:
 	-go run ./devtools/importlinter worker api lib util >> .make-lint-expect 2>&1
 	-go run ./devtools/bandimportlinter ./pkg ./cmd >> .make-lint-expect 2>&1
 	git diff --exit-code .make-lint-expect > /dev/null 2>&1
-	go run ./devtools/gotemplatelinter ./resources/authgear/templates/en/web/authflowv2
+	go run ./devtools/gotemplatelinter --ignore-rule translation-key ./resources/authgear/templates/en/web/authflowv2
 
 .PHONY: fmt
 fmt:

diff --git a/devtools/gotemplatelinter/args_flags.go b/devtools/gotemplatelinter/args_flags.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"flag"
+	"strings"
+)
+
+type ArgsFlags struct {
+	Paths         []string
+	RulesToIgnore []string
+}
+
+func ParseArgsFlags() ArgsFlags {
+	var rulesToIgnore RulesToIgnoreFlags
+	flag.Var(&rulesToIgnore, "ignore-rule", "rules to ignore, repeat this flag to ignore more rules")
+
+	flag.Parse()
+
+	paths := flag.Args()
+
+	return ArgsFlags{
+		Paths:         paths,
+		RulesToIgnore: rulesToIgnore,
+	}
+}
+
+type RulesToIgnoreFlags []string
+
+func (rs *RulesToIgnoreFlags) String() string {
+	if rs == nil {
+		return ""
+	}
+	return strings.Join(*rs, ",")
+}
+
+func (rs *RulesToIgnoreFlags) Set(value string) error {
+	*rs = append(*rs, value)
+	return nil
+}
diff --git a/devtools/gotemplatelinter/final_newline_rule.go b/devtools/gotemplatelinter/final_newline_rule.go
@@ -4,9 +4,11 @@ import (
 	"strings"
 )
 
-type FinalNewlineRule struct{}
+type EOLAtEOFRule struct{}
 
-func (r FinalNewlineRule) Check(content string, path string) LintViolations {
+var _ Rule = EOLAtEOFRule{}
+
+func (r EOLAtEOFRule) Check(content string, path string) LintViolations {
 	var violations LintViolations
 	lines := strings.Split(content, "\n")
 	if len(content) > 0 && !strings.HasSuffix(content, "\n") {
@@ -21,3 +23,7 @@ func (r FinalNewlineRule) Check(content string, path string) LintViolations {
 	}
 	return violations
 }
+
+func (r EOLAtEOFRule) Key() string {
+	return "eol-at-eof"
+}
diff --git a/devtools/gotemplatelinter/final_newline_rule_test.go b/devtools/gotemplatelinter/final_newline_rule_test.go
@@ -6,18 +6,18 @@ import (
 	. "github.com/smartystreets/goconvey/convey"
 )
 
-func TestFinalNewlineRule(t *testing.T) {
+func TestEOLAtEOFRule(t *testing.T) {
 	Convey("Given a empty file", t, func() {
 		html := ``
-		violations := FinalNewlineRule{}.Check(html, "test.html")
+		violations := EOLAtEOFRule{}.Check(html, "test.html")
 		Convey("Then I expect to see a lint violation", func() {
 			So(len(violations), ShouldEqual, 0)
 		})
 	})
 
 	Convey("Given a file with a single line", t, func() {
 		html := `<!DOCTYPE html><html lang="en"><head><title>Test</title></head><body><p>Test</p></body></html>`
-		violations := FinalNewlineRule{}.Check(html, "test.html")
+		violations := EOLAtEOFRule{}.Check(html, "test.html")
 		Convey("Then I expect to see a lint violation", func() {
 			So(len(violations), ShouldEqual, 1)
 			So(violations[0].Path, ShouldEqual, "test.html")
@@ -30,7 +30,7 @@ func TestFinalNewlineRule(t *testing.T) {
 	Convey("Given a file with a single line and a newline", t, func() {
 		html := `<!DOCTYPE html><html lang="en"><head><title>Test</title></head><body><p>Test</p></body></html>
 `
-		violations := FinalNewlineRule{}.Check(html, "test.html")
+		violations := EOLAtEOFRule{}.Check(html, "test.html")
 		Convey("Then I expect to see no violation", func() {
 			So(len(violations), ShouldEqual, 0)
 		})
@@ -39,7 +39,7 @@ func TestFinalNewlineRule(t *testing.T) {
 	Convey("Given a file with a single character and a newline", t, func() {
 		html := `A
 `
-		violations := FinalNewlineRule{}.Check(html, "test.html")
+		violations := EOLAtEOFRule{}.Check(html, "test.html")
 		Convey("Then I expect to see no violation", func() {
 			So(len(violations), ShouldEqual, 0)
 		})
@@ -55,7 +55,7 @@ func TestFinalNewlineRule(t *testing.T) {
 <p>Test</p>
 </body>
 </html>`
-		violations := FinalNewlineRule{}.Check(html, "test.html")
+		violations := EOLAtEOFRule{}.Check(html, "test.html")
 		Convey("Then I expect to see a lint violation", func() {
 			So(len(violations), ShouldEqual, 1)
 			So(violations[0].Path, ShouldEqual, "test.html")

diff --git a/devtools/gotemplatelinter/indent_rule.go b/devtools/gotemplatelinter/indent_rule.go
@@ -7,6 +7,8 @@ import (
 
 type IndentationRule struct{}
 
+var _ Rule = IndentationRule{}
+
 func (r IndentationRule) Check(content string, path string) LintViolations {
 	var violations LintViolations
 	lines := strings.Split(content, "\n")
@@ -24,3 +26,7 @@ func (r IndentationRule) Check(content string, path string) LintViolations {
 	}
 	return violations
 }
+
+func (r IndentationRule) Key() string {
+	return "indentation"
+}
diff --git a/devtools/gotemplatelinter/main.go b/devtools/gotemplatelinter/main.go
@@ -6,10 +6,13 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/authgear/authgear-server/pkg/util/slice"
 )
 
 type Rule interface {
 	Check(content string, path string) LintViolations
+	Key() string
 }
 
 type LintViolation struct {
@@ -98,25 +101,57 @@ func (l *Linter) LintFile(path string, info os.FileInfo) (violations LintViolati
 	return
 }
 
+func constructRules(rulesToIgnore []string) []Rule {
+	indentationRule := IndentationRule{}
+	EOLAtEOFRule := EOLAtEOFRule{}
+	translationKeyRule := TranslationKeyRule{}
+	rules := []Rule{
+		indentationRule,
+		EOLAtEOFRule,
+		translationKeyRule,
+	}
+	ignoreRuleFn := func(rule Rule) {
+		rules = slice.Filter[Rule](rules, func(r Rule) bool {
+			return r != rule
+		})
+	}
+	for _, ruleToIgnore := range rulesToIgnore {
+		switch ruleToIgnore {
+		case indentationRule.Key():
+			ignoreRuleFn(indentationRule)
+		case EOLAtEOFRule.Key():
+			ignoreRuleFn(EOLAtEOFRule)
+		case translationKeyRule.Key():
+			ignoreRuleFn(translationKeyRule)
+		}
+	}
+
+	return rules
+}
+
 func doMain() (violations LintViolations, err error) {
 	if len(os.Args) < 2 {
-		err = fmt.Errorf("usage: gotemplatelinter <path/to/htmls>")
+		err = fmt.Errorf("usage: gotemplatelinter --path <path/to/htmls> --ignore-rule rule1ToIgnore --ignore-rule rule2ToIgnore")
 		return
 	}
-	path := os.Args[1]
-	linter := Linter{
-		IgnorePatterns: []string{
-			"__generated_asset.html",
-		},
-		Rules: []Rule{
-			IndentationRule{},
-			FinalNewlineRule{},
-		},
-		Path: path,
+	argsFlags := ParseArgsFlags()
+	rules := constructRules(argsFlags.RulesToIgnore)
+	ignorePatterns := []string{
+		"__generated_asset.html",
 	}
-	violations, err = linter.Lint()
-	if err != nil {
-		return
+	linters := slice.Map(argsFlags.Paths, func(path string) Linter {
+		return Linter{
+			IgnorePatterns: ignorePatterns,
+			Rules:          rules,
+			Path:           path,
+		}
+	})
+	for _, linter := range linters {
+		newViolations, err := linter.Lint()
+		if err != nil {
+			return violations, err
+		}
+		violations = append(violations, newViolations...)
 	}
 
 	return

diff --git a/devtools/gotemplatelinter/transation_key_rule_check_include.go b/devtools/gotemplatelinter/transation_key_rule_check_include.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"strings"
+	"text/template/parse"
+)
+
+// validate `include` command
+//
+// e.g. (include "v2-error-screen-title" nil)
+// e.g. (include (printf "v2-oauth-branding-%s" .provider_type) nil)
+// e.g. (include $description_key nil)
+func CheckCommandInclude(includeNode *parse.CommandNode) (err error) {
+	// 2nd arg should be translation key
+	for idx, arg := range includeNode.Args {
+		if idx == 1 {
+			if isHTMLInclude(arg) { // false positive
+				break
+			}
+			err = CheckTranslationKeyNode(arg)
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return
+}
+
+func isHTMLInclude(arg parse.Node) bool {
+	if str, ok := arg.(*parse.StringNode); ok {
+		if strings.Contains(str.Text, ".html") {
+			return true
+		}
+	}
+	return false
+}
diff --git a/devtools/gotemplatelinter/transation_key_rule_check_template.go b/devtools/gotemplatelinter/transation_key_rule_check_template.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"strings"
+	"text/template/parse"
+)
+
+// validate `{{ template }}` nodes
+//
+// e.g. {{template "setup-totp-get-google-authenticator-description"}}
+// e.g. {{template "setup-totp-raw-secret" (dict "secret" $.Secret)}}
+// e.g. {{template "settings-totp-item-description" (dict "time" .CreatedAt "rfc3339" (rfc3339 .CreatedAt))}}
+func CheckTemplate(templateNode *parse.TemplateNode) (err error) {
+	if isHTMLTemplate(templateNode) { // false positive
+		return
+	}
+	translationKey := templateNode.Name
+	err = CheckTranslationKeyPattern(translationKey)
+	if err != nil {
+		return err
+	}
+	return
+}
+
+func isHTMLTemplate(templateNode *parse.TemplateNode) bool {
+	return strings.Contains(templateNode.Name, ".html")
+}
diff --git a/devtools/gotemplatelinter/transation_key_rule_check_translate.go b/devtools/gotemplatelinter/transation_key_rule_check_translate.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"text/template/parse"
+)
+
+// validate `translate` command
+//
+// e.g. (translate "app.name" nil)
+func CheckCommandTranslate(translateNode *parse.CommandNode) (err error) {
+	// 2nd arg should be translation key
+	for idx, arg := range translateNode.Args {
+		if idx == 1 {
+			err = CheckTranslationKeyNode(arg)
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return
+}
diff --git a/devtools/gotemplatelinter/transation_key_rule_check_translations_render_text.go b/devtools/gotemplatelinter/transation_key_rule_check_translations_render_text.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+	"text/template/parse"
+)
+
+// validate commands with variable `$.Translations.RenderText` or field `.Translations.RenderText`
+//
+// example: `($.Translations.RenderText "customer-support-link" nil)`
+// example: (.Translations.RenderText "terms-of-service-link" nil)
+func CheckCommandTranslationsRenderText(node *parse.CommandNode) (err error) {
+	// 2nd arg should be translation key
+	for idx, arg := range node.Args {
+		if idx == 1 {
+			err = CheckTranslationKeyNode(arg)
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return
+}