Move fork to edit logic to a separate file

Author: brechtvl

routers/web/repo/editor.go

@@ -11,16 +11,13 @@ import (
 	"strings"
 
 	git_model "code.gitea.io/gitea/models/git"
-	access_model "code.gitea.io/gitea/models/perm/access"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unit"
 	"code.gitea.io/gitea/modules/charset"
 	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/gitrepo"
 	"code.gitea.io/gitea/modules/json"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/markup"
-	repo_module "code.gitea.io/gitea/modules/repository"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/typesniffer"
@@ -30,7 +27,6 @@ import (
 	"code.gitea.io/gitea/services/context"
 	"code.gitea.io/gitea/services/context/upload"
 	"code.gitea.io/gitea/services/forms"
-	repo_service "code.gitea.io/gitea/services/repository"
 	files_service "code.gitea.io/gitea/services/repository/files"
 )
 
@@ -39,7 +35,6 @@ const (
 	tplEditDiffPreview templates.TplName = "repo/editor/diff_preview"
 	tplDeleteFile      templates.TplName = "repo/editor/delete"
 	tplUploadFile      templates.TplName = "repo/editor/upload"
-	tplForkFile        templates.TplName = "repo/editor/fork"
 
 	frmCommitChoiceDirect    string = "direct"
 	frmCommitChoiceNewBranch string = "commit-to-new-branch"
@@ -117,201 +112,6 @@ func getParentTreeFields(treePath string) (treeNames, treePaths []string) {
 	return treeNames, treePaths
 }
 
-// getEditRepository returns the repository where the actual edits will be written to.
-// This may be a fork of the repository owned by the user. If no repository can be found
-// for editing, nil is returned along with a message explaining why editing is not possible.
-func getEditRepository(ctx *context.Context) (*repo_model.Repository, any) {
-	if context.CanWriteToBranch(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.BranchName) {
-		return ctx.Repo.Repository, nil
-	}
-
-	// If we can't write to the branch, try find a user fork to create a branch in instead
-	userRepo, err := repo_model.GetUserFork(ctx, ctx.Repo.Repository.ID, ctx.Doer.ID)
-	if err != nil {
-		log.Error("GetUserFork: %v", err)
-		return nil, nil
-	}
-	if userRepo == nil {
-		return nil, nil
-	}
-
-	// Load repository information
-	if err := userRepo.LoadOwner(ctx); err != nil {
-		log.Error("LoadOwner: %v", err)
-		return nil, ctx.Tr("repo.editor.fork_internal_error", userRepo.FullName())
-	}
-	if err := userRepo.GetBaseRepo(ctx); err != nil || userRepo.BaseRepo == nil {
-		if err != nil {
-			log.Error("GetBaseRepo: %v", err)
-		} else {
-			log.Error("GetBaseRepo: Expected a base repo for user fork", err)
-		}
-		return nil, ctx.Tr("repo.editor.fork_internal_error", userRepo.FullName())
-	}
-
-	// Check code unit, archiving and permissions.
-	if !userRepo.UnitEnabled(ctx, unit.TypeCode) {
-		return nil, ctx.Tr("repo.editor.fork_code_disabled", userRepo.FullName())
-	}
-	if userRepo.IsArchived {
-		return nil, ctx.Tr("repo.editor.fork_is_archived", userRepo.FullName())
-	}
-	permission, err := access_model.GetUserRepoPermission(ctx, userRepo, ctx.Doer)
-	if err != nil {
-		log.Error("access_model.GetUserRepoPermission: %v", err)
-		return nil, ctx.Tr("repo.editor.fork_internal_error", userRepo.FullName())
-	}
-	if !permission.CanWrite(unit.TypeCode) {
-		return nil, ctx.Tr("repo.editor.fork_no_permission", userRepo.FullName())
-	}
-
-	ctx.Data["ForkRepo"] = userRepo
-	return userRepo, nil
-}
-
-// GetEditRepository returns the repository where the edits will be written to.
-// If no repository is editable, redirects to a page to create a fork.
-func GetEditRepositoryOrFork(ctx *context.Context, editOperation string) *repo_model.Repository {
-	editRepo, notEditableMessage := getEditRepository(ctx)
-	if editRepo != nil {
-		return editRepo
-	}
-
-	// No editable repository, suggest to create a fork
-	forkToEditFileCommon(ctx, editOperation, ctx.Repo.TreePath, notEditableMessage)
-	ctx.HTML(http.StatusOK, tplForkFile)
-	return nil
-}
-
-// GetEditRepository returns the repository where the edits will be written to.
-// If no repository is editable, display an error.
-func GetEditRepositoryOrError(ctx *context.Context, tpl templates.TplName, form any) *repo_model.Repository {
-	editRepo, _ := getEditRepository(ctx)
-	if editRepo == nil {
-		// No editable repo, maybe the fork was deleted in the meantime
-		ctx.RenderWithErr(ctx.Tr("repo.editor.cannot_find_editable_repo"), tpl, form)
-		return nil
-	}
-	return editRepo
-}
-
-// CheckPushEditBranch chesk if pushing to the branch in the edit repository is possible,
-// and if not renders an error and returns false.
-func CheckCanPushEditBranch(ctx *context.Context, editRepo *repo_model.Repository, branchName string, tpl templates.TplName, form any) bool {
-	// When pushing to a fork or another branch on the same repository, it should not exist yet
-	if ctx.Repo.Repository != editRepo || ctx.Repo.BranchName != branchName {
-		if exist, err := git_model.IsBranchExist(ctx, editRepo.ID, branchName); err == nil && exist {
-			ctx.Data["Err_NewBranchName"] = true
-			ctx.RenderWithErr(ctx.Tr("repo.editor.branch_already_exists", branchName), tpl, form)
-			return false
-		}
-	}
-
-	// Check for protected branch
-	canCommitToBranch, err := context.CanCommitToBranch(ctx, ctx.Doer, editRepo, branchName)
-	if err != nil {
-		log.Error("CanCommitToBranch: %v", err)
-	}
-	if !canCommitToBranch.CanCommitToBranch {
-		ctx.Data["Err_NewBranchName"] = true
-		ctx.RenderWithErr(ctx.Tr("repo.editor.cannot_commit_to_protected_branch", branchName), tpl, form)
-		return false
-	}
-
-	return true
-}
-
-// PushEditBranchOrError pushes the branch that editing will be applied on top of
-// to the user fork, if needed. On failure, it displays and returns an error. The
-// branch name to be used for editing is returned.
-func PushEditBranchOrError(ctx *context.Context, editRepo *repo_model.Repository, branchName string, tpl templates.TplName, form any) (string, error) {
-	if editRepo == ctx.Repo.Repository {
-		return ctx.Repo.BranchName, nil
-	}
-
-	// If editing a user fork, first push the branch to that repository
-	baseRepo := ctx.Repo.Repository
-	baseBranchName := ctx.Repo.BranchName
-
-	log.Trace("pushBranchToUserRepo: pushing branch to user repo for editing: %s:%s %s:%s", baseRepo.FullName(), baseBranchName, editRepo.FullName(), branchName)
-
-	if err := git.Push(ctx, baseRepo.RepoPath(), git.PushOptions{
-		Remote: editRepo.RepoPath(),
-		Branch: baseBranchName + ":" + branchName,
-		Env:    repo_module.PushingEnvironment(ctx.Doer, editRepo),
-	}); err != nil {
-		ctx.RenderWithErr(ctx.Tr("repo.editor.fork_failed_to_push_branch", branchName), tpl, form)
-		return "", nil
-	}
-
-	return branchName, nil
-}
-
-// UpdateEditRepositoryIsEmpty updates the the edit repository to mark it as no longer empty
-func UpdateEditRepositoryIsEmpty(ctx *context.Context, editRepo *repo_model.Repository) {
-	if !editRepo.IsEmpty {
-		return
-	}
-
-	editGitRepo, err := gitrepo.OpenRepository(git.DefaultContext, editRepo)
-	if err != nil {
-		log.Error("gitrepo.OpenRepository: %v", err)
-		return
-	}
-	if editGitRepo == nil {
-		return
-	}
-
-	if isEmpty, err := editGitRepo.IsEmpty(); err == nil && !isEmpty {
-		_ = repo_model.UpdateRepositoryCols(ctx, &repo_model.Repository{ID: editRepo.ID, IsEmpty: false}, "is_empty")
-	}
-	editGitRepo.Close()
-}
-
-func forkToEditFileCommon(ctx *context.Context, editOperation, treePath string, notEditableMessage any) {
-	// Check if the filename (and additional path) is specified in the querystring
-	// (filename is a misnomer, but kept for compatibility with GitHub)
-	filePath, _ := path.Split(ctx.Req.URL.Query().Get("filename"))
-	filePath = strings.Trim(filePath, "/")
-	treeNames, treePaths := getParentTreeFields(path.Join(ctx.Repo.TreePath, filePath))
-
-	ctx.Data["EditOperation"] = editOperation
-	ctx.Data["TreePath"] = treePath
-	ctx.Data["TreeNames"] = treeNames
-	ctx.Data["TreePaths"] = treePaths
-	ctx.Data["CanForkRepo"] = notEditableMessage == nil
-	ctx.Data["NotEditableMessage"] = notEditableMessage
-}
-
-func ForkToEditFilePost(ctx *context.Context) {
-	form := web.GetForm(ctx).(*forms.ForkToEditRepoFileForm)
-
-	editRepo, notEditableMessage := getEditRepository(ctx)
-
-	ctx.Data["PageHasPosted"] = true
-
-	// Fork repository, if it doesn't already exist
-	if editRepo == nil && notEditableMessage == nil {
-		_, err := ForkRepository(ctx, ctx.Doer, repo_service.ForkRepoOptions{
-			BaseRepo:     ctx.Repo.Repository,
-			Name:         GetUniqueRepositoryName(ctx, ctx.Repo.Repository.Name),
-			Description:  ctx.Repo.Repository.Description,
-			SingleBranch: ctx.Repo.BranchName,
-		}, tplForkFile, form)
-		if err != nil {
-			forkToEditFileCommon(ctx, form.EditOperation, form.TreePath, notEditableMessage)
-			ctx.HTML(http.StatusOK, tplForkFile)
-			return
-		}
-	}
-
-	// Redirect back to editing page
-	ctx.Redirect(path.Join(ctx.Repo.RepoLink, form.EditOperation, util.PathEscapeSegments(ctx.Repo.BranchName), util.PathEscapeSegments(form.TreePath)))
-}
-
-// editFileCommon setup common context, and return repository that will be edited.
-// If no repository can be found for editing, nil is returned along with a message
-// explaining why editing is not possible.
 func editFileCommon(ctx *context.Context, isNewFile bool) {
 	ctx.Data["PageIsEdit"] = true
 	ctx.Data["IsNewFile"] = isNewFile
@@ -323,7 +123,7 @@ func editFileCommon(ctx *context.Context, isNewFile bool) {
 }
 
 func editFile(ctx *context.Context, isNewFile bool) {
-	editRepo := GetEditRepositoryOrFork(ctx, util.Iif(isNewFile, "_new", "_edit"))
+	editRepo := getEditRepositoryOrFork(ctx, util.Iif(isNewFile, "_new", "_edit"))
 	if editRepo == nil {
 		return
 	}
@@ -464,15 +264,15 @@ func editFilePost(ctx *context.Context, form forms.EditRepoFileForm, isNewFile b
 		return
 	}
 
-	editRepo := GetEditRepositoryOrError(ctx, tplEditFile, &form)
+	editRepo := getEditRepositoryOrError(ctx, tplEditFile, &form)
 	if editRepo == nil {
 		return
 	}
 
 	renderCommitRights(ctx, editRepo)
 
 	// Cannot commit to an existing branch if user doesn't have rights
-	if !CheckCanPushEditBranch(ctx, editRepo, branchName, tplEditFile, &form) {
+	if !canPushToEditRepository(ctx, editRepo, branchName, tplEditFile, &form) {
 		return
 	}
 
@@ -503,7 +303,7 @@ func editFilePost(ctx *context.Context, form forms.EditRepoFileForm, isNewFile b
 		operation = "create"
 	}
 
-	editBranchName, err := PushEditBranchOrError(ctx, editRepo, branchName, tplEditFile, &form)
+	editBranchName, err := pushToEditRepositoryOrError(ctx, editRepo, branchName, tplEditFile, &form)
 	if err != nil {
 		return
 	}
@@ -602,7 +402,7 @@ func editFilePost(ctx *context.Context, form forms.EditRepoFileForm, isNewFile b
 		}
 	}
 
-	UpdateEditRepositoryIsEmpty(ctx, editRepo)
+	updateEditRepositoryIsEmpty(ctx, editRepo)
 
 	redirectForCommitChoice(ctx, editRepo, form.CommitChoice, branchName, form.TreePath)
 }
@@ -652,7 +452,7 @@ func DiffPreviewPost(ctx *context.Context) {
 
 // DeleteFile render delete file page
 func DeleteFile(ctx *context.Context) {
-	editRepo := GetEditRepositoryOrFork(ctx, "_delete")
+	editRepo := getEditRepositoryOrFork(ctx, "_delete")
 	if editRepo == nil {
 		return
 	}
@@ -704,15 +504,15 @@ func DeleteFilePost(ctx *context.Context) {
 		return
 	}
 
-	editRepo := GetEditRepositoryOrError(ctx, tplDeleteFile, &form)
+	editRepo := getEditRepositoryOrError(ctx, tplDeleteFile, &form)
 	if editRepo == nil {
 		return
 	}
 
 	renderCommitRights(ctx, editRepo)
 
 	// Cannot commit to an existing branch if user doesn't have rights
-	if !CheckCanPushEditBranch(ctx, editRepo, branchName, tplDeleteFile, &form) {
+	if !canPushToEditRepository(ctx, editRepo, branchName, tplDeleteFile, &form) {
 		return
 	}
 
@@ -732,7 +532,7 @@ func DeleteFilePost(ctx *context.Context) {
 		return
 	}
 
-	editBranchName, err := PushEditBranchOrError(ctx, editRepo, branchName, tplDeleteFile, &form)
+	editBranchName, err := pushToEditRepositoryOrError(ctx, editRepo, branchName, tplDeleteFile, &form)
 	if err != nil {
 		return
 	}
@@ -834,7 +634,7 @@ func DeleteFilePost(ctx *context.Context) {
 
 // UploadFile render upload file page
 func UploadFile(ctx *context.Context) {
-	editRepo := GetEditRepositoryOrFork(ctx, "_upload")
+	editRepo := getEditRepositoryOrFork(ctx, "_upload")
 	if editRepo == nil {
 		return
 	}
@@ -903,14 +703,14 @@ func UploadFilePost(ctx *context.Context) {
 		return
 	}
 
-	editRepo := GetEditRepositoryOrError(ctx, tplUploadFile, &form)
+	editRepo := getEditRepositoryOrError(ctx, tplUploadFile, &form)
 	if editRepo == nil {
 		return
 	}
 
 	renderCommitRights(ctx, editRepo)
 
-	if !CheckCanPushEditBranch(ctx, editRepo, branchName, tplUploadFile, &form) {
+	if !canPushToEditRepository(ctx, editRepo, branchName, tplUploadFile, &form) {
 		return
 	}
 
@@ -957,7 +757,7 @@ func UploadFilePost(ctx *context.Context) {
 		return
 	}
 
-	editBranchName, err := PushEditBranchOrError(ctx, editRepo, branchName, tplUploadFile, &form)
+	editBranchName, err := pushToEditRepositoryOrError(ctx, editRepo, branchName, tplUploadFile, &form)
 	if err != nil {
 		return
 	}
@@ -1029,7 +829,7 @@ func UploadFilePost(ctx *context.Context) {
 		return
 	}
 
-	UpdateEditRepositoryIsEmpty(ctx, editRepo)
+	updateEditRepositoryIsEmpty(ctx, editRepo)
 
 	redirectForCommitChoice(ctx, editRepo, form.CommitChoice, branchName, form.TreePath)
 }
@@ -1122,23 +922,6 @@ func GetUniquePatchBranchName(ctx *context.Context, editRepo *repo_model.Reposit
 	return ""
 }
 
-// GetUniqueRepositoryName Gets a unique repository name for a user
-// It will append a -<num> postfix if the name is already taken
-func GetUniqueRepositoryName(ctx *context.Context, name string) string {
-	uniqueName := name
-	i := 1
-
-	for {
-		_, err := repo_model.GetRepositoryByName(ctx, ctx.Doer.ID, uniqueName)
-		if err != nil || repo_model.IsErrRepoNotExist(err) {
-			return uniqueName
-		}
-
-		uniqueName = fmt.Sprintf("%s-%d", name, i)
-		i++
-	}
-}
-
 // GetClosestParentWithFiles Recursively gets the path of parent in a tree that has files (used when file in a tree is
 // deleted). Returns "" for the root if no parents other than the root have files. If the given treePath isn't a
 // SubTree or it has no entries, we go up one dir and see if we can return the user to that listing.