patch of appview: remove `ResolvedRepo` for eternity · round #2 · pull #821 · tangled.org/core

+8 -8

appview/issues/issues.go

···

       103
       103
        
       

     

       104
       104
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       105
       105
        
       		rp.db,

     

       106
       106
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       106
       106
       +
       		db.FilterIn("at_uri", f.Labels),

     

       107
       107
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       108
       108
        
       	)

     

       109
       109
        
       	if err != nil {

     
···

       264
       264
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       265
       265
        
       

     

       266
       266
        
       	// return to all issues page

     

       267
       267
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       267
       267
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       268
       268
        
       	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")

     

       269
       269
        
       }

     

       270
       270
        
       

     
···

       306
       306
        
       		// notify about the issue closure

     

       307
       307
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       308
       308
        
       

     

       309
       309
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       309
       309
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       310
       310
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       311
       311
        
       		return

     

       312
       312
        
       	} else {

     
···

       353
       353
        
       		// notify about the issue reopen

     

       354
       354
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       355
       355
        
       

     

       356
       356
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       356
       356
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       357
       357
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       358
       358
        
       		return

     

       359
       359
        
       	} else {

     
···

       458
       458
        
       	}

     

       459
       459
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       460
       460
        
       

     

       461
       461
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       461
       461
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       462
       462
        
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       463
       463
        
       }

     

       464
       464
        
       

     
···

       827
       827
        
       

     

       828
       828
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       829
       829
        
       		rp.db,

     

       830
       830
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       830
       830
       +
       		db.FilterIn("at_uri", f.Labels),

     

       831
       831
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       832
       832
        
       	)

     

       833
       833
        
       	if err != nil {

     
···

       878
       878
        
       			Open:    true,

     

       879
       879
        
       			Did:     user.Did,

     

       880
       880
        
       			Created: time.Now(),

     

       881
       881
       -
       			Repo:    &f.Repo,

     

       881
       881
       +
       			Repo:    f,

     

       882
       882
        
       		}

     

       883
       883
        
       

     

       884
       884
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

     
···

       957
       957
        
       		}

     

       958
       958
        
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       959
       959
        
       

     

       960
       960
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       960
       960
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       961
       961
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       962
       962
        
       		return

     

       963
       963
        
       	}

+3 -3

appview/issues/opengraph.go

···

       232
       232
        
       

     

       233
       233
        
       	// Get owner handle for avatar

     

       234
       234
        
       	var ownerHandle string

     

       235
       235
       -
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)

     

       235
       235
       +
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       236
       236
        
       	if err != nil {

     

       237
       237
       -
       		ownerHandle = f.Repo.Did

     

       237
       237
       +
       		ownerHandle = f.Did

     

       238
       238
        
       	} else {

     

       239
       239
        
       		ownerHandle = "@" + owner.Handle.String()

     

       240
       240
        
       	}

     

       241
       241
        
       

     

       242
       242
       -
       	card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)

     

       242
       242
       +
       	card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)

     

       243
       243
        
       	if err != nil {

     

       244
       244
        
       		log.Println("failed to draw issue summary card", err)

     

       245
       245
        
       		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

+1 -1

appview/middleware/middleware.go

···

       327
       327
        
       				return

     

       328
       328
        
       			}

     

       329
       329
        
       

     

       330
       330
       -
       			fullName := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       330
       330
       +
       			fullName := reporesolver.GetBaseRepoPath(r, f)

     

       331
       331
        
       

     

       332
       332
        
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       333
       333
        
       				if r.URL.Query().Get("go-get") == "1" {

+1 -1

appview/pulls/opengraph.go

···

       293
       293
        
       		filesChanged = niceDiff.Stat.FilesChanged

     

       294
       294
        
       	}

     

       295
       295
        
       

     

       296
       296
       -
       	card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)

     

       296
       296
       +
       	card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)

     

       297
       297
        
       	if err != nil {

     

       298
       298
        
       		log.Println("failed to draw pull summary card", err)

     

       299
       299
        
       		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

+18 -18

appview/pulls/pulls.go

···

       115
       115
        
       			return

     

       116
       116
        
       		}

     

       117
       117
        
       

     

       118
       118
       -
       		mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       119
       119
       -
       		branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       118
       118
       +
       		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       119
       119
       +
       		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       120
       120
        
       		resubmitResult := pages.Unknown

     

       121
       121
        
       		if user.Did == pull.OwnerDid {

     

       122
       122
       -
       			resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)

     

       122
       122
       +
       			resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       123
       123
        
       		}

     

       124
       124
        
       

     

       125
       125
        
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     
···

       155
       155
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       156
       156
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     

       157
       157
        
       

     

       158
       158
       -
       	mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       159
       159
       -
       	branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       158
       158
       +
       	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       159
       159
       +
       	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       160
       160
        
       	resubmitResult := pages.Unknown

     

       161
       161
        
       	if user != nil && user.Did == pull.OwnerDid {

     

       162
       162
       -
       		resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)

     

       162
       162
       +
       		resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       163
       163
        
       	}

     

       164
       164
        
       

     

       165
       165
        
       	m := make(map[string]models.Pipeline)

     
