refactor add fork functionality

Inline addRemoteAndRefresh and selectRemoteAndCheckout into
addAndCheckoutRemote. It's not worth having them as separate helper
functions
since they are only called from within addAndCheckoutRemote, and that
function
is not overly long.

This fixes two issues:
- selectRemoteAndCheckout had an unused parameter remoteUrl
- the error return value from addRemoteAndRefresh was not checked

Prefer errors.New over fmt.Errorf when there are no placeholders.

Combine the three regex's into one. While it makes the regex itself more
complex, it simplifies the code.

Author: stefanhaller

pkg/gui/controllers/remotes_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"slices"
@@ -143,8 +144,8 @@ func (self *RemotesController) enter(remote *models.Remote) error {
 	return nil
 }
 
-// Adds a new remote and refreshes the list of remotes.
-func (self *RemotesController) addRemoteAndRefresh(remoteName string, remoteUrl string) error {
+// Adds a new remote, refreshes and selects it, then fetches and checks out the specified branch if provided.
+func (self *RemotesController) addAndCheckoutRemote(remoteName string, remoteUrl string, branchToCheckout string) error {
 	self.c.LogAction(self.c.Tr.Actions.AddRemote)
 	err := self.c.Git().Remote.AddRemote(remoteName, remoteUrl)
 	if err != nil {
@@ -158,11 +159,7 @@ func (self *RemotesController) addRemoteAndRefresh(remoteName string, remoteUrl
 		Scope: []types.RefreshableView{types.REMOTES},
 		Mode:  types.SYNC,
 	})
-	return nil
-}
 
-// Selects the given remote in the UI, fetches it, and checks out the specified branch if profided.
-func (self *RemotesController) selectRemoteAndCheckout(remoteName string, remoteUrl string, branchToCheckout string) error {
 	// Select the remote
 	for idx, remote := range self.c.Model().Remotes {
 		if remote.Name == remoteName {
@@ -175,13 +172,6 @@ func (self *RemotesController) selectRemoteAndCheckout(remoteName string, remote
 	return self.fetchAndCheckout(self.c.Contexts().Remotes.GetSelected(), branchToCheckout)
 }
 
-// Adds a new remote, refreshes and selects it, then fetches and checks out the specified branch if provided.
-func (self *RemotesController) addAndCheckoutRemote(remoteName string, remoteUrl string, branchToCheckout string) error {
-	self.addRemoteAndRefresh(remoteName, remoteUrl)
-
-	return self.selectRemoteAndCheckout(remoteName, remoteUrl, branchToCheckout)
-}
-
 // Ensures the fork remote exists (matching the given URL).
 // If it exists and matches, it’s selected and fetched; otherwise, it’s created and then fetched and checked out.
 // If it does exist but with a different URL, an error is returned.
@@ -190,7 +180,7 @@ func (self *RemotesController) ensureForkRemoteAndCheckout(remoteName string, re
 		if remote.Name == remoteName {
 			hasTheSameUrl := slices.Contains(remote.Urls, remoteUrl)
 			if !hasTheSameUrl {
-				return fmt.Errorf("%s", utils.ResolvePlaceholderString(
+				return errors.New(utils.ResolvePlaceholderString(
 					self.c.Tr.IncompatibleForkAlreadyExistsError,
 					map[string]string{
 						"remoteName": remoteName,
@@ -222,37 +212,27 @@ func (self *RemotesController) add() error {
 	return nil
 }
 
-var (
-	// 1. SCP-like SSH: git@host:owner[/subgroups]/repo(.git)
-	sshScpRegex = regexp.MustCompile(`^(git@[^:]+:)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
-
-	// 2. SSH URL style: ssh://user@host[:port]/owner[/subgroups]/repo(.git)
-	sshUrlRegex = regexp.MustCompile(`^(ssh://[^/]+/)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
-
-	// 3. HTTPS: https://host/owner[/subgroups]/repo(.git)
-	httpRegex = regexp.MustCompile(`^(https?://[^/]+/)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
-)
+// Regex to match and capture parts of a Git remote URL. Supports the following formats:
+// 1. SCP-like SSH: git@host:owner[/subgroups]/repo(.git)
+// 2. SSH URL style: ssh://user@host[:port]/owner[/subgroups]/repo(.git)
+// 3. HTTPS: https://host/owner[/subgroups]/repo(.git)
+var urlRegex = regexp.MustCompile(`^(git@[^:]+:|ssh://[^/]+/|https?://[^/]+/)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
 
 // Rewrites a Git remote URL to use the given fork username,
 // keeping the repo name and host intact. Supports SCP-like SSH, SSH URL style, and HTTPS.
 func replaceForkUsername(remoteUrl, forkUsername string) (string, error) {
 	if forkUsername == "" {
-		return "", fmt.Errorf("fork username cannot be empty")
+		return "", errors.New("fork username cannot be empty")
 	}
 	if remoteUrl == "" {
-		return "", fmt.Errorf("remote URL cannot be empty")
+		return "", errors.New("remote URL cannot be empty")
 	}
 
-	switch {
-	case sshScpRegex.MatchString(remoteUrl):
-		return sshScpRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
-	case sshUrlRegex.MatchString(remoteUrl):
-		return sshUrlRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
-	case httpRegex.MatchString(remoteUrl):
-		return httpRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
-	default:
-		return "", fmt.Errorf("unsupported or invalid remote URL: %s", remoteUrl)
+	if urlRegex.MatchString(remoteUrl) {
+		return urlRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
 	}
+
+	return "", fmt.Errorf("unsupported or invalid remote URL: %s", remoteUrl)
 }
 
 func (self *RemotesController) addFork(baseRemote *models.Remote) error {