remove PreferredTimestampTense,AmbiguousUnicodeDetection,MaxDisplayFileSize

Author: hiifong

custom/conf/app.example.ini

@@ -1286,11 +1286,9 @@ LEVEL = Info
 ;CODE_COMMENT_LINES = 4
 ;;
 ;; Max size of files to be displayed (default is 8MiB)
-;; Deprecated in v1.24
 ;MAX_DISPLAY_FILE_SIZE = 8388608
 ;;
 ;; Detect ambiguous unicode characters in file contents and show warnings on the UI
-;; Deprecated in v1.24
 ;AMBIGUOUS_UNICODE_DETECTION = true
 ;;
 ;; Whether the email of the user should be shown in the Explore Users page
@@ -1340,7 +1338,6 @@ LEVEL = Info
 ;;
 ;; The tense all timestamps should be rendered in. Possible values are `absolute` time (i.e. 1970-01-01, 11:59) and `mixed`.
 ;; `mixed` means most timestamps are rendered in relative time (i.e. 2 days ago).
-;; Deprecated in v1.24
 ;PREFERRED_TIMESTAMP_TENSE = mixed
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

models/migrations/v1_24/v315.go

@@ -30,7 +30,7 @@ func (s *Setting) TableName() string {
 }
 
 func MigrateIniToDatabase(x *xorm.Engine) error {
-	uiMap, err := util.ConfigSectionToMap(setting.UI, "ui", []string{"Reactions", "CustomEmojis"}...)
+	uiMap, err := util.ConfigSectionToMap(setting.UI, "ui", []string{"Reactions", "CustomEmojis", "MaxDisplayFileSize", "PreferredTimestampTense", "AmbiguousUnicodeDetection"}...)
 	if err != nil {
 		return err
 	}

models/migrations/v1_24/v315_test.go

@@ -23,5 +23,5 @@ func Test_MigrateIniToDatabase(t *testing.T) {
 
 	cnt, err := x.Table("system_setting").Where("setting_key LIKE 'ui.%'").Count()
 	assert.NoError(t, err)
-	assert.EqualValues(t, 21, cnt)
+	assert.EqualValues(t, 18, cnt)
 }

modules/charset/escape.go

@@ -8,7 +8,6 @@
 package charset
 
 import (
-	"context"
 	"html/template"
 	"io"
 	"strings"
@@ -22,15 +21,15 @@ import (
 const RuneNBSP = 0xa0
 
 // EscapeControlHTML escapes the unicode control sequences in a provided html document
-func EscapeControlHTML(ctx context.Context, html template.HTML, locale translation.Locale, allowed ...rune) (escaped *EscapeStatus, output template.HTML) {
+func EscapeControlHTML(html template.HTML, locale translation.Locale, allowed ...rune) (escaped *EscapeStatus, output template.HTML) {
 	sb := &strings.Builder{}
-	escaped, _ = EscapeControlReader(ctx, strings.NewReader(string(html)), sb, locale, allowed...) // err has been handled in EscapeControlReader
+	escaped, _ = EscapeControlReader(strings.NewReader(string(html)), sb, locale, allowed...) // err has been handled in EscapeControlReader
 	return escaped, template.HTML(sb.String())
 }
 
 // EscapeControlReader escapes the unicode control sequences in a provided reader of HTML content and writer in a locale and returns the findings as an EscapeStatus
-func EscapeControlReader(ctx context.Context, reader io.Reader, writer io.Writer, locale translation.Locale, allowed ...rune) (escaped *EscapeStatus, err error) {
-	if !setting.Config().UI.AmbiguousUnicodeDetection.Value(ctx) {
+func EscapeControlReader(reader io.Reader, writer io.Writer, locale translation.Locale, allowed ...rune) (escaped *EscapeStatus, err error) {
+	if !setting.UI.AmbiguousUnicodeDetection {
 		_, err = io.Copy(writer, reader)
 		return &EscapeStatus{}, err
 	}

modules/charset/escape_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"code.gitea.io/gitea/modules/setting"
-	"code.gitea.io/gitea/modules/setting/config"
 	"code.gitea.io/gitea/modules/test"
 	"code.gitea.io/gitea/modules/translation"
 
@@ -162,7 +161,7 @@ func TestEscapeControlReader(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			output := &strings.Builder{}
-			status, err := EscapeControlReader(t.Context(), strings.NewReader(tt.text), output, &translation.MockLocale{})
+			status, err := EscapeControlReader(strings.NewReader(tt.text), output, &translation.MockLocale{})
 			assert.NoError(t, err)
 			assert.Equal(t, tt.status, *status)
 			outStr := output.String()
@@ -173,12 +172,10 @@ func TestEscapeControlReader(t *testing.T) {
 }
 
 func TestSettingAmbiguousUnicodeDetection(t *testing.T) {
-	ambiguousUnicodeDetectionValue := setting.Config().UI.AmbiguousUnicodeDetection.Value(t.Context())
-	defer test.MockVariableValue(&ambiguousUnicodeDetectionValue, true)()
-	_, out := EscapeControlHTML(t.Context(), "a test", &translation.MockLocale{})
+	defer test.MockVariableValue(&setting.UI.AmbiguousUnicodeDetection, true)()
+	_, out := EscapeControlHTML("a test", &translation.MockLocale{})
 	assert.EqualValues(t, `a<span class="escaped-code-point" data-escaped="[U+00A0]"><span class="char"> </span></span>test`, out)
-	ambiguousUnicodeDetection := config.Value[bool]{}
-	setting.Config().UI.AmbiguousUnicodeDetection = ambiguousUnicodeDetection.WithDefault(false)
-	_, out = EscapeControlHTML(t.Context(), "a test", &translation.MockLocale{})
+	setting.UI.AmbiguousUnicodeDetection = false
+	_, out = EscapeControlHTML("a test", &translation.MockLocale{})
 	assert.EqualValues(t, `a test`, out)
 }

modules/issue/template/unmarshal.go

@@ -4,7 +4,6 @@
 package template
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"path"
@@ -43,31 +42,31 @@ func Unmarshal(filename string, content []byte) (*api.IssueTemplate, error) {
 }
 
 // UnmarshalFromEntry parses out a valid template from the blob in entry
-func UnmarshalFromEntry(ctx context.Context, entry *git.TreeEntry, dir string) (*api.IssueTemplate, error) {
-	return unmarshalFromEntry(ctx, entry, path.Join(dir, entry.Name())) // Filepaths in Git are ALWAYS '/' separated do not use filepath here
+func UnmarshalFromEntry(entry *git.TreeEntry, dir string) (*api.IssueTemplate, error) {
+	return unmarshalFromEntry(entry, path.Join(dir, entry.Name())) // Filepaths in Git are ALWAYS '/' separated do not use filepath here
 }
 
 // UnmarshalFromCommit parses out a valid template from the commit
-func UnmarshalFromCommit(ctx context.Context, commit *git.Commit, filename string) (*api.IssueTemplate, error) {
+func UnmarshalFromCommit(commit *git.Commit, filename string) (*api.IssueTemplate, error) {
 	entry, err := commit.GetTreeEntryByPath(filename)
 	if err != nil {
 		return nil, fmt.Errorf("get entry for %q: %w", filename, err)
 	}
-	return unmarshalFromEntry(ctx, entry, filename)
+	return unmarshalFromEntry(entry, filename)
 }
 
 // UnmarshalFromRepo parses out a valid template from the head commit of the branch
-func UnmarshalFromRepo(ctx context.Context, repo *git.Repository, branch, filename string) (*api.IssueTemplate, error) {
+func UnmarshalFromRepo(repo *git.Repository, branch, filename string) (*api.IssueTemplate, error) {
 	commit, err := repo.GetBranchCommit(branch)
 	if err != nil {
 		return nil, fmt.Errorf("get commit on branch %q: %w", branch, err)
 	}
 
-	return UnmarshalFromCommit(ctx, commit, filename)
+	return UnmarshalFromCommit(commit, filename)
 }
 
-func unmarshalFromEntry(ctx context.Context, entry *git.TreeEntry, filename string) (*api.IssueTemplate, error) {
-	if size := entry.Blob().Size(); size > setting.Config().UI.MaxDisplayFileSize.Value(ctx) {
+func unmarshalFromEntry(entry *git.TreeEntry, filename string) (*api.IssueTemplate, error) {
+	if size := entry.Blob().Size(); size > setting.UI.MaxDisplayFileSize {
 		return nil, fmt.Errorf("too large: %v > MaxDisplayFileSize", size)
 	}
 

modules/markup/markdown/markdown.go

@@ -156,7 +156,7 @@ func render(ctx *markup.RenderContext, input io.Reader, output io.Writer) error
 	converter := SpecializedMarkdown(ctx)
 	lw := &limitWriter{
 		w:     output,
-		limit: setting.Config().UI.MaxDisplayFileSize.Value(ctx) * 3,
+		limit: setting.UI.MaxDisplayFileSize * 3,
 	}
 
 	// FIXME: should we include a timeout to abort the renderer if it takes too long?