init: parse route from URL

Make the '<route>' positional arg optional in 'git-bundle-server init'. If
it is not specified (or is an empty string), extract a route from the
supplied clone URI.

Called by 'init', 'core.GetRouteFromUrl()' attempts to match the URL against
SSH, HTTP(S), and filesystem ('file://') URLs. If the URL cannot be matched,
'init' will exit with an error and usage printout.

Also include unit tests of the route matching function to demonstrate its
behavior.

Signed-off-by: Victoria Dye <[email protected]>

Author: vdye

README.md

@@ -104,7 +104,7 @@ being managed by the bundle server.
   server route to find the data for this repository. Otherwise, the route is
   inferred from `<url>` by removing the domain name. For example,
   `https://github.com/git-for-windows/git` is assigned the route
-  `/git-for-windows/git`. Run `git-bundle-server update` to initialize bundle
+  `git-for-windows/git`. Run `git-bundle-server update` to initialize bundle
   information. Configure the web server to recognize this repository at that
   route. Configure scheduler to run `git-bundle-server update-all` as
   necessary.

cmd/git-bundle-server/init.go

@@ -35,12 +35,20 @@ should be hosted at '<route>'.`
 }
 
 func (i *initCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser(i.logger, "git-bundle-server init <url> <route>")
+	parser := argparse.NewArgParser(i.logger, "git-bundle-server init <url> [<route>]")
 	url := parser.PositionalString("url", "the URL of a repository to clone", true)
-	// TODO: allow parsing <route> out of <url>
-	route := parser.PositionalString("route", "the route to host the specified repo", true)
+	route := parser.PositionalString("route", "the route to host the specified repo", false)
 	parser.Parse(ctx, args)
 
+	// Set route value, if needed
+	if *route == "" {
+		var ok bool
+		*route, ok = core.GetRouteFromUrl(*url)
+		if !ok {
+			parser.Usage(ctx, "Cannot parse route from url '%s'; please specify an explicit route.", *url)
+		}
+	}
+
 	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, i.container)
 	bundleProvider := utils.GetDependency[bundles.BundleProvider](ctx, i.container)
 	gitHelper := utils.GetDependency[git.GitHelper](ctx, i.container)

docs/man/git-bundle-server.adoc

@@ -53,15 +53,17 @@ the server.
 
 == COMMANDS
 
-*init* _url_ _route_::
+*init* _url_ [_route_]::
   Initialize a repository for which bundles should be served. The repository is
   cloned into a bare repo from _url_. A base bundle is created for the
-  repository, served from _route_, and the man:cron[8] global bundle update
-  schedule is started.
+  repository and used to initialize the bundle list. If _route_ is specified,
+  the bundle list will be served from that route; otherwise, the route is
+  derived from the _url_. Finally, the man:cron[8] global bundle update schedule
+  is started.
 +
-It is recommended that users specify an SSH (rather than HTTP) URL for the
-_url_ argument to avoid potentially error-causing authentication prompts
-while fetching during scheduled bundle updates.
+It is recommended that users specify an SSH (rather than HTTP) URL for the _url_
+argument to avoid potentially error-causing authentication prompts while
+fetching during scheduled bundle updates.
 
 *start* _route_::
   Start computing bundles for the repository identified by _route_. If the

internal/core/funcs.go

@@ -0,0 +1,29 @@
+package core
+
+import (
+	"regexp"
+	"strings"
+)
+
+// Standalone helper functions for core (repo, cron, etc.) functionality.
+
+func GetRouteFromUrl(url string) (string, bool) {
+	matchers := []*regexp.Regexp{
+		// SSH, matches <username>@<domain>:<route>[.git]
+		regexp.MustCompile(`^[\w-]+@[\w\.-]+:([\w\.-]+/[\w\.-]+)/*$`),
+
+		// HTTP(S), matches http[s]://<domain>/<route>[.git]
+		regexp.MustCompile(`^(?i:http[s]?)://[\w\.-]+/([\w\.-]+/[\w\.-]+)/*$`),
+
+		// Filesystem, matches file://[<path>/]<route>[.git]
+		regexp.MustCompile(`^(?i:file)://[\w\.-/ ]*/([\w\.-]+/[\w\.-]+)/*$`),
+	}
+
+	for _, matcher := range matchers {
+		if groups := matcher.FindStringSubmatch(url); groups != nil {
+			return strings.TrimSuffix(groups[1], ".git"), true
+		}
+	}
+
+	return "", false
+}

internal/core/funcs_test.go

@@ -0,0 +1,122 @@
+package core_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/github/git-bundle-server/internal/core"
+	"github.com/stretchr/testify/assert"
+)
+
+var urlToRouteTests = []struct {
+	url           string
+	expectedRoute string
+	expectedMatch bool
+}{
+	// SSH tests
+	{
+		"[email protected]:git/git.git",
+		"git/git",
+		true,
+	},
+	{
+		"[email protected]:BUNDLE_SERVER.io/git-bundle-server",
+		"BUNDLE_SERVER.io/git-bundle-server",
+		true,
+	},
+	{
+		"[email protected]:imFineWith/trailingSlashes//",
+		"imFineWith/trailingSlashes",
+		true,
+	},
+	{
+		"test@mydomain:deeper/toodeep/cannotmatch",
+		"",
+		false,
+	},
+	{
+		"[email protected]:imFineWith/trailingSlashes/",
+		"imFineWith/trailingSlashes",
+		true,
+	},
+	{
+		"[email protected]:tooshallow",
+		"",
+		false,
+	},
+
+	// HTTP(S) tests
+	{
+		"hTTp://www.mysite.net/org/repo.git/",
+		"org/repo",
+		true,
+	},
+	{
+		"https://domain.test/clone/me",
+		"clone/me",
+		true,
+	},
+	{
+		"https://all.my.repos/having-some_fun/with.valid_ch4racters",
+		"having-some_fun/with.valid_ch4racters",
+		true,
+	},
+	{
+		"http://completely.normal.site/with/invalid/repo",
+		"",
+		false,
+	},
+	{
+		"HTTPS://SCREAM/INTOTHEVOID",
+		"",
+		false,
+	},
+
+	// Filesystem tests
+	{
+		"file:///root/path/to/a/repo.git",
+		"a/repo",
+		true,
+	},
+	{
+		"FILE://RELATIVE/to/me",
+		"to/me",
+		true,
+	},
+	{
+		"fIlE://spaces are allowed/in/path/to/repo",
+		"to/repo",
+		true,
+	},
+	{
+		"fIlE:///butspaces/are/NOT/allowed in route",
+		"",
+		false,
+	},
+	{
+		"file://somepathsaretooshort",
+		"",
+		false,
+	},
+}
+
+func TestGetRouteFromUrl(t *testing.T) {
+	for _, tt := range urlToRouteTests {
+		var title string
+		if tt.expectedMatch {
+			title = fmt.Sprintf("%s => %s", tt.url, tt.expectedRoute)
+		} else {
+			title = fmt.Sprintf("%s (no match)", tt.url)
+		}
+
+		t.Run(title, func(t *testing.T) {
+			route, isMatched := core.GetRouteFromUrl(tt.url)
+			if tt.expectedMatch {
+				assert.True(t, isMatched)
+				assert.Equal(t, tt.expectedRoute, route)
+			} else {
+				assert.False(t, isMatched, "Expected no match, got route %s", route)
+			}
+		})
+	}
+}