use regex replace instead of parsing urls

Author: karolzwolak

pkg/gui/controllers/remotes_controller.go

@@ -2,7 +2,7 @@ package controllers
 
 import (
 	"fmt"
-	"net/url"
+	"regexp"
 	"strings"
 
 	"github.com/jesseduffield/gocui"
@@ -186,79 +186,44 @@ func (self *RemotesController) add() error {
 	return nil
 }
 
-// replaceForkUsername replaces the "owner" part of a git remote URL with forkUsername,
-// preserving the repo name (last path segment) and everything else (host, scheme, port, .git suffix).
-// Supported forms:
-//   - SSH scp-like:   git@host:owner[/subgroups]/repo(.git)
-//   - HTTPS/HTTP:     https://host/owner[/subgroups]/repo(.git)
-//
-// Rules:
-//   - If there are fewer than 2 path segments (i.e., no clear owner+repo), return an error.
-//   - For multi-segment paths (e.g., group/subgroup/repo), the entire prefix is replaced by forkUsername.
+var (
+	// SSH scp-like: git@host:owner[/subgroups]/repo(.git)
+	sshRegex = regexp.MustCompile(`^(git@[^:]+:)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
+
+	// HTTPS/HTTP: https://host/owner[/subgroups]/repo(.git)
+	httpRegex = regexp.MustCompile(`^(https?://[^/]+/)([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
+
+	// Shorthand: owner[/subgroups]/repo(.git)
+	shorthandRegex = regexp.MustCompile(`^([^/]+(?:/[^/]+)*)/([^/]+?)(\.git)?$`)
+)
+
+// replaceForkUsername rewrites a Git remote URL so that the owner/group part
+// is replaced with the given fork username, while keeping the repo name and
+// host/protocol intact. Supports SSH, HTTPS, and shorthand forms.
 func replaceForkUsername(remoteUrl, forkUsername string) (string, error) {
 	if forkUsername == "" {
-		return "", fmt.Errorf("Fork username cannot be empty")
+		return "", fmt.Errorf("fork username cannot be empty")
 	}
 	if remoteUrl == "" {
-		return "", fmt.Errorf("Remote url cannot be empty")
+		return "", fmt.Errorf("remote URL cannot be empty")
 	}
 
-	// SSH scp-like (most common): git@host:path
-	if isScpLikeSSH(remoteUrl) {
-		colon := strings.IndexByte(remoteUrl, ':')
-		if colon == -1 {
-			return "", fmt.Errorf("Invalid SSH remote URL (missing ':'): %s", remoteUrl)
-		}
-		path := remoteUrl[colon+1:] // e.g. owner/repo(.git) or group/sub/repo(.git)
-		segments := splitNonEmpty(path, "/")
-		if len(segments) < 2 {
-			return "", fmt.Errorf("Remote URL must include owner and repo: %s", remoteUrl)
-		}
-		last := segments[len(segments)-1] // repo(.git)
-		newPath := forkUsername + "/" + last
-		return remoteUrl[:colon+1] + newPath, nil
+	// SSH
+	if sshRegex.MatchString(remoteUrl) {
+		return sshRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
 	}
 
-	// Try URL parsing for http(s) (and reject anything else).
-	u, err := url.Parse(remoteUrl)
-	if err != nil {
-		return "", fmt.Errorf("Invalid remote URL: %w", err)
-	}
-	if u.Scheme != "https" && u.Scheme != "http" {
-		return "", fmt.Errorf("Unsupported remote URL scheme: %s", u.Scheme)
+	// HTTPS/HTTP
+	if httpRegex.MatchString(remoteUrl) {
+		return httpRegex.ReplaceAllString(remoteUrl, "${1}"+forkUsername+"/$3$4"), nil
 	}
 
-	// u.Path like "/owner[/subgroups]/repo(.git)" or "" or "/"
-	path := strings.Trim(u.Path, "/")
-	segments := splitNonEmpty(path, "/")
-	if len(segments) < 2 {
-		return "", fmt.Errorf("Remote URL must include owner and repo: %s", remoteUrl)
+	// Shorthand (owner/repo)
+	if shorthandRegex.MatchString(remoteUrl) {
+		return shorthandRegex.ReplaceAllString(remoteUrl, forkUsername+"/$2$3"), nil
 	}
 
-	last := segments[len(segments)-1] // repo(.git)
-	u.Path = "/" + forkUsername + "/" + last
-
-	// Preserve trailing slash only if it existed and wasn't empty
-	// (remotes rarely care, but we'll avoid adding one)
-	return u.String(), nil
-}
-
-func isScpLikeSSH(s string) bool {
-	// Minimal heuristic: "<user>@<host>:<path>"
-	at := strings.IndexByte(s, '@')
-	colon := strings.IndexByte(s, ':')
-	return at > 0 && colon > at
-}
-
-func splitNonEmpty(s, sep string) []string {
-	raw := strings.Split(s, sep)
-	out := make([]string, 0, len(raw))
-	for _, p := range raw {
-		if p != "" {
-			out = append(out, p)
-		}
-	}
-	return out
+	return "", fmt.Errorf("unsupported or invalid remote URL: %s", remoteUrl)
 }
 
 func (self *RemotesController) addFork(baseRemote *models.Remote) error {