···

       205
       205
        
       

     

       206
       206
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       207
       207
        
       		s.db,

     

       208
       208
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       208
       208
       +
       		db.FilterIn("at_uri", f.Labels),

     

       209
       209
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       210
       210
        
       	)

     

       211
       211
        
       	if err != nil {

     
···

       651
       651
        
       

     

       652
       652
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       653
       653
        
       		s.db,

     

       654
       654
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       654
       654
       +
       		db.FilterIn("at_uri", f.Labels),

     

       655
       655
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       656
       656
        
       	)

     

       657
       657
        
       	if err != nil {

     
···

       787
       787
        
       		}

     

       788
       788
        
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       789
       789
        
       

     

       790
       790
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       790
       790
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       791
       791
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))

     

       792
       792
        
       		return

     

       793
       793
        
       	}

     
···

       940
       940
        
       				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")

     

       941
       941
        
       				return

     

       942
       942
        
       			}

     

       943
       943
       -
       			s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)

     

       943
       943
       +
       			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)

     

       944
       944
        
       		} else if isForkBased {

     

       945
       945
        
       			if !caps.PullRequests.ForkSubmissions {

     

       946
       946
        
       				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")

     

       947
       947
        
       				return

     

       948
       948
        
       			}

     

       949
       949
       -
       			s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       949
       949
       +
       			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       950
       950
        
       		} else if isPatchBased {

     

       951
       951
        
       			if !caps.PullRequests.PatchSubmissions {

     

       952
       952
        
       				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")

     

       953
       953
        
       				return

     

       954
       954
        
       			}

     

       955
       955
       -
       			s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)

     

       955
       955
       +
       			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)

     

       956
       956
        
       		}

     

       957
       957
        
       		return

     

       958
       958
        
       	}

     
···

       1619
       1619
        
       

     

       1620
       1620
        
       	patch := r.FormValue("patch")

     

       1621
       1621
        
       

     

       1622
       1622
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")

     

       1622
       1622
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")

     

       1623
       1623
        
       }

     

       1624
       1624
        
       

     

       1625
       1625
        
       func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {

     
···

       1684
       1684
        
       	patch := comparison.FormatPatchRaw

     

       1685
       1685
        
       	combined := comparison.CombinedPatchRaw

     

       1686
       1686
        
       

     

       1687
       1687
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       1687
       1687
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       1688
       1688
        
       }

     

       1689
       1689
        
       

     

       1690
       1690
        
       func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {

     
···

       1781
       1781
        
       	patch := comparison.FormatPatchRaw

     

       1782
       1782
        
       	combined := comparison.CombinedPatchRaw

     

       1783
       1783
        
       

     

       1784
       1784
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       1784
       1784
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       1785
       1785
        
       }

     

       1786
       1786
        
       

     

       1787
       1787
        
       func (s *Pulls) resubmitPullHelper(

     
···

       2210
       2210
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2211
       2211
        
       	}

     

       2212
       2212
        
       

     

       2213
       2213
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2213
       2213
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2214
       2214
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2215
       2215
        
       }

     

       2216
       2216
        
       

     
···

       2283
       2283
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2284
       2284
        
       	}

     

       2285
       2285
        
       

     

       2286
       2286
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2286
       2286
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2287
       2287
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2288
       2288
        
       }

     

       2289
       2289
        
       

     
···

       2357
       2357
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2358
       2358
        
       	}

     

       2359
       2359
        
       

     

       2360
       2360
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2360
       2360
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2361
       2361
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2362
       2362
        
       }

     

       2363
       2363

