Move branch name validation to model

Author: lafriks

models/error.go

@@ -649,6 +649,51 @@ func (err ErrBranchNotExist) Error() string {
 	return fmt.Sprintf("branch does not exist [name: %s]", err.Name)
 }
 
+// ErrBranchAlreadyExists represents an error that branch with such name already exists
+type ErrBranchAlreadyExists struct {
+	BranchName string
+}
+
+// IsErrBranchAlreadyExists checks if an error is an ErrBranchAlreadyExists.
+func IsErrBranchAlreadyExists(err error) bool {
+	_, ok := err.(ErrBranchAlreadyExists)
+	return ok
+}
+
+func (err ErrBranchAlreadyExists) Error() string {
+	return fmt.Sprintf("branch already exists [name: %s]", err.BranchName)
+}
+
+// ErrBranchNameConflict represents an error that branch name conflicts with other branch
+type ErrBranchNameConflict struct {
+	BranchName string
+}
+
+// IsErrBranchNameConflict checks if an error is an ErrBranchNameConflict.
+func IsErrBranchNameConflict(err error) bool {
+	_, ok := err.(ErrBranchNameConflict)
+	return ok
+}
+
+func (err ErrBranchNameConflict) Error() string {
+	return fmt.Sprintf("branch conflicts with existing branch [name: %s]", err.BranchName)
+}
+
+// ErrTagAlreadyExists represents an error that tag with such name already exists
+type ErrTagAlreadyExists struct {
+	TagName string
+}
+
+// IsErrTagAlreadyExists checks if an error is an ErrTagAlreadyExists.
+func IsErrTagAlreadyExists(err error) bool {
+	_, ok := err.(ErrTagAlreadyExists)
+	return ok
+}
+
+func (err ErrTagAlreadyExists) Error() string {
+	return fmt.Sprintf("tag already exists [name: %s]", err.TagName)
+}
+
 //  __      __      ___.   .__                   __
 // /  \    /  \ ____\_ |__ |  |__   ____   ____ |  | __
 // \   \/\/   // __ \| __ \|  |  \ /  _ \ /  _ \|  |/ /

models/repo_branch.go

@@ -63,8 +63,40 @@ func (repo *Repository) GetBranches() ([]*Branch, error) {
 	return GetBranchesByPath(repo.RepoPath())
 }
 
+// CheckBranchName validates branch name with existing repository branches
+func (repo *Repository) CheckBranchName(name string) error {
+	gitRepo, err := git.OpenRepository(repo.RepoPath())
+	if err != nil {
+		return err
+	}
+
+	if _, err := gitRepo.GetTag(name); err == nil {
+		return ErrTagAlreadyExists{name}
+	}
+
+	branches, err := repo.GetBranches()
+	if err != nil {
+		return err
+	}
+
+	for _, branch := range branches {
+		if branch.Name == name {
+			return ErrBranchAlreadyExists{branch.Name}
+		} else if (len(branch.Name) < len(name) && branch.Name+"/" == name[0:len(branch.Name)+1]) ||
+			(len(branch.Name) > len(name) && name+"/" == branch.Name[0:len(name)+1]) {
+			return ErrBranchNameConflict{branch.Name}
+		}
+	}
+	return nil
+}
+
 // CreateNewBranch creates a new repository branch
 func (repo *Repository) CreateNewBranch(doer *User, oldBranchName, branchName string) (err error) {
+	// Check if branch name can be used
+	if err := repo.CheckBranchName(branchName); err != nil {
+		return err
+	}
+
 	repoWorkingPool.CheckIn(com.ToStr(repo.ID))
 	defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
 
@@ -125,6 +157,11 @@ func (repo *Repository) updateLocalCopyToCommit(commit string) error {
 
 // CreateNewBranchFromCommit creates a new repository branch
 func (repo *Repository) CreateNewBranchFromCommit(doer *User, commit, branchName string) (err error) {
+	// Check if branch name can be used
+	if err := repo.CheckBranchName(branchName); err != nil {
+		return err
+	}
+
 	repoWorkingPool.CheckIn(com.ToStr(repo.ID))
 	defer repoWorkingPool.CheckOut(com.ToStr(repo.ID))
 

routers/repo/branch.go

@@ -5,6 +5,7 @@
 package repo
 
 import (
+	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/auth"
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/context"
@@ -45,37 +46,32 @@ func CreateBranch(ctx *context.Context, form auth.NewBranchForm) {
 		return
 	}
 
-	branches, err := ctx.Repo.Repository.GetBranches()
-	if err != nil {
-		ctx.Handle(500, "GetBranches", err)
-		return
+	var err error
+	if ctx.Repo.IsViewBranch {
+		err = ctx.Repo.Repository.CreateNewBranch(ctx.User, ctx.Repo.BranchName, form.NewBranchName)
+	} else {
+		err = ctx.Repo.Repository.CreateNewBranchFromCommit(ctx.User, ctx.Repo.BranchName, form.NewBranchName)
 	}
-
-	for _, branch := range branches {
-		if branch.Name == form.NewBranchName {
-			ctx.Flash.Error(ctx.Tr("repo.branch.branch_already_exists", branch.Name))
+	if err != nil {
+		if models.IsErrTagAlreadyExists(err) {
+			e := err.(models.ErrTagAlreadyExists)
+			ctx.Flash.Error(ctx.Tr("repo.branch.tag_collision", e.TagName))
 			ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchName)
 			return
-		} else if (len(branch.Name) < len(form.NewBranchName) && branch.Name+"/" == form.NewBranchName[0:len(branch.Name)+1]) ||
-			(len(branch.Name) > len(form.NewBranchName) && form.NewBranchName+"/" == branch.Name[0:len(form.NewBranchName)+1]) {
-			ctx.Flash.Error(ctx.Tr("repo.branch.branch_name_conflict", form.NewBranchName, branch.Name))
+		}
+		if models.IsErrBranchAlreadyExists(err) {
+			e := err.(models.ErrBranchAlreadyExists)
+			ctx.Flash.Error(ctx.Tr("repo.branch.branch_already_exists", e.BranchName))
+			ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchName)
+			return
+		}
+		if models.IsErrBranchNameConflict(err) {
+			e := err.(models.ErrBranchNameConflict)
+			ctx.Flash.Error(ctx.Tr("repo.branch.branch_name_conflict", form.NewBranchName, e.BranchName))
 			ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchName)
 			return
 		}
-	}
-
-	if _, err := ctx.Repo.GitRepo.GetTag(form.NewBranchName); err == nil {
-		ctx.Flash.Error(ctx.Tr("repo.branch.tag_collision", form.NewBranchName))
-		ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchName)
-		return
-	}
 
-	if ctx.Repo.IsViewBranch {
-		err = ctx.Repo.Repository.CreateNewBranch(ctx.User, ctx.Repo.BranchName, form.NewBranchName)
-	} else {
-		err = ctx.Repo.Repository.CreateNewBranchFromCommit(ctx.User, ctx.Repo.BranchName, form.NewBranchName)
-	}
-	if err != nil {
 		ctx.Handle(500, "CreateNewBranch", err)
 		return
 	}