appview,knotserver: remove redundant call to DefaultBranch

appview/pages/pages.go

···
 	}
 
 	p.rctx.RepoInfo = params.RepoInfo
+	p.rctx.RepoInfo.Ref = params.Ref
 	p.rctx.RendererType = markup.RendererTypeRepoMarkdown
 
 	if params.ReadmeFileName != "" {

appview/repo/index.go

···
 
 func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) {
 	ref := chi.URLParam(r, "ref")
+
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to fully resolve repo", err)
···
 
 	var forkInfo *types.ForkInfo
 	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {
-		forkInfo, err = getForkInfo(repoInfo, rp, f, user, signedClient)
+		forkInfo, err = getForkInfo(repoInfo, rp, f, result.Ref, user, signedClient)
 		if err != nil {
 			log.Printf("Failed to fetch fork information: %v", err)
 			return
···
 	}
 
 	// TODO: a bit dirty
-	languageInfo, err := rp.getLanguageInfo(f, signedClient, chi.URLParam(r, "ref") == "")
+	languageInfo, err := rp.getLanguageInfo(f, signedClient, result.Ref, ref == "")
 	if err != nil {
 		log.Printf("failed to compute language percentages: %s", err)
 		// non-fatal
···
 func (rp *Repo) getLanguageInfo(
 	f *reporesolver.ResolvedRepo,
 	signedClient *knotclient.SignedClient,
+	currentRef string,
 	isDefaultRef bool,
 ) ([]types.RepoLanguageDetails, error) {
 	// first attempt to fetch from db
 	langs, err := db.GetRepoLanguages(
 		rp.db,
 		db.FilterEq("repo_at", f.RepoAt()),
-		db.FilterEq("ref", f.Ref),
+		db.FilterEq("ref", currentRef),
 	)
 
 	if err != nil || langs == nil {
 		// non-fatal, fetch langs from ks
-		ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref)
+		ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, currentRef)
 		if err != nil {
 			return nil, err
 		}
···
 		for l, s := range ls.Languages {
 			langs = append(langs, db.RepoLanguage{
 				RepoAt:       f.RepoAt(),
-				Ref:          f.Ref,
+				Ref:          currentRef,
 				IsDefaultRef: isDefaultRef,
 				Language:     l,
 				Bytes:        s,
···
 	repoInfo repoinfo.RepoInfo,
 	rp *Repo,
 	f *reporesolver.ResolvedRepo,
+	currentRef string,
 	user *oauth.User,
 	signedClient *knotclient.SignedClient,
 ) (*types.ForkInfo, error) {
···
 	}
 
 	if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool {
-		return branch.Name == f.Ref
+		return branch.Name == currentRef
 	}) {
 		forkInfo.Status = types.MissingBranch
 		return &forkInfo, nil
 	}
 
-	newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, f.Ref, f.Ref)
+	newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, currentRef, currentRef)
 	if err != nil || newHiddenRefResp.StatusCode != http.StatusNoContent {
 		log.Printf("failed to update tracking branch: %s", err)
 		return nil, err
 	}
 
-	hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
+	hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef)
 
 	var status types.AncestorCheckResponse
-	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef)
+	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef)
 	if err != nil {
 		log.Printf("failed to check if fork is ahead/behind: %s", err)
 		return nil, err

appview/repo/repo.go

···
 }
 
 func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {
+	ref := chi.URLParam(r, "ref")
+
 	user := rp.oauth.GetUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 		forkName := fmt.Sprintf("%s", f.Name)
 		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
 
-		_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref)
+		_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, ref)
 		if err != nil {
 			rp.pages.Notice(w, "repo", "Failed to sync repository fork.")
 			return

appview/reporesolver/resolver.go

···
 	"fmt"
 	"log"
 	"net/http"
-	"net/url"
 	"path"
+	"regexp"
 	"strings"
 
 	"github.com/bluesky-social/indigo/atproto/identity"
···
 
 type ResolvedRepo struct {
 	db.Repo
-	OwnerId     identity.Identity
-	Ref         string
-	CurrentDir  string
+	OwnerId    identity.Identity
+	CurrentDir string
+	Ref        string
 
 	rr *RepoResolver
 }
···
 		return nil, fmt.Errorf("malformed middleware")
 	}
 
+	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))
 	ref := chi.URLParam(r, "ref")
 
-	if ref == "" {
-		us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev)
-		if err != nil {
-			return nil, err
-		}
-
-		defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name)
-		if err != nil {
-			return nil, err
-		}
-
-		ref = defaultBranch.Branch
-	}
-
-	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref))
-
 	return &ResolvedRepo{
 		Repo:       *repo,
 		OwnerId:    id,
-		Ref:        ref,
 		CurrentDir: currentDir,
+		Ref:        ref,
 
 		rr: rr,
 	}, nil
