From 07e91bf049b7c689958b777e79b6063392163f71 Mon Sep 17 00:00:00 2001
From: yp05327 <576951401@qq.com>
Date: Mon, 29 May 2023 05:24:09 +0000
Subject: [PATCH] fix migration

---
 models/migrations/v1_20/v259.go | 109 +++++++++++++++++++++++++++++++-
 1 file changed, 107 insertions(+), 2 deletions(-)

diff --git a/models/migrations/v1_20/v259.go b/models/migrations/v1_20/v259.go
index d64a938ee6..a20f6dc17d 100644
--- a/models/migrations/v1_20/v259.go
+++ b/models/migrations/v1_20/v259.go
@@ -5,12 +5,13 @@ package v1_20 //nolint
 
 import (
 	"fmt"
+	"path"
 	"path/filepath"
 	"strings"
 
+	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
-	repo_module "code.gitea.io/gitea/modules/repository"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/util"
 	"github.com/google/licensecheck"
@@ -28,6 +29,7 @@ func userPath(userName string) string {
 	return filepath.Join(setting.RepoRootPath, strings.ToLower(userName))
 }
 
+// Copy paste from modules/repository/file.go because we cannot import models package
 func findLicenseFile(gitRepo *git.Repository, branchName string) (string, *git.TreeEntry, error) {
 	if branchName == "" {
 		return "", nil, nil
@@ -47,7 +49,110 @@ func findLicenseFile(gitRepo *git.Repository, branchName string) (string, *git.T
 	if err != nil {
 		return "", nil, fmt.Errorf("ListEntries: %w", err)
 	}
-	return repo_module.FindFileInEntries(util.FileTypeLicense, entries, "", "", false)
+	return findFileInEntries(util.FileTypeLicense, entries, "", "", false)
+}
+
+func findFileInEntries(fileType util.FileType, entries []*git.TreeEntry, treePath, language string, tryWellKnownDirs bool) (string, *git.TreeEntry, error) {
+	// Create a list of extensions in priority order
+	// 1. Markdown files - with and without localisation - e.g. README.en-us.md or README.md
+	// 2. Txt files - e.g. README.txt
+	// 3. No extension - e.g. README
+	exts := append(localizedExtensions(".md", language), ".txt", "") // sorted by priority
+	extCount := len(exts)
+	targetFiles := make([]*git.TreeEntry, extCount+1)
+
+	docsEntries := make([]*git.TreeEntry, 3) // (one of docs/, .gitea/ or .github/)
+	for _, entry := range entries {
+		if tryWellKnownDirs && entry.IsDir() {
+			// as a special case for the top-level repo introduction README,
+			// fall back to subfolders, looking for e.g. docs/README.md, .gitea/README.zh-CN.txt, .github/README.txt, ...
+			// (note that docsEntries is ignored unless we are at the root)
+			lowerName := strings.ToLower(entry.Name())
+			switch lowerName {
+			case "docs":
+				if entry.Name() == "docs" || docsEntries[0] == nil {
+					docsEntries[0] = entry
+				}
+			case ".gitea":
+				if entry.Name() == ".gitea" || docsEntries[1] == nil {
+					docsEntries[1] = entry
+				}
+			case ".github":
+				if entry.Name() == ".github" || docsEntries[2] == nil {
+					docsEntries[2] = entry
+				}
+			}
+			continue
+		}
+		if i, ok := util.IsFileExtension(entry.Name(), fileType, exts...); ok {
+			log.Debug("Potential %s file: %s", fileType, entry.Name())
+			if targetFiles[i] == nil || base.NaturalSortLess(targetFiles[i].Name(), entry.Blob().Name()) {
+				if entry.IsLink() {
+					target, err := entry.FollowLinks()
+					if err != nil && !git.IsErrBadLink(err) {
+						return "", nil, err
+					} else if target != nil && (target.IsExecutable() || target.IsRegular()) {
+						targetFiles[i] = entry
+					}
+				} else {
+					targetFiles[i] = entry
+				}
+			}
+		}
+	}
+	var targetFile *git.TreeEntry
+	for _, f := range targetFiles {
+		if f != nil {
+			targetFile = f
+			break
+		}
+	}
+
+	if treePath == "" && targetFile == nil {
+		for _, subTreeEntry := range docsEntries {
+			if subTreeEntry == nil {
+				continue
+			}
+			subTree := subTreeEntry.Tree()
+			if subTree == nil {
+				// this should be impossible; if subTreeEntry exists so should this.
+				continue
+			}
+			var err error
+			childEntries, err := subTree.ListEntries()
+			if err != nil {
+				return "", nil, err
+			}
+
+			subfolder, targetFile, err := findFileInEntries(fileType, childEntries, subTreeEntry.Name(), language, false)
+			if err != nil && !git.IsErrNotExist(err) {
+				return "", nil, err
+			}
+			if targetFile != nil {
+				return path.Join(subTreeEntry.Name(), subfolder), targetFile, nil
+			}
+		}
+	}
+
+	return "", targetFile, nil
+}
+
+func localizedExtensions(ext, languageCode string) (localizedExts []string) {
+	if len(languageCode) < 1 {
+		return []string{ext}
+	}
+
+	lowerLangCode := "." + strings.ToLower(languageCode)
+
+	if strings.Contains(lowerLangCode, "-") {
+		underscoreLangCode := strings.ReplaceAll(lowerLangCode, "-", "_")
+		indexOfDash := strings.Index(lowerLangCode, "-")
+		// e.g. [.zh-cn.md, .zh_cn.md, .zh.md, _zh.md, .md]
+		return []string{lowerLangCode + ext, underscoreLangCode + ext, lowerLangCode[:indexOfDash] + ext, "_" + lowerLangCode[1:indexOfDash] + ext, ext}
+	}
+
+	// e.g. [.en.md, .md]
+	return []string{lowerLangCode + ext, ext}
 }
 
 func detectLicense(file *git.TreeEntry) ([]string, error) {