Use a new vars template implementation

Author: lunny

models/migrations/migrations_test.go

@@ -24,7 +24,6 @@ import (
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/unknwon/com"
 	"xorm.io/xorm"
 	"xorm.io/xorm/names"
 )
@@ -204,7 +203,7 @@ func prepareTestEnv(t *testing.T, skip int, syncModels ...interface{}) (*xorm.En
 	deferFn := PrintCurrentTest(t, ourSkip)
 	assert.NoError(t, os.RemoveAll(setting.RepoRootPath))
 
-	assert.NoError(t, com.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"),
+	assert.NoError(t, util.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"),
 		setting.RepoRootPath))
 	ownerDirs, err := os.ReadDir(setting.RepoRootPath)
 	if err != nil {

modules/cache/cache_redis.go

@@ -10,10 +10,10 @@ import (
 
 	"code.gitea.io/gitea/modules/graceful"
 	"code.gitea.io/gitea/modules/nosql"
+	"code.gitea.io/gitea/modules/util"
 
 	"gitea.com/go-chi/cache"
 	"github.com/go-redis/redis/v8"
-	"github.com/unknwon/com"
 )
 
 // RedisCacher represents a redis cache adapter implementation.
@@ -29,15 +29,15 @@ type RedisCacher struct {
 func (c *RedisCacher) Put(key string, val interface{}, expire int64) error {
 	key = c.prefix + key
 	if expire == 0 {
-		if err := c.c.Set(graceful.GetManager().HammerContext(), key, com.ToStr(val), 0).Err(); err != nil {
+		if err := c.c.Set(graceful.GetManager().HammerContext(), key, util.ToStr(val), 0).Err(); err != nil {
 			return err
 		}
 	} else {
-		dur, err := time.ParseDuration(com.ToStr(expire) + "s")
+		dur, err := time.ParseDuration(util.ToStr(expire) + "s")
 		if err != nil {
 			return err
 		}
-		if err = c.c.Set(graceful.GetManager().HammerContext(), key, com.ToStr(val), dur).Err(); err != nil {
+		if err = c.c.Set(graceful.GetManager().HammerContext(), key, util.ToStr(val), dur).Err(); err != nil {
 			return err
 		}
 	}

modules/context/csrf.go

@@ -23,6 +23,7 @@ import (
 	"time"
 
 	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/modules/web/middleware"
 
 	"github.com/unknwon/com"
@@ -211,7 +212,7 @@ func Csrfer(opt CsrfOptions, ctx *Context) CSRF {
 	x.ID = "0"
 	uid := ctx.Session.Get(opt.SessionKey)
 	if uid != nil {
-		x.ID = com.ToStr(uid)
+		x.ID = util.ToStr(uid)
 	}
 
 	needsNew := false

modules/context/repo.go

@@ -26,11 +26,11 @@ import (
 	"code.gitea.io/gitea/modules/markup/markdown"
 	"code.gitea.io/gitea/modules/setting"
 	api "code.gitea.io/gitea/modules/structs"
+	"code.gitea.io/gitea/modules/templates/vars"
 	"code.gitea.io/gitea/modules/util"
 	asymkey_service "code.gitea.io/gitea/services/asymkey"
 
 	"github.com/editorconfig/editorconfig-core-go/v2"
-	"github.com/unknwon/com"
 )
 
 // IssueTemplateDirCandidates issue templates directory
@@ -309,11 +309,17 @@ func EarlyResponseForGoGetMeta(ctx *Context) {
 		ctx.PlainText(http.StatusBadRequest, "invalid repository path")
 		return
 	}
-	ctx.PlainText(http.StatusOK, com.Expand(`<meta name="go-import" content="{GoGetImport} git {CloneLink}">`,
+	res, err := vars.Expand(`<meta name="go-import" content="{GoGetImport} git {CloneLink}">`,
 		map[string]string{
 			"GoGetImport": ComposeGoGetImport(username, reponame),
 			"CloneLink":   repo_model.ComposeHTTPSCloneURL(username, reponame),
-		}))
+		})
+	if err != nil {
+		log.Error(err.Error())
+		ctx.PlainText(http.StatusInternalServerError, "expand vars failed")
+		return
+	}
+	ctx.PlainText(http.StatusOK, res)
 }
 
 // RedirectToRepo redirect to a differently-named repository

modules/markup/html.go

@@ -21,9 +21,9 @@ import (
 	"code.gitea.io/gitea/modules/markup/common"
 	"code.gitea.io/gitea/modules/references"
 	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/templates/vars"
 	"code.gitea.io/gitea/modules/util"
 
-	"github.com/unknwon/com"
 	"golang.org/x/net/html"
 	"golang.org/x/net/html/atom"
 	"mvdan.cc/xurls/v2"
@@ -837,7 +837,14 @@ func issueIndexPatternProcessor(ctx *RenderContext, node *html.Node) {
 		reftext := node.Data[ref.RefLocation.Start:ref.RefLocation.End]
 		if exttrack && !ref.IsPull {
 			ctx.Metas["index"] = ref.Issue
-			link = createLink(com.Expand(ctx.Metas["format"], ctx.Metas), reftext, "ref-issue ref-external-issue")
+
+			res, err := vars.Expand(ctx.Metas["format"], ctx.Metas)
+			if err != nil {
+				log.Error(err.Error())
+				return
+			}
+
+			link = createLink(res, reftext, "ref-issue ref-external-issue")
 		} else {
 			// Path determines the type of link that will be rendered. It's unknown at this point whether
 			// the linked item is actually a PR or an issue. Luckily it's of no real consequence because

modules/repository/init.go

@@ -19,10 +19,9 @@ import (
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/templates/vars"
 	"code.gitea.io/gitea/modules/util"
 	asymkey_service "code.gitea.io/gitea/services/asymkey"
-
-	"github.com/unknwon/com"
 )
 
 func prepareRepoCommit(ctx context.Context, repo *repo_model.Repository, tmpDir, repoPath string, opts models.CreateRepoOptions) error {
@@ -61,8 +60,12 @@ func prepareRepoCommit(ctx context.Context, repo *repo_model.Repository, tmpDir,
 		"CloneURL.HTTPS": cloneLink.HTTPS,
 		"OwnerName":      repo.OwnerName,
 	}
+	res, err := vars.Expand(string(data), match)
+	if err != nil {
+		return fmt.Errorf("expand README.md: %v", err)
+	}
 	if err = os.WriteFile(filepath.Join(tmpDir, "README.md"),
-		[]byte(com.Expand(string(data), match)), 0o644); err != nil {
+		[]byte(res), 0o644); err != nil {
 		return fmt.Errorf("write README.md: %v", err)
 	}
 

modules/sync/unique_queue.go

@@ -5,9 +5,7 @@
 
 package sync
 
-import (
-	"github.com/unknwon/com"
-)
+import "code.gitea.io/gitea/modules/util"
 
 // UniqueQueue is a queue which guarantees only one instance of same
 // identity is in the line. Instances with same identity will be
@@ -73,13 +71,13 @@ func (q *UniqueQueue) Queue() <-chan string {
 // Exist returns true if there is an instance with given identity
 // exists in the queue.
 func (q *UniqueQueue) Exist(id interface{}) bool {
-	return q.table.IsRunning(com.ToStr(id))
+	return q.table.IsRunning(util.ToStr(id))
 }
 
 // AddFunc adds new instance to the queue with a custom runnable function,
 // the queue is blocked until the function exits.
 func (q *UniqueQueue) AddFunc(id interface{}, fn func()) {
-	idStr := com.ToStr(id)
+	idStr := util.ToStr(id)
 	q.table.lock.Lock()
 	if _, ok := q.table.pool[idStr]; ok {
 		q.table.lock.Unlock()
@@ -105,5 +103,5 @@ func (q *UniqueQueue) Add(id interface{}) {
 
 // Remove removes instance from the queue.
 func (q *UniqueQueue) Remove(id interface{}) {
-	q.table.Stop(com.ToStr(id))
+	q.table.Stop(util.ToStr(id))
 }

modules/templates/vars/vars.go

@@ -0,0 +1,106 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package vars
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ErrWrongSyntax represents a wrong syntax with a tempate
+type ErrWrongSyntax struct {
+	Template string
+}
+
+func (err ErrWrongSyntax) Error() string {
+	return fmt.Sprintf("Wrong syntax found in %s", err.Template)
+}
+
+// IsErrWrongSyntax returns true if the error is ErrWrongSyntax
+func IsErrWrongSyntax(err error) bool {
+	_, ok := err.(ErrWrongSyntax)
+	return ok
+}
+
+// ErrNoMatchedVar represents an error that no matched vars
+type ErrNoMatchedVar struct {
+	Template string
+	Var      string
+}
+
+func (err ErrNoMatchedVar) Error() string {
+	return fmt.Sprintf("No matched variable %s found for %s", err.Var, err.Template)
+}
+
+// IsErrNoMatchedVar returns true if the error is ErrNoMatchedVar
+func IsErrNoMatchedVar(err error) bool {
+	_, ok := err.(ErrNoMatchedVar)
+	return ok
+}
+
+// Expand replaces all variables like {var} to match
+func Expand(template string, match map[string]string, subs ...string) (string, error) {
+	var (
+		buf   strings.Builder
+		key   strings.Builder
+		enter bool
+	)
+	for _, c := range template {
+		switch {
+		case c == '{':
+			if enter {
+				return "", ErrWrongSyntax{
+					Template: template,
+				}
+			}
+			enter = true
+		case c == '}':
+			if !enter {
+				return "", ErrWrongSyntax{
+					Template: template,
+				}
+			}
+			if key.Len() == 0 {
+				return "", ErrWrongSyntax{
+					Template: template,
+				}
+			}
+
+			if len(match) == 0 {
+				return "", ErrNoMatchedVar{
+					Template: template,
+					Var:      key.String(),
+				}
+			}
+
+			v, ok := match[key.String()]
+			if !ok {
+				if len(subs) == 0 {
+					return "", ErrNoMatchedVar{
+						Template: template,
+						Var:      key.String(),
+					}
+				}
+				v = subs[0]
+			}
+
+			if _, err := buf.WriteString(v); err != nil {
+				return "", err
+			}
+			key.Reset()
+
+			enter = false
+		case enter:
+			if _, err := key.WriteRune(c); err != nil {
+				return "", err
+			}
+		default:
+			if _, err := buf.WriteRune(c); err != nil {
+				return "", err
+			}
+		}
+	}
+	return buf.String(), nil
+}

modules/templates/vars/vars_test.go

@@ -0,0 +1,70 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package vars
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExpandVars(t *testing.T) {
+	kases := []struct {
+		template string
+		maps     map[string]string
+		expected string
+		fail     bool
+	}{
+		{
+			template: "{a}",
+			maps: map[string]string{
+				"a": "1",
+			},
+			expected: "1",
+		},
+		{
+			template: "expand {a}, {b} and {c}",
+			maps: map[string]string{
+				"a": "1",
+				"b": "2",
+				"c": "3",
+			},
+			expected: "expand 1, 2 and 3",
+		},
+		{
+			template: "中文内容 {一}, {二} 和 {三} 中文结尾",
+			maps: map[string]string{
+				"一": "11",
+				"二": "22",
+				"三": "33",
+			},
+			expected: "中文内容 11, 22 和 33 中文结尾",
+		},
+		{
+			template: "expand {{a}, {b} and {c}",
+			fail:     true,
+		},
+		{
+			template: "expand {}, {b} and {c}",
+			fail:     true,
+		},
+		{
+			template: "expand }, {b} and {c}",
+			fail:     true,
+		},
+	}
+
+	for _, kase := range kases {
+		t.Run(kase.template, func(t *testing.T) {
+			res, err := Expand(kase.template, kase.maps)
+			if kase.fail {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.EqualValues(t, kase.expected, res)
+		})
+	}
+}

modules/util/util.go

@@ -11,6 +11,8 @@ import (
 	"math/big"
 	"strconv"
 	"strings"
+
+	"github.com/unknwon/com"
 )
 
 // OptionalBool a boolean that can be "null"
@@ -181,3 +183,8 @@ func ToUpperASCII(s string) string {
 	}
 	return string(b)
 }
+
+// ToStr should be replaced
+func ToStr(value interface{}, args ...int) string {
+	return com.ToStr(value, args...)
+}