+2 -2

appview/repo/artifact.go

···

       38
       38
        
       		return

     

       39
       39
        
       	}

     

       40
       40
        
       

     

       41
       41
       -
       	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       41
       41
       +
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       42
       42
        
       	if err != nil {

     

       43
       43
        
       		log.Println("failed to resolve tag", err)

     

       44
       44
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

     
···

       146
       146
        
       	tagParam := chi.URLParam(r, "tag")

     

       147
       147
        
       	filename := chi.URLParam(r, "file")

     

       148
       148
        
       

     

       149
       149
       -
       	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       149
       149
       +
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       150
       150
        
       	if err != nil {

     

       151
       151
        
       		log.Println("failed to resolve tag", err)

     

       152
       152
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

+4 -4

appview/repo/blob.go

···

       54
       54
        
       	xrpcc := &indigoxrpc.Client{

     

       55
       55
        
       		Host: host,

     

       56
       56
        
       	}

     

       57
       57
       -
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)

     

       57
       57
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       58
       58
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       59
       59
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       60
       60
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     
···

       62
       62
        
       		return

     

       63
       63
        
       	}

     

       64
       64
        
       

     

       65
       65
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       65
       65
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       66
       66
        
       

     

       67
       67
        
       	// Use XRPC response directly instead of converting to internal types

     

       68
       68
        
       	var breadcrumbs [][]string

     
···

       74
       74
        
       	}

     

       75
       75
        
       

     

       76
       76
        
       	// Create the blob view

     

       77
       77
       -
       	blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())

     

       77
       77
       +
       	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       78
       78
        
       

     

       79
       79
        
       	user := rp.oauth.GetUser(r)

     

       80
       80
        
       

     
···

       107
       107
        
       	if !rp.config.Core.Dev {

     

       108
       108
        
       		scheme = "https"

     

       109
       109
        
       	}

     

       110
       110
       -
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)

     

       110
       110
       +
       	repo := f.DidSlashRepo()

     

       111
       111
        
       	baseURL := &url.URL{

     

       112
       112
        
       		Scheme: scheme,

     

       113
       113
        
       		Host:   f.Knot,

+1 -1

appview/repo/feed.go

···

       159
       159
        
       	}

     

       160
       160
        
       	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name

     

       161
       161
        
       

     

       162
       162
       -
       	feed, err := rp.getRepoFeed(r.Context(), &f.Repo, ownerSlashRepo)

     

       162
       162
       +
       	feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)

     

       163
       163
        
       	if err != nil {

     

       164
       164
        
       		log.Println("failed to get repo feed:", err)

     

       165
       165
        
       		rp.pages.Error500(w)

+3 -3

appview/repo/index.go

···

       53
       53
        
       	user := rp.oauth.GetUser(r)

     

       54
       54
        
       

     

       55
       55
        
       	// Build index response from multiple XRPC calls

     

       56
       56
       -
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)

     

       56
       56
       +
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     

       57
       57
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       58
       58
        
       		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       59
       59
        
       			l.Error("failed to call XRPC repo.index", "err", err)

     
···

       128
       128
        
       	}

     

       129
       129
        
       

     

       130
       130
        
       	// TODO: a bit dirty

     

       131
       131
       -
       	languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")

     

       131
       131
       +
       	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")

     

       132
       132
        
       	if err != nil {

     

       133
       133
        
       		l.Warn("failed to compute language percentages", "err", err)

     

       134
       134
        
       		// non-fatal

     
···

       138
       138
        
       	for _, c := range commitsTrunc {

     

       139
       139
        
       		shas = append(shas, c.Hash.String())

     

       140
       140
        
       	}

     

       141
       141
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)

     

       141
       141
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       142
       142
        
       	if err != nil {

     

       143
       143
        
       		l.Error("failed to fetch pipeline statuses", "err", err)

     

       144
       144
        
       		// non-fatal

+2 -2

appview/repo/log.go

···

       125
       125
        
       	for _, c := range xrpcResp.Commits {

     

       126
       126
        
       		shas = append(shas, c.Hash.String())

     

       127
       127
        
       	}

     

       128
       128
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)

     

       128
       128
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       129
       129
        
       	if err != nil {

     

       130
       130
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       131
       131
        
       		// non-fatal

     
···

       198
       198
        
       	}

     

       199
       199
        
       

     

       200
       200
        
       	user := rp.oauth.GetUser(r)

     

       201
       201
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})

     

       201
       201
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})

     

       202
       202
        
       	if err != nil {

     

       203
       203
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       204
       204
        
       		// non-fatal

+1 -1

appview/repo/opengraph.go

···

       374
       374
        
       		})

     

       375
       375
        
       	}

     

       376
       376
        
       

     

       377
       377
       -
       	card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)

     

       377
       377
       +
       	card, err := rp.drawRepoSummaryCard(f, languageStats)

     

       378
       378
        
       	if err != nil {

     

       379
       379
        
       		log.Println("failed to draw repo summary card", err)

     

       380
       380
        
       		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

+11 -11

appview/repo/repo.go

···

       118
       118
        
       		}

     

       119
       119
        
       	}

     

       120
       120
        
       

     

       121
       121
       -
       	newRepo := f.Repo

     

       121
       121
       +
       	newRepo := *f

     

       122
       122
        
       	newRepo.Spindle = newSpindle

     

       123
       123
        
       	record := newRepo.AsRecord()

     

       124
       124
        
       

     
