Add support for finishing non-standard branches

Author: alexrinass

cmd/finish.go

@@ -15,8 +15,8 @@ import (
 )
 
 // FinishCommand is the implementation of the finish command for topic branches
-func FinishCommand(branchType string, name string, continueOp bool, abortOp bool) {
-	if err := executeFinish(branchType, name, continueOp, abortOp); err != nil {
+func FinishCommand(branchType string, name string, continueOp bool, abortOp bool, force bool) {
+	if err := executeFinish(branchType, name, continueOp, abortOp, force); err != nil {
 		var exitCode errors.ExitCode
 		if flowErr, ok := err.(errors.Error); ok {
 			exitCode = flowErr.ExitCode()
@@ -29,7 +29,7 @@ func FinishCommand(branchType string, name string, continueOp bool, abortOp bool
 }
 
 // executeFinish performs the actual branch finishing logic and returns any errors
-func executeFinish(branchType string, name string, continueOp bool, abortOp bool) error {
+func executeFinish(branchType string, name string, continueOp bool, abortOp bool, force bool) error {
 	// Get configuration early
 	cfg, err := config.LoadConfig()
 	if err != nil {
@@ -71,6 +71,52 @@ func executeFinish(branchType string, name string, continueOp bool, abortOp bool
 		return &errors.NoMergeInProgressError{}
 	}
 
+	// Check if the branch exists first
+	branchExists := false
+	if err := git.BranchExists(name); err == nil {
+		branchExists = true
+	} else if !strings.HasPrefix(name, branchConfig.Prefix) {
+		// If not found as-is, try with prefix
+		fullName := branchConfig.Prefix + name
+		if err := git.BranchExists(fullName); err == nil {
+			name = fullName
+			branchExists = true
+		}
+	}
+
+	// Return early if branch doesn't exist
+	if !branchExists {
+		return &errors.BranchNotFoundError{BranchName: name}
+	}
+
+	// If the branch exists but doesn't have the expected prefix
+	if !strings.HasPrefix(name, branchConfig.Prefix) {
+		if !force {
+			// Get the short name for tag creation
+			shortName := name
+			if strings.Contains(name, "/") {
+				parts := strings.Split(name, "/")
+				shortName = parts[len(parts)-1]
+			}
+
+			// Prompt user for confirmation
+			fmt.Printf("Warning: Branch '%s' is not a standard %s branch (missing prefix '%s').\n", name, branchType, branchConfig.Prefix)
+			fmt.Printf("Finishing this branch will:\n")
+			fmt.Printf("1. Merge it into '%s' using the %s strategy\n", branchConfig.Parent, branchConfig.UpstreamStrategy)
+			if branchConfig.Tag {
+				fmt.Printf("2. Create a tag '%s%s'\n", branchConfig.TagPrefix, shortName)
+			}
+			fmt.Printf("3. Delete the branch after successful merge\n\n")
+			fmt.Printf("Do you want to continue? [y/N]: ")
+
+			var response string
+			fmt.Scanln(&response)
+			if strings.ToLower(response) != "y" {
+				return fmt.Errorf("operation cancelled by user")
+			}
+		}
+	}
+
 	// Regular finish command flow
 	return finishBranch(branchType, name, branchConfig)
 }
@@ -90,12 +136,19 @@ func finishBranch(branchType string, name string, branchConfig config.BranchConf
 		return &errors.InvalidBranchNameError{Name: name}
 	}
 
-	// Get full branch name
-	fullBranchName := branchConfig.Prefix + name
+	// Get the short name by removing the prefix if it exists
+	shortName := name
+	if strings.HasPrefix(name, branchConfig.Prefix) {
+		shortName = strings.TrimPrefix(name, branchConfig.Prefix)
+	} else if strings.Contains(name, "/") {
+		// For non-standard branches, use the last part after the slash
+		parts := strings.Split(name, "/")
+		shortName = parts[len(parts)-1]
+	}
 
 	// Check if branch exists
-	if err := git.BranchExists(fullBranchName); err != nil {
-		return &errors.BranchNotFoundError{BranchName: fullBranchName}
+	if err := git.BranchExists(name); err != nil {
+		return &errors.BranchNotFoundError{BranchName: name}
 	}
 
 	// Get target branch (always the parent branch)
@@ -124,11 +177,11 @@ func finishBranch(branchType string, name string, branchConfig config.BranchConf
 	state := &model.MergeState{
 		Action:          "finish",
 		BranchType:      branchType,
-		BranchName:      name,
+		BranchName:      shortName,
 		CurrentStep:     "merge",
 		ParentBranch:    targetBranch,
 		MergeStrategy:   branchConfig.UpstreamStrategy,
-		FullBranchName:  fullBranchName,
+		FullBranchName:  name,
 		ChildBranches:   childBranches,
 		UpdatedBranches: []string{},
 	}
@@ -220,6 +273,7 @@ func handleContinue(state *model.MergeState, branchConfig config.BranchConfig) e
 	case "create_tag":
 		// Create tag if enabled for this branch type
 		if branchConfig.Tag {
+			// Use BranchName for tag creation - it's already the correct short name
 			tagName := state.BranchName
 			if branchConfig.TagPrefix != "" {
 				tagName = branchConfig.TagPrefix + state.BranchName

cmd/topicbranch.go

@@ -84,21 +84,23 @@ func registerBranchCommand(branchType string) {
 		Use:     "finish [name]",
 		Short:   fmt.Sprintf("Finish a %s branch", branchType),
 		Long:    fmt.Sprintf("Finish a %s branch by merging it into the appropriate base branch", branchType),
-		Example: fmt.Sprintf("  git flow %s finish my-feature", branchType),
+		Example: fmt.Sprintf("  git flow %s finish my-feature\n  git flow %s finish other/branch -f", branchType, branchType),
 		Args:    cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			// Get flags
 			continueOp, _ := cmd.Flags().GetBool("continue")
 			abortOp, _ := cmd.Flags().GetBool("abort")
+			force, _ := cmd.Flags().GetBool("force")
 
 			// Call the generic finish command with the branch type and name
-			FinishCommand(branchType, args[0], continueOp, abortOp)
+			FinishCommand(branchType, args[0], continueOp, abortOp, force)
 		},
 	}
 
 	// Add flags
 	finishCmd.Flags().BoolP("continue", "c", false, "Continue the finish operation after resolving conflicts")
 	finishCmd.Flags().BoolP("abort", "a", false, "Abort the finish operation and return to the original state")
+	finishCmd.Flags().BoolP("force", "f", false, "Force finish a non-standard branch using this branch type's strategy")
 
 	branchCmd.AddCommand(finishCmd)
 

test/cmd/finish_test.go

@@ -939,3 +939,159 @@ func TestFinishReleaseWithMergeContinue(t *testing.T) {
 		t.Error("Expected tag 'v1.0.0' to be created")
 	}
 }
+
+// TestFinishNonStandardBranchWithForce tests finishing a non-standard branch with force flag
+func TestFinishNonStandardBranchWithForce(t *testing.T) {
+	// Setup
+	dir := testutil.SetupTestRepo(t)
+	defer testutil.CleanupTestRepo(t, dir)
+
+	// Initialize git-flow with defaults
+	output, err := testutil.RunGitFlow(t, dir, "init", "-d", "-c")
+	if err != nil {
+		t.Fatalf("Failed to initialize git-flow: %v\nOutput: %s", err, output)
+	}
+
+	// Create a non-standard branch from develop
+	_, err = testutil.RunGit(t, dir, "checkout", "develop")
+	if err != nil {
+		t.Fatalf("Failed to checkout develop: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "checkout", "-b", "custom/my-branch")
+	if err != nil {
+		t.Fatalf("Failed to create custom branch: %v", err)
+	}
+
+	// Add some changes
+	testutil.WriteFile(t, dir, "test.txt", "test content")
+	_, err = testutil.RunGit(t, dir, "add", "test.txt")
+	if err != nil {
+		t.Fatalf("Failed to add file: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "commit", "-m", "Add test file")
+	if err != nil {
+		t.Fatalf("Failed to commit file: %v", err)
+	}
+
+	// Finish the branch using feature strategy with force flag
+	output, err = testutil.RunGitFlow(t, dir, "feature", "finish", "-f", "custom/my-branch")
+	if err != nil {
+		t.Fatalf("Failed to finish custom branch: %v\nOutput: %s", err, output)
+	}
+
+	// Verify branch was merged to develop
+	_, err = testutil.RunGit(t, dir, "checkout", "develop")
+	if err != nil {
+		t.Fatalf("Failed to checkout develop: %v", err)
+	}
+
+	// Check if test.txt exists in develop
+	if !testutil.FileExists(t, dir, "test.txt") {
+		t.Error("Expected test.txt to exist in develop branch")
+	}
+
+	// Verify custom branch was deleted
+	if testutil.BranchExists(t, dir, "custom/my-branch") {
+		t.Error("Expected custom branch to be deleted")
+	}
+}
+
+// TestFinishNonStandardBranchWithoutForce tests finishing a non-standard branch without force flag
+func TestFinishNonStandardBranchWithoutForce(t *testing.T) {
+	// Setup
+	dir := testutil.SetupTestRepo(t)
+	defer testutil.CleanupTestRepo(t, dir)
+
+	// Initialize git-flow with defaults
+	output, err := testutil.RunGitFlow(t, dir, "init", "-d", "-c")
+	if err != nil {
+		t.Fatalf("Failed to initialize git-flow: %v\nOutput: %s", err, output)
+	}
+
+	// Create a non-standard branch from develop
+	_, err = testutil.RunGit(t, dir, "checkout", "develop")
+	if err != nil {
+		t.Fatalf("Failed to checkout develop: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "checkout", "-b", "custom/my-branch")
+	if err != nil {
+		t.Fatalf("Failed to create custom branch: %v", err)
+	}
+
+	// Add some changes
+	testutil.WriteFile(t, dir, "test.txt", "test content")
+	_, err = testutil.RunGit(t, dir, "add", "test.txt")
+	if err != nil {
+		t.Fatalf("Failed to add file: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "commit", "-m", "Add test file")
+	if err != nil {
+		t.Fatalf("Failed to commit file: %v", err)
+	}
+
+	// Try to finish the branch without force flag (should fail)
+	output, err = testutil.RunGitFlow(t, dir, "feature", "finish", "custom/my-branch")
+	if err == nil {
+		t.Fatal("Expected finish to fail without force flag and user confirmation")
+	}
+
+	// Verify branch still exists
+	if !testutil.BranchExists(t, dir, "custom/my-branch") {
+		t.Error("Expected custom branch to still exist")
+	}
+
+	// Verify we're still on the custom branch
+	currentBranch := testutil.GetCurrentBranch(t, dir)
+	if currentBranch != "custom/my-branch" {
+		t.Errorf("Expected to be on custom/my-branch, got %s", currentBranch)
+	}
+}
+
+// TestFinishNonStandardBranchWithTag tests finishing a non-standard branch with tag creation
+func TestFinishNonStandardBranchWithTag(t *testing.T) {
+	// Setup
+	dir := testutil.SetupTestRepo(t)
+	defer testutil.CleanupTestRepo(t, dir)
+
+	// Initialize git-flow with defaults and tag configuration
+	output, err := testutil.RunGitFlow(t, dir, "init", "-d", "-c")
+	if err != nil {
+		t.Fatalf("Failed to initialize git-flow: %v\nOutput: %s", err, output)
+	}
+
+	// Create a non-standard branch from develop
+	_, err = testutil.RunGit(t, dir, "checkout", "develop")
+	if err != nil {
+		t.Fatalf("Failed to checkout develop: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "checkout", "-b", "custom/my-release")
+	if err != nil {
+		t.Fatalf("Failed to create custom branch: %v", err)
+	}
+
+	// Add some changes
+	testutil.WriteFile(t, dir, "release.txt", "release content")
+	_, err = testutil.RunGit(t, dir, "add", "release.txt")
+	if err != nil {
+		t.Fatalf("Failed to add file: %v", err)
+	}
+	_, err = testutil.RunGit(t, dir, "commit", "-m", "Add release file")
+	if err != nil {
+		t.Fatalf("Failed to commit file: %v", err)
+	}
+
+	// Finish the branch using release strategy with force flag
+	output, err = testutil.RunGitFlow(t, dir, "release", "finish", "-f", "custom/my-release")
+	if err != nil {
+		t.Fatalf("Failed to finish custom release branch: %v\nOutput: %s", err, output)
+	}
+
+	// Verify tag was created
+	tagExists, err := testutil.RunGit(t, dir, "tag", "-l", "my-release")
+	if err != nil {
+		t.Fatalf("Failed to list tags: %v", err)
+	}
+	if tagExists == "" {
+		t.Error("Expected tag 'my-release' to exist")
+	}
+}

test/testutil/testutil.go

@@ -51,3 +51,11 @@ func ReadFile(t *testing.T, dir string, name string) string {
 	}
 	return string(content)
 }
+
+// FileExists checks if a file exists in the repository
+func FileExists(t *testing.T, dir string, path string) bool {
+	t.Helper()
+	fullPath := filepath.Join(dir, path)
+	_, err := os.Stat(fullPath)
+	return err == nil
+}