···
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s: %v", knot, err)
 	} else {
-		result, err := us.Branches(f.OwnerDid(), f.Name)
-		if err != nil {
+		if result, err := us.Branches(f.OwnerDid(), f.Name); err != nil {
 			log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err)
-		}
-
-		if len(result.Branches) == 0 {
+		} else if len(result.Branches) == 0 {
 			disableFork = true
 		}
 	}
···
 		Name:        f.Name,
 		RepoAt:      repoAt,
 		Description: f.Description,
-		Ref:         f.Ref,
 		IsStarred:   isStarred,
 		Knot:        knot,
 		Spindle:     f.Spindle,
···
 		},
 		DisableFork: disableFork,
 		CurrentDir:  f.CurrentDir,
+		Ref:         f.Ref,
 	}
 
 	if sourceRepo != nil {
···
 // after the ref. for example:
 //
 //	/@icyphox.sh/foorepo/blob/main/abc/xyz/ => abc/xyz/
-func extractPathAfterRef(fullPath, ref string) string {
+func extractPathAfterRef(fullPath string) string {
 	fullPath = strings.TrimPrefix(fullPath, "/")
 
-	ref = url.PathEscape(ref)
+	// match blob/, tree/, or raw/ followed by any ref and then a slash
+	//
+	// captures everything after the final slash
+	pattern := `(?:blob|tree|raw)/[^/]+/(.*)$`
 
-	prefixes := []string{
-		fmt.Sprintf("blob/%s/", ref),
-		fmt.Sprintf("tree/%s/", ref),
-		fmt.Sprintf("raw/%s/", ref),
-	}
+	re := regexp.MustCompile(pattern)
+	matches := re.FindStringSubmatch(fullPath)
 
-	for _, prefix := range prefixes {
-		idx := strings.Index(fullPath, prefix)
-		if idx != -1 {
-			return fullPath[idx+len(prefix):]
-		}
+	if len(matches) > 1 {
+		return matches[1]
 	}
 
 	return ""

appview/state/profile.go

···
 		log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)
 	}
 
-	var didsToResolve []string
-	for _, r := range collaboratingRepos {
-		didsToResolve = append(didsToResolve, r.Did)
-	}
-	for _, byMonth := range timeline.ByMonth {
-		for _, pe := range byMonth.PullEvents.Items {
-			didsToResolve = append(didsToResolve, pe.Repo.Did)
-		}
-		for _, ie := range byMonth.IssueEvents.Items {
-			didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)
-		}
-		for _, re := range byMonth.RepoEvents {
-			didsToResolve = append(didsToResolve, re.Repo.Did)
-			if re.Source != nil {
-				didsToResolve = append(didsToResolve, re.Source.Did)
-			}
-		}
-	}
-
 	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())
 	if err != nil {
 		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

knotserver/git/fork.go

···
 	return nil
 }
 
-func (g *GitRepo) Sync(branch string) error {
+func (g *GitRepo) Sync() error {
+	branch := g.h.String()
+
 	fetchOpts := &git.FetchOptions{
 		RefSpecs: []config.RefSpec{
-			config.RefSpec(fmt.Sprintf("+refs/heads/%s:refs/heads/%s", branch, branch)),
+			config.RefSpec("+" + branch + ":" + branch), // +refs/heads/master:refs/heads/master
 		},
 	}
 

knotserver/handler.go

···
 		r.Delete("/", h.RemoveRepo)
 		r.Route("/fork", func(r chi.Router) {
 			r.Post("/", h.RepoFork)
-			r.Post("/sync/{branch}", h.RepoForkSync)
-			r.Get("/sync/{branch}", h.RepoForkAheadBehind)
+			r.Post("/sync/*", h.RepoForkSync)
+			r.Get("/sync/*", h.RepoForkAheadBehind)
 		})
 	})
 

knotserver/routes.go

···
 }
 
 func (h *Handle) RepoForkAheadBehind(w http.ResponseWriter, r *http.Request) {
-	l := h.l.With("handler", "RepoForkSync")
+	l := h.l.With("handler", "RepoForkAheadBehind")
 
 	data := struct {
 		Did       string `json:"did"`
···
 		name = filepath.Base(source)
 	}
 
-	branch := chi.URLParam(r, "branch")
+	branch := chi.URLParam(r, "*")
 	branch, _ = url.PathUnescape(branch)
 
 	relativeRepoPath := filepath.Join(did, name)
 	repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath)
 
-	gr, err := git.PlainOpen(repoPath)
+	gr, err := git.Open(repoPath, branch)
 	if err != nil {
 		log.Println(err)
 		notFound(w)
 		return
 	}
 
-	err = gr.Sync(branch)
+	err = gr.Sync()
 	if err != nil {
 		l.Error("error syncing repo fork", "error", err.Error())
 		writeError(w, err.Error(), http.StatusInternalServerError)