···

       257
       257
        
       	l.Info("wrote label record to PDS")

     

       258
       258
        
       

     

       259
       259
        
       	// update the repo to subscribe to this label

     

       260
       260
       -
       	newRepo := f.Repo

     

       260
       260
       +
       	newRepo := *f

     

       261
       261
        
       	newRepo.Labels = append(newRepo.Labels, aturi)

     

       262
       262
        
       	repoRecord := newRepo.AsRecord()

     

       263
       263
        
       

     
···

       369
       369
        
       	}

     

       370
       370
        
       

     

       371
       371
        
       	// update repo record to remove the label reference

     

       372
       372
       -
       	newRepo := f.Repo

     

       372
       372
       +
       	newRepo := *f

     

       373
       373
        
       	var updated []string

     

       374
       374
        
       	removedAt := label.AtUri().String()

     

       375
       375
        
       	for _, l := range newRepo.Labels {

     
···

       462
       462
        
       		return

     

       463
       463
        
       	}

     

       464
       464
        
       

     

       465
       465
       -
       	newRepo := f.Repo

     

       465
       465
       +
       	newRepo := *f

     

       466
       466
        
       	newRepo.Labels = append(newRepo.Labels, labelAts...)

     

       467
       467
        
       

     

       468
       468
        
       	// dedup

     
···

       477
       477
        
       		return

     

       478
       478
        
       	}

     

       479
       479
        
       

     

       480
       480
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       480
       480
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       481
       481
        
       	if err != nil {

     

       482
       482
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       483
       483
        
       		return

     
···

       549
       549
        
       	}

     

       550
       550
        
       

     

       551
       551
        
       	// update repo record to remove the label reference

     

       552
       552
       -
       	newRepo := f.Repo

     

       552
       552
       +
       	newRepo := *f

     

       553
       553
        
       	var updated []string

     

       554
       554
        
       	for _, l := range newRepo.Labels {

     

       555
       555
        
       		if !slices.Contains(labelAts, l) {

     
···

       565
       565
        
       		return

     

       566
       566
        
       	}

     

       567
       567
        
       

     

       568
       568
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       568
       568
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       569
       569
        
       	if err != nil {

     

       570
       570
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       571
       571
        
       		return

     
···

       612
       612
        
       

     

       613
       613
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       614
       614
        
       		rp.db,

     

       615
       615
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       615
       615
       +
       		db.FilterIn("at_uri", f.Labels),

     

       616
       616
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       617
       617
        
       	)

     

       618
       618
        
       	if err != nil {

     
···

       660
       660
        
       

     

       661
       661
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       662
       662
        
       		rp.db,

     

       663
       663
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       663
       663
       +
       		db.FilterIn("at_uri", f.Labels),

     

       664
       664
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       665
       665
        
       	)

     

       666
       666
        
       	if err != nil {

     
···

       1057
       1057
        
       			uri = "http"

     

       1058
       1058
        
       		}

     

       1059
       1059
        
       

     

       1060
       1060
       -
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Repo.Name)

     

       1060
       1060
       +
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)

     

       1061
       1061
        
       		l = l.With("cloneUrl", forkSourceUrl)

     

       1062
       1062
        
       

     

       1063
       1063
        
       		sourceAt := f.RepoAt().String()

     
