fix lint & test

Author: wxiaoguang

routers/api/v1/api.go

@@ -1397,7 +1397,7 @@ func Routes() *web.Router {
 						m.Delete("", bind(api.DeleteFileOptions{}), reqRepoBranchWriter, mustNotBeArchived, repo.DeleteFile)
 					}, reqToken())
 				}, reqRepoReader(unit.TypeCode), context.ReferencesGitRepo())
-				m.Post("/files", reqRepoReader(unit.TypeCode), context.ReferencesGitRepo(), context.RepoRefForAPI, bind(api.GetFilesOptions{}), repo.GetFiles)
+				m.Post("/files", reqRepoReader(unit.TypeCode), context.ReferencesGitRepo(), bind(api.GetFilesOptions{}), repo.GetFiles)
 				m.Get("/signing-key.gpg", misc.SigningKey)
 				m.Group("/topics", func() {
 					m.Combo("").Get(repo.ListTopics).

routers/api/v1/repo/file.go

@@ -896,9 +896,9 @@ func DeleteFile(ctx *context.APIContext) {
 	}
 }
 
-func resolveRefCommit(ctx *context.APIContext, ref string) *utils.RefCommit {
+func resolveRefCommit(ctx *context.APIContext, ref string, minCommitIDLen ...int) *utils.RefCommit {
 	ref = util.IfZero(ref, ctx.Repo.Repository.DefaultBranch)
-	refCommit, err := utils.ResolveRefCommit(ctx, ctx.Repo.Repository, ref)
+	refCommit, err := utils.ResolveRefCommit(ctx, ctx.Repo.Repository, ref, minCommitIDLen...)
 	if errors.Is(err, util.ErrNotExist) {
 		ctx.APIErrorNotFound(err)
 	} else if err != nil {

routers/api/v1/repo/status.go

@@ -177,7 +177,7 @@ func GetCommitStatusesByRef(ctx *context.APIContext) {
 	//   "404":
 	//     "$ref": "#/responses/notFound"
 
-	refCommit := resolveRefCommit(ctx, ctx.PathParam("ref"))
+	refCommit := resolveRefCommit(ctx, ctx.PathParam("ref"), 7)
 	if ctx.Written() {
 		return
 	}
@@ -251,7 +251,7 @@ func GetCombinedCommitStatusByRef(ctx *context.APIContext) {
 	//   "404":
 	//     "$ref": "#/responses/notFound"
 
-	refCommit := resolveRefCommit(ctx, ctx.PathParam("ref"))
+	refCommit := resolveRefCommit(ctx, ctx.PathParam("ref"), 7)
 	if ctx.Written() {
 		return
 	}

routers/api/v1/utils/git.go

@@ -15,37 +15,37 @@ import (
 
 type RefCommit struct {
 	InputRef string
-	Ref      git.RefName
+	RefName  git.RefName
 	Commit   *git.Commit
 	CommitID string
 }
 
 // ResolveRefCommit resolve ref to a commit if exist
-func ResolveRefCommit(ctx reqctx.RequestContext, repo *repo_model.Repository, inputRef string) (_ *RefCommit, err error) {
+func ResolveRefCommit(ctx reqctx.RequestContext, repo *repo_model.Repository, inputRef string, minCommitIDLen ...int) (_ *RefCommit, err error) {
 	gitRepo, err := gitrepo.RepositoryFromRequestContextOrOpen(ctx, repo)
 	if err != nil {
 		return nil, err
 	}
 	refCommit := RefCommit{InputRef: inputRef}
 	if gitrepo.IsBranchExist(ctx, repo, inputRef) {
-		refCommit.Ref = git.RefNameFromBranch(inputRef)
+		refCommit.RefName = git.RefNameFromBranch(inputRef)
 	} else if gitrepo.IsTagExist(ctx, repo, inputRef) {
-		refCommit.Ref = git.RefNameFromTag(inputRef)
-	} else if len(inputRef) == git.ObjectFormatFromName(repo.ObjectFormatName).FullLength() {
-		refCommit.Ref = git.RefNameFromCommit(inputRef)
+		refCommit.RefName = git.RefNameFromTag(inputRef)
+	} else if git.IsStringLikelyCommitID(git.ObjectFormatFromName(repo.ObjectFormatName), inputRef, minCommitIDLen...) {
+		refCommit.RefName = git.RefNameFromCommit(inputRef)
 	}
-	if refCommit.Ref == "" {
+	if refCommit.RefName == "" {
 		return nil, git.ErrNotExist{ID: inputRef}
 	}
-	if refCommit.Commit, err = gitRepo.GetCommit(refCommit.Ref.String()); err != nil {
+	if refCommit.Commit, err = gitRepo.GetCommit(refCommit.RefName.String()); err != nil {
 		return nil, err
 	}
 	refCommit.CommitID = refCommit.Commit.ID.String()
 	return &refCommit, nil
 }
 
 func NewRefCommit(refName git.RefName, commit *git.Commit) *RefCommit {
-	return &RefCommit{InputRef: refName.ShortName(), Ref: refName, Commit: commit, CommitID: commit.ID.String()}
+	return &RefCommit{InputRef: refName.ShortName(), RefName: refName, Commit: commit, CommitID: commit.ID.String()}
 }
 
 // GetGitRefs return git references based on filter

services/context/api.go

@@ -300,16 +300,16 @@ func RepoRefForAPI(next http.Handler) http.Handler {
 
 		if ctx.Repo.GitRepo == nil {
 			panic("no GitRepo, forgot to call the middleware?") // it is a programming error
-			return
 		}
 
 		refName, refType, _ := getRefNameLegacy(ctx.Base, ctx.Repo, ctx.PathParam("*"), ctx.FormTrim("ref"))
 		var err error
-		if refType == git.RefTypeBranch {
+		switch {
+		case refType == git.RefTypeBranch:
 			ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetBranchCommit(refName)
-		} else if refType == git.RefTypeTag {
+		case refType == git.RefTypeTag:
 			ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetTagCommit(refName)
-		} else if refType == git.RefTypeCommit {
+		case refType == git.RefTypeCommit:
 			ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetCommit(refName)
 		}
 		if ctx.Repo.Commit == nil || errors.Is(err, util.ErrNotExist) {

services/repository/files/content.go

@@ -123,9 +123,9 @@ func GetContents(ctx context.Context, repo *repo_model.Repository, refCommit *ut
 		return nil, err
 	}
 
-	refType := refCommit.Ref.RefType()
+	refType := refCommit.RefName.RefType()
 	if refType != git.RefTypeBranch && refType != git.RefTypeTag && refType != git.RefTypeCommit {
-		return nil, fmt.Errorf("no commit found for the ref [ref: %s]", refCommit.Ref)
+		return nil, fmt.Errorf("no commit found for the ref [ref: %s]", refCommit.RefName)
 	}
 
 	selfURL, err := url.Parse(repo.APIURL() + "/contents/" + util.PathEscapeSegments(treePath) + "?ref=" + url.QueryEscape(refCommit.InputRef))
@@ -200,15 +200,15 @@ func GetContents(ctx context.Context, repo *repo_model.Repository, refCommit *ut
 	}
 	// Handle links
 	if entry.IsRegular() || entry.IsLink() || entry.IsExecutable() {
-		downloadURL, err := url.Parse(repo.HTMLURL() + "/raw/" + refCommit.Ref.RefWebLinkPath() + "/" + util.PathEscapeSegments(treePath))
+		downloadURL, err := url.Parse(repo.HTMLURL() + "/raw/" + refCommit.RefName.RefWebLinkPath() + "/" + util.PathEscapeSegments(treePath))
 		if err != nil {
 			return nil, err
 		}
 		downloadURLString := downloadURL.String()
 		contentsResponse.DownloadURL = &downloadURLString
 	}
 	if !entry.IsSubModule() {
-		htmlURL, err := url.Parse(repo.HTMLURL() + "/src/" + refCommit.Ref.RefWebLinkPath() + "/" + util.PathEscapeSegments(treePath))
+		htmlURL, err := url.Parse(repo.HTMLURL() + "/src/" + refCommit.RefName.RefWebLinkPath() + "/" + util.PathEscapeSegments(treePath))
 		if err != nil {
 			return nil, err
 		}