detect license file by const filename

Author: yp05327

models/repo/license.go

@@ -111,3 +111,10 @@ func CopyLicense(ctx context.Context, originalRepo, destRepo *Repository) error
 	}
 	return nil
 }
+
+// CleanRepoLicenses will remove all license record of the repo
+func CleanRepoLicenses(ctx context.Context, repo *Repository) error {
+	return db.DeleteBeans(ctx, &RepoLicense{
+		RepoID: repo.ID,
+	})
+}

modules/util/path.go

@@ -283,47 +283,38 @@ func CommonSkip(name string) bool {
 	return false
 }
 
-type FileType string
-
-const (
-	FileTypeReadme  FileType = "readme"
-	FileTypeLicense FileType = "license"
-)
-
-// IsFileName reports whether name looks like a target name file
+// IsReadmeFileName reports whether name looks like a README file
 // based on its name.
-func IsFileName(name string, fileType FileType) bool {
+func IsReadmeFileName(name string) bool {
 	name = strings.ToLower(name)
-	lenFileType := len(fileType)
-	if len(name) < lenFileType {
+	if len(name) < 6 {
 		return false
-	} else if len(name) == lenFileType {
-		return name == string(fileType)
+	} else if len(name) == 6 {
+		return name == "readme"
 	}
-	return name[:lenFileType+1] == string(fileType)+"."
+	return name[:7] == "readme."
 }
 
-// IsFileExtension reports whether name looks like a target name file
+// IsReadmeFileExtension reports whether name looks like a README file
 // based on its name. It will look through the provided extensions and check if the file matches
 // one of the extensions and provide the index in the extension list.
 // If the filename is `readme.` with an unmatched extension it will match with the index equaling
 // the length of the provided extension list.
 // Note that the '.' should be provided in ext, e.g ".md"
-func IsFileExtension(name string, fileType FileType, ext ...string) (int, bool) {
+func IsReadmeFileExtension(name string, ext ...string) (int, bool) {
 	name = strings.ToLower(name)
-	lenFileType := len(fileType)
-	if len(name) < lenFileType || name[:lenFileType] != string(fileType) {
+	if len(name) < 6 || name[:6] != "readme" {
 		return 0, false
 	}
 
 	for i, extension := range ext {
 		extension = strings.ToLower(extension)
-		if name[lenFileType:] == extension {
+		if name[6:] == extension {
 			return i, true
 		}
 	}
 
-	if name[lenFileType] == '.' {
+	if name[6] == '.' {
 		return len(ext), true
 	}
 

modules/util/path_test.go

@@ -76,10 +76,10 @@ func TestMisc_IsReadmeFileName(t *testing.T) {
 	}
 
 	for _, testCase := range trueTestCases {
-		assert.True(t, IsFileName(testCase, FileTypeReadme))
+		assert.True(t, IsReadmeFileName(testCase))
 	}
 	for _, testCase := range falseTestCases {
-		assert.False(t, IsFileName(testCase, FileTypeReadme))
+		assert.False(t, IsReadmeFileName(testCase))
 	}
 
 	type extensionTestcase struct {
@@ -131,7 +131,7 @@ func TestMisc_IsReadmeFileName(t *testing.T) {
 	}
 
 	for _, testCase := range testCasesExtensions {
-		idx, ok := IsFileExtension(testCase.name, FileTypeReadme, exts...)
+		idx, ok := IsReadmeFileExtension(testCase.name, exts...)
 		assert.Equal(t, testCase.expected, ok)
 		assert.Equal(t, testCase.idx, idx)
 	}

routers/web/repo/branch.go

@@ -89,12 +89,7 @@ func Branches(ctx *context.Context) {
 	pager := context.NewPagination(int(branchesCount), pageSize, page, 5)
 	pager.SetDefaultParams(ctx)
 	ctx.Data["Page"] = pager
-
-	ctx.Data["DetectedLicenseFileName"], err = repo_service.GetDetectedLicenseFileName(ctx, ctx.Repo.Repository, ctx.Repo.Commit)
-	if err != nil {
-		ctx.ServerError("GetDetectedLicenseFileName", err)
-		return
-	}
+	ctx.Data["LicenseFileName"] = repo_service.LicenseFileName
 	ctx.HTML(http.StatusOK, tplBranch)
 }
 

routers/web/repo/commit.go

@@ -101,11 +101,7 @@ func Commits(ctx *context.Context) {
 	pager := context.NewPagination(int(commitsCount), pageSize, page, 5)
 	pager.SetDefaultParams(ctx)
 	ctx.Data["Page"] = pager
-	ctx.Data["DetectedLicenseFileName"], err = repo_service.GetDetectedLicenseFileName(ctx, ctx.Repo.Repository, ctx.Repo.Commit)
-	if err != nil {
-		ctx.ServerError("GetDetectedLicenseFileName", err)
-		return
-	}
+	ctx.Data["LicenseFileName"] = repo_service.LicenseFileName
 	ctx.HTML(http.StatusOK, tplCommits)
 }
 
@@ -223,11 +219,7 @@ func SearchCommits(ctx *context.Context) {
 	ctx.Data["Username"] = ctx.Repo.Owner.Name
 	ctx.Data["Reponame"] = ctx.Repo.Repository.Name
 	ctx.Data["RefName"] = ctx.Repo.RefName
-	ctx.Data["DetectedLicenseFileName"], err = repo_service.GetDetectedLicenseFileName(ctx, ctx.Repo.Repository, ctx.Repo.Commit)
-	if err != nil {
-		ctx.ServerError("GetDetectedLicenseFileName", err)
-		return
-	}
+	ctx.Data["LicenseFileName"] = repo_service.LicenseFileName
 	ctx.HTML(http.StatusOK, tplCommits)
 }
 
@@ -273,12 +265,7 @@ func FileHistory(ctx *context.Context) {
 	pager := context.NewPagination(int(commitsCount), setting.Git.CommitsRangeSize, page, 5)
 	pager.SetDefaultParams(ctx)
 	ctx.Data["Page"] = pager
-
-	ctx.Data["DetectedLicenseFileName"], err = repo_service.GetDetectedLicenseFileName(ctx, ctx.Repo.Repository, ctx.Repo.Commit)
-	if err != nil {
-		ctx.ServerError("GetDetectedLicenseFileName", err)
-		return
-	}
+	ctx.Data["LicenseFileName"] = repo_service.LicenseFileName
 	ctx.HTML(http.StatusOK, tplCommits)
 }
 

routers/web/repo/view.go

@@ -69,6 +69,99 @@ const (
 	tplMigrating    base.TplName = "repo/migrate/migrating"
 )
 
+// locate a README for a tree in one of the supported paths.
+//
+// entries is passed to reduce calls to ListEntries(), so
+// this has precondition:
+//
+//	entries == ctx.Repo.Commit.SubTree(ctx.Repo.TreePath).ListEntries()
+//
+// FIXME: There has to be a more efficient way of doing this
+func findReadmeFileInEntries(ctx *context.Context, entries []*git.TreeEntry, 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", ctx.Locale.Language()), ".txt", "") // sorted by priority
+	extCount := len(exts)
+	readmeFiles := 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.IsReadmeFileExtension(entry.Name(), exts...); ok {
+			log.Debug("Potential readme file: %s", entry.Name())
+			if readmeFiles[i] == nil || base.NaturalSortLess(readmeFiles[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()) {
+						readmeFiles[i] = entry
+					}
+				} else {
+					readmeFiles[i] = entry
+				}
+			}
+		}
+	}
+	var readmeFile *git.TreeEntry
+	for _, f := range readmeFiles {
+		if f != nil {
+			readmeFile = f
+			break
+		}
+	}
+
+	if ctx.Repo.TreePath == "" && readmeFile == 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, readmeFile, err := findReadmeFileInEntries(ctx, childEntries, false)
+			if err != nil && !git.IsErrNotExist(err) {
+				return "", nil, err
+			}
+			if readmeFile != nil {
+				return path.Join(subTreeEntry.Name(), subfolder), readmeFile, nil
+			}
+		}
+	}
+
+	return "", readmeFile, nil
+}
+
 func renderDirectory(ctx *context.Context) {
 	entries := renderDirectoryFiles(ctx, 1*time.Second)
 	if ctx.Written() {
@@ -80,15 +173,37 @@ func renderDirectory(ctx *context.Context) {
 		ctx.Data["Title"] = ctx.Tr("repo.file.title", ctx.Repo.Repository.Name+"/"+path.Base(ctx.Repo.TreePath), ctx.Repo.RefName)
 	}
 
-	subfolder, readmeFile, err := repo_service.FindFileInEntries(util.FileTypeReadme, entries, ctx.Repo.TreePath, ctx.Locale.Language(), true)
+	subfolder, readmeFile, err := findReadmeFileInEntries(ctx, entries, true)
 	if err != nil {
-		ctx.ServerError("findFileInEntries", err)
+		ctx.ServerError("findReadmeFileInEntries", err)
 		return
 	}
 
 	renderReadmeFile(ctx, subfolder, readmeFile)
 }
 
+// localizedExtensions prepends the provided language code with and without a
+// regional identifier to the provided extension.
+// Note: the language code will always be lower-cased, if a region is present it must be separated with a `-`
+// Note: ext should be prefixed with a `.`
+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}
+}
+
 type fileInfo struct {
 	isTextFile bool
 	isLFSFile  bool
@@ -384,7 +499,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry) {
 		rd := charset.ToUTF8WithFallbackReader(io.MultiReader(bytes.NewReader(buf), dataRc), charset.ConvertOpts{})
 
 		shouldRenderSource := ctx.FormString("display") == "source"
-		readmeExist := util.IsFileName(blob.Name(), util.FileTypeReadme)
+		readmeExist := util.IsReadmeFileName(blob.Name())
 		ctx.Data["ReadmeExist"] = readmeExist
 
 		markupType := markup.DetectMarkupTypeByFileName(blob.Name())
@@ -963,11 +1078,7 @@ func renderHomeCode(ctx *context.Context) {
 	ctx.Data["TreeLink"] = treeLink
 	ctx.Data["TreeNames"] = treeNames
 	ctx.Data["BranchLink"] = branchLink
-	ctx.Data["DetectedLicenseFileName"], err = repo_service.GetDetectedLicenseFileName(ctx, ctx.Repo.Repository, ctx.Repo.Commit)
-	if err != nil {
-		ctx.ServerError("GetDetectedLicenseFileName", err)
-		return
-	}
+	ctx.Data["LicenseFileName"] = repo_service.LicenseFileName
 	ctx.HTML(http.StatusOK, tplRepoHome)
 }
 

services/repository/file_test.go renamed to routers/web/repo/view_test.go

@@ -1,7 +1,8 @@
-// Copyright 2023 The Gitea Authors. All rights reserved.
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Copyright 2014 The Gogs Authors. All rights reserved.
 // SPDX-License-Identifier: MIT
 
-package repository
+package repo
 
 import (
 	"reflect"