`6a4cb28`

Backfill relative GitHub submodules

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 days ago

SHA: 6a4cb28f46b240e1d5cf4690603c3bbcff93cd19
Parents: 42a4b83
Tree: 6ee993c

3 changed files

Status	File	+	-
M	`docs/internal/code-tab.md`	11	11
M	`internal/web/handlers/repo/code_tree_rows_test.go`	20	3
M	`internal/web/handlers/repo/submodule_links.go`	13	5

docs/internal/code-tab.mdmodified

  submodule path, and links GitHub or configured shithub clone remotes to
  the local `/{owner}/{repo}/tree/{gitlink-oid}` route when the target
  repo has that commit. If the target repo exists locally but does not
 -have the pinned commit object, and `.gitmodules` points at GitHub, the
 -handler performs a bounded, non-forced fetch of heads/tags from that
 -GitHub remote, re-checks the object, and then links to the exact
 -detached-commit tree when it arrived. Successful backfills update the
 -target repo's default-branch OID when that ref moved, then enqueue the
 -same code-index and size-recalc maintenance used after pushes. Diverged
 -local refs are never force-updated; on fetch failure or still-missing
 -objects, the row links to the target repo's default Code tab so
 -independently-created mirrors don't produce dead links. Unknown,
 -external, absent, or malformed remotes stay as plain `name @ shortsha`
 -rows.
 +have the pinned commit object, and `.gitmodules` points at GitHub or a
 +relative sibling repo, the handler performs a bounded, non-forced fetch
 +of heads/tags from the corresponding GitHub remote, re-checks the
 +object, and then links to the exact detached-commit tree when it
 +arrived. Successful backfills update the target repo's default-branch
 +OID when that ref moved, then enqueue the same code-index and
 +size-recalc maintenance used after pushes. Diverged local refs are
 +never force-updated; on fetch failure or still-missing objects, the row
 +links to the target repo's default Code tab so independently-created
 +mirrors don't produce dead links. Unknown, external, absent, or
 +malformed remotes stay as plain `name @ shortsha` rows.
  The S17 ship excludes the htmx-driven "last commit per entry" column
  that the spec describes — an extra round-trip we can add later without

internal/web/handlers/repo/code_tree_rows_test.gomodified

  func TestGitHubSubmoduleFetchURL_CanonicalizesSupportedRemotes(t *testing.T) {
  	t.Parallel()
 +	cfg := submoduleRouteConfig{
 +		owner:    "FortranGoingOnForty",
 +		repoName: "lib-modules",
 +		baseURL:  "https://shithub.sh",
 +		sshHost:  "git@shithub.sh",
 +	}
  	for _, tt := range []struct {
  		name   string
  			remote: "ssh://git@github.com/FortranGoingOnForty/afs-ld.git",
  			want:   "https://github.com/FortranGoingOnForty/afs-ld.git",
  		},
 +		{
 +			name:   "relative sibling without suffix",
 +			remote: "../fgof-process",
 +			want:   "https://github.com/FortranGoingOnForty/fgof-process.git",
 +		},
 +		{
 +			name:   "relative sibling with suffix",
 +			remote: "../fgof-fs.git",
 +			want:   "https://github.com/FortranGoingOnForty/fgof-fs.git",
 +		},
  	} {
  		tt := tt
  		t.Run(tt.name, func(t *testing.T) {
  			t.Parallel()
 -			got, ok := githubSubmoduleFetchURL(tt.remote)
 +			got, ok := githubSubmoduleFetchURL(cfg, tt.remote)
  			if !ok {
  				t.Fatalf("githubSubmoduleFetchURL(%q) ok = false", tt.remote)
+ 			}
  func TestGitHubSubmoduleFetchURL_RejectsUnsupportedRemotes(t *testing.T) {
  	t.Parallel()
 +	cfg := submoduleRouteConfig{owner: "octo", repoName: "super", baseURL: "https://shithub.sh", sshHost: "git@shithub.sh"}
  	for _, remote := range []string{
  		"https://shithub.sh/tenseleyFlow/bencch.git",
 -		"../afs-ld.git",
 +		"../../../afs-ld.git",
  		"https://example.com/octo/lib.git",
  		"https://github.com/octo/nested/lib.git",
  		"https://github.com/%2F/lib.git",
  		remote := remote
  		t.Run(remote, func(t *testing.T) {
  			t.Parallel()
 -			if got, ok := githubSubmoduleFetchURL(remote); ok || got != "" {
 +			if got, ok := githubSubmoduleFetchURL(cfg, remote); ok || got != "" {
  				t.Fatalf("githubSubmoduleFetchURL(%q) = %q, %v; want empty, false", remote, got, ok)
+ 			}
  		})

internal/web/handlers/repo/submodule_links.gomodified

+ }
  func (h *Handlers) submoduleTreeURL(ctx context.Context, cc *codeContext, remoteURL, oid string) string {
 -	route, ok := submoduleRouteForRemote(submoduleRouteConfig{
 +	cfg := submoduleRouteConfig{
  		owner:    cc.owner,
  		repoName: cc.row.Name,
  		baseURL:  h.d.CloneURLs.BaseURL,
  		sshHost:  h.d.CloneURLs.SSHHost,
 -	}, remoteURL, oid)
 +	}
 +	route, ok := submoduleRouteForRemote(cfg, remoteURL, oid)
  	if !ok {
  		return ""
+ 	}
  		return route.RepoURL
+ 	}
  	if !existsAtCommit {
 -		if fetchURL, ok := githubSubmoduleFetchURL(remoteURL); ok {
 +		if fetchURL, ok := githubSubmoduleFetchURL(cfg, remoteURL); ok {
  			backfilled, backfillErr := h.backfillSubmoduleCommit(ctx, gitDir, fetchURL, oid)
  			if backfillErr != nil {
  				if h.d.Logger != nil {
  	return ownerRepoFromRemotePath(strings.TrimPrefix(u.EscapedPath(), "/"))
+ }
 -func githubSubmoduleFetchURL(remoteURL string) (string, bool) {
 +func githubSubmoduleFetchURL(cfg submoduleRouteConfig, remoteURL string) (string, bool) {
  	remoteURL = strings.TrimSpace(remoteURL)
  	if remoteURL == "" {
  		return "", false
+ 	}
 +	if owner, repoName, ok := submoduleRepoFromRelativeURL(cfg, remoteURL); ok {
 +		return githubRepoFetchURL(owner, repoName), true
 +	}
  	var repoPath string
  	if host, path, ok := scpLikeRemote(remoteURL); ok {
  		if normalizeRemoteHost(host) != "github.com" {
  	if !ok {
  		return "", false
+ 	}
 -	return "https://github.com/" + url.PathEscape(owner) + "/" + url.PathEscape(repoName) + ".git", true
 +	return githubRepoFetchURL(owner, repoName), true
 +}
++
 +func githubRepoFetchURL(owner, repoName string) string {
 +	return "https://github.com/" + url.PathEscape(owner) + "/" + url.PathEscape(repoName) + ".git"
+ }
  func submoduleRepoFromRelativeURL(cfg submoduleRouteConfig, remoteURL string) (owner, repoName string, ok bool) {