···

       1070
       1070
        
       			Knot:        targetKnot,

     

       1071
       1071
        
       			Rkey:        rkey,

     

       1072
       1072
        
       			Source:      sourceAt,

     

       1073
       1073
       -
       			Description: f.Repo.Description,

     

       1073
       1073
       +
       			Description: f.Description,

     

       1074
       1074
        
       			Created:     time.Now(),

     

       1075
       1075
        
       			Labels:      rp.config.Label.DefaultLabelDefs,

     

       1076
       1076
        
       		}

+4 -4

appview/repo/settings.go

···

       217
       217
        
       		return

     

       218
       218
        
       	}

     

       219
       219
        
       

     

       220
       220
       -
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       220
       220
       +
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Labels))

     

       221
       221
        
       	if err != nil {

     

       222
       222
        
       		l.Error("failed to fetch labels", "err", err)

     

       223
       223
        
       		rp.pages.Error503(w)

     
···

       238
       238
        
       	labels = labels[:n]

     

       239
       239
        
       

     

       240
       240
        
       	subscribedLabels := make(map[string]struct{})

     

       241
       241
       -
       	for _, l := range f.Repo.Labels {

     

       241
       241
       +
       	for _, l := range f.Labels {

     

       242
       242
        
       		subscribedLabels[l] = struct{}{}

     

       243
       243
        
       	}

     

       244
       244
        
       

     
···

       299
       299
        
       			collaborators = append(collaborators, c)

     

       300
       300
        
       		}

     

       301
       301
        
       		return collaborators, nil

     

       302
       302
       -
       	}(&f.Repo)

     

       302
       302
       +
       	}(f)

     

       303
       303
        
       	if err != nil {

     

       304
       304
        
       		l.Error("failed to get collaborators", "err", err)

     

       305
       305
        
       	}

     
···

       416
       416
        
       	}

     

       417
       417
        
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       418
       418
        
       

     

       419
       419
       -
       	newRepo := f.Repo

     

       419
       419
       +
       	newRepo := *f

     

       420
       420
        
       	newRepo.Description = description

     

       421
       421
        
       	newRepo.Website = website

     

       422
       422
        
       	newRepo.Topics = topics

+1 -1

appview/repo/tree.go

···

       80
       80
        
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       81
       81
        
       		result.Readme = xrpcResp.Readme.Contents

     

       82
       82
        
       	}

     

       83
       83
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       83
       83
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       84
       84
        
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
       85
        
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
       86
        
       	if len(result.Files) == 0 && result.Parent == treePath {

+3 -9

appview/reporesolver/resolver.go

···

       18
       18
        
       	"tangled.org/core/rbac"

     

       19
       19
        
       )

     

       20
       20
        
       

     

       21
       21
       -
       type ResolvedRepo struct {

     

       22
       22
       -
       	models.Repo

     

       23
       23
       -
       }

     

       24
       24
       -
       

     

       25
       21
        
       type RepoResolver struct {

     

       26
       22
        
       	config   *config.Config

     

       27
       23
        
       	enforcer *rbac.Enforcer

     
···

       45
       41
        
       }

     

       46
       42
        
       

     

       47
       43
        
       // TODO: move this out of `RepoResolver` struct

     

       48
       48
       -
       func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     

       44
       44
       +
       func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {

     

       49
       45
        
       	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       50
       46
        
       	if !ok {

     

       51
       47
        
       		log.Println("malformed middleware: `repo` not exist in context")

     

       52
       48
        
       		return nil, fmt.Errorf("malformed middleware")

     

       53
       49
        
       	}

     

       54
       50
        
       

     

       55
       55
       -
       	return &ResolvedRepo{

     

       56
       56
       -
       		Repo: *repo,

     

       57
       57
       -
       	}, nil

     

       51
       51
       +
       	return repo, nil

     

       58
       52
        
       }

     

       59
       53
        
       

     

       60
       54
        
       // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`

     

       61
       55
        
       // 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`

     

       62
       62
       -
       // 3. [ ] remove `ResolvedRepo`

     

       56
       56
       +
       // 3. [x] remove `ResolvedRepo`

     

       63
       57
        
       // 4. [ ] replace reporesolver to reposervice

     

       64
       58
        
       func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {

     

       65
       59
        
       	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)