feat: vendor gitea 1.16.2

package/gitea/source/modules/templates/htmlrenderer.go

@@ -6,21 +6,18 @@ package templates
 import (
 	"bufio"
 	"bytes"
-	"context"
 	"errors"
 	"fmt"
+	"html/template"
 	"io"
-	"net/http"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
-	"sync"
 	"sync/atomic"
 	texttemplate "text/template"
 
 	"code.gitea.io/gitea/modules/assetfs"
-	"code.gitea.io/gitea/modules/graceful"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/templates/scopedtmpl"
@@ -31,58 +28,27 @@ type TemplateExecutor scopedtmpl.TemplateExecutor
 
 type TplName string
 
-type HTMLRender struct {
+type tmplRender struct {
 	templates atomic.Pointer[scopedtmpl.ScopedTemplate]
+
+	collectTemplateNames func() ([]string, error)
+	readTemplateContent  func(name string) ([]byte, error)
 }
 
-var (
-	htmlRender     *HTMLRender
-	htmlRenderOnce sync.Once
-)
-
-var ErrTemplateNotInitialized = errors.New("template system is not initialized, check your log for errors")
-
-func (h *HTMLRender) HTML(w io.Writer, status int, tplName TplName, data any, ctx context.Context) error { //nolint:revive // we don't use ctx, only pass it to the template executor
-	name := string(tplName)
-	if respWriter, ok := w.(http.ResponseWriter); ok {
-		if respWriter.Header().Get("Content-Type") == "" {
-			respWriter.Header().Set("Content-Type", "text/html; charset=utf-8")
-		}
-		respWriter.WriteHeader(status)
-	}
-	t, err := h.TemplateLookup(name, ctx)
-	if err != nil {
-		return texttemplate.ExecError{Name: name, Err: err}
-	}
-	return t.Execute(w, data)
+func (h *tmplRender) Templates() *scopedtmpl.ScopedTemplate {
+	return h.templates.Load()
 }
 
-func (h *HTMLRender) TemplateLookup(name string, ctx context.Context) (TemplateExecutor, error) { //nolint:revive // we don't use ctx, only pass it to the template executor
-	tmpls := h.templates.Load()
-	if tmpls == nil {
-		return nil, ErrTemplateNotInitialized
-	}
-	m := NewFuncMap()
-	m["ctx"] = func() any { return ctx }
-	return tmpls.Executor(name, m)
-}
-
-func (h *HTMLRender) CompileTemplates() error {
-	assets := AssetFS()
-	extSuffix := ".tmpl"
+func (h *tmplRender) recompileTemplates(dummyFuncMap template.FuncMap) error {
 	tmpls := scopedtmpl.NewScopedTemplate()
-	tmpls.Funcs(NewFuncMap())
-	files, err := ListWebTemplateAssetNames(assets)
+	tmpls.Funcs(dummyFuncMap)
+	names, err := h.collectTemplateNames()
 	if err != nil {
-		return nil
+		return err
 	}
-	for _, file := range files {
-		if !strings.HasSuffix(file, extSuffix) {
-			continue
-		}
-		name := strings.TrimSuffix(file, extSuffix)
+	for _, name := range names {
 		tmpl := tmpls.New(filepath.ToSlash(name))
-		buf, err := assets.ReadFile(file)
+		buf, err := h.readTemplateContent(name)
 		if err != nil {
 			return err
 		}
@@ -95,55 +61,20 @@ func (h *HTMLRender) CompileTemplates() error {
 	return nil
 }
 
-// HTMLRenderer init once and returns the globally shared html renderer
-func HTMLRenderer() *HTMLRender {
-	htmlRenderOnce.Do(initHTMLRenderer)
-	return htmlRender
+func ReloadAllTemplates() error {
+	return errors.Join(PageRendererReload(), MailRendererReload())
 }
 
-func ReloadHTMLTemplates() error {
-	log.Trace("Reloading HTML templates")
-	if err := htmlRender.CompileTemplates(); err != nil {
-		log.Error("Template error: %v\n%s", err, log.Stack(2))
-		return err
-	}
-	return nil
-}
-
-func initHTMLRenderer() {
-	rendererType := "static"
-	if !setting.IsProd {
-		rendererType = "auto-reloading"
-	}
-	log.Debug("Creating %s HTML Renderer", rendererType)
-
-	htmlRender = &HTMLRender{}
-	if err := htmlRender.CompileTemplates(); err != nil {
-		p := &templateErrorPrettier{assets: AssetFS()}
-		wrapTmplErrMsg(p.handleFuncNotDefinedError(err))
-		wrapTmplErrMsg(p.handleUnexpectedOperandError(err))
-		wrapTmplErrMsg(p.handleExpectedEndError(err))
-		wrapTmplErrMsg(p.handleGenericTemplateError(err))
-		wrapTmplErrMsg(fmt.Sprintf("CompileTemplates error: %v", err))
-	}
-
-	if !setting.IsProd {
-		go AssetFS().WatchLocalChanges(graceful.GetManager().ShutdownContext(), func() {
-			_ = ReloadHTMLTemplates()
-		})
-	}
-}
-
-func wrapTmplErrMsg(msg string) {
-	if msg == "" {
+func processStartupTemplateError(err error) {
+	if err == nil {
 		return
 	}
-	if setting.IsProd {
+	if setting.IsProd || setting.IsInTesting {
 		// in prod mode, Gitea must have correct templates to run
-		log.Fatal("Gitea can't run with template errors: %s", msg)
+		log.Fatal("Gitea can't run with template errors: %v", err)
 	}
 	// in dev mode, do not need to really exit, because the template errors could be fixed by developer soon and the templates get reloaded
-	log.Error("There are template errors but Gitea continues to run in dev mode: %s", msg)
+	log.Error("There are template errors but Gitea continues to run in dev mode: %v", err)
 }
 
 type templateErrorPrettier struct {
@@ -158,7 +89,7 @@ func (p *templateErrorPrettier) handleGenericTemplateError(err error) string {
 		return ""
 	}
 	tmplName, lineStr, message := groups[1], groups[2], groups[3]
-	return p.makeDetailedError(message, tmplName, lineStr, -1, "")
+	return p.makeDetailedError(message, tmplName, lineStr, "", "")
 }
 
 var reFuncNotDefinedError = regexp.MustCompile(`^template: (.*):([0-9]+): (function "(.*)" not defined)`)
@@ -170,7 +101,7 @@ func (p *templateErrorPrettier) handleFuncNotDefinedError(err error) string {
 	}
 	tmplName, lineStr, message, funcName := groups[1], groups[2], groups[3], groups[4]
 	funcName, _ = strconv.Unquote(`"` + funcName + `"`)
-	return p.makeDetailedError(message, tmplName, lineStr, -1, funcName)
+	return p.makeDetailedError(message, tmplName, lineStr, "", funcName)
 }
 
 var reUnexpectedOperandError = regexp.MustCompile(`^template: (.*):([0-9]+): (unexpected "(.*)" in operand)`)
@@ -182,7 +113,7 @@ func (p *templateErrorPrettier) handleUnexpectedOperandError(err error) string {
 	}
 	tmplName, lineStr, message, unexpected := groups[1], groups[2], groups[3], groups[4]
 	unexpected, _ = strconv.Unquote(`"` + unexpected + `"`)
-	return p.makeDetailedError(message, tmplName, lineStr, -1, unexpected)
+	return p.makeDetailedError(message, tmplName, lineStr, "", unexpected)
 }
 
 var reExpectedEndError = regexp.MustCompile(`^template: (.*):([0-9]+): (expected end; found (.*))`)
@@ -193,7 +124,7 @@ func (p *templateErrorPrettier) handleExpectedEndError(err error) string {
 		return ""
 	}
 	tmplName, lineStr, message, unexpected := groups[1], groups[2], groups[3], groups[4]
-	return p.makeDetailedError(message, tmplName, lineStr, -1, unexpected)
+	return p.makeDetailedError(message, tmplName, lineStr, "", unexpected)
 }
 
 var (
@@ -223,20 +154,20 @@ func HandleTemplateRenderingError(err error) string {
 
 const dashSeparator = "----------------------------------------------------------------------"
 
-func (p *templateErrorPrettier) makeDetailedError(errMsg, tmplName string, lineNum, posNum any, target string) string {
+func (p *templateErrorPrettier) makeDetailedError(errMsg, tmplName, lineNumStr, posNumStr, target string) string {
 	code, layer, err := p.assets.ReadLayeredFile(tmplName + ".tmpl")
 	if err != nil {
 		return fmt.Sprintf("template error: %s, and unable to find template file %q", errMsg, tmplName)
 	}
-	line, err := util.ToInt64(lineNum)
+	line, err := strconv.Atoi(lineNumStr)
 	if err != nil {
-		return fmt.Sprintf("template error: %s, unable to parse template %q line number %q", errMsg, tmplName, lineNum)
+		return fmt.Sprintf("template error: %s, unable to parse template %q line number %s", errMsg, tmplName, lineNumStr)
 	}
-	pos, err := util.ToInt64(posNum)
+	pos, err := strconv.Atoi(util.IfZero(posNumStr, "-1"))
 	if err != nil {
-		return fmt.Sprintf("template error: %s, unable to parse template %q pos number %q", errMsg, tmplName, posNum)
+		return fmt.Sprintf("template error: %s, unable to parse template %q pos number %s", errMsg, tmplName, posNumStr)
 	}
-	detail := extractErrorLine(code, int(line), int(pos), target)
+	detail := extractErrorLine(code, line, pos, target)
 
 	var msg string
 	if pos >= 0 {