lewis.moe
Monorepo for Tangled
appview: prefer `models.Repo` over `ResolvedRepo` internally
Signed-off-by: Seongmin Lee <git@boltless.me>
authored by
Seongmin Lee
and committed by
Tangled
b51677f7
3a7730c5
+47
-49
appview/pulls/pulls.go
+47
-49
appview/pulls/pulls.go
···
115
115
return
116
116
}
117
117
118
-
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
119
-
branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
118
+
mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
119
+
branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
120
120
resubmitResult := pages.Unknown
121
121
if user.Did == pull.OwnerDid {
122
-
resubmitResult = s.resubmitCheck(r, f, pull, stack)
122
+
resubmitResult = s.resubmitCheck(r, &f.Repo, 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
-
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
159
-
branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
158
+
mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
159
+
branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
160
160
resubmitResult := pages.Unknown
161
161
if user != nil && user.Did == pull.OwnerDid {
162
-
resubmitResult = s.resubmitCheck(r, f, pull, stack)
162
+
resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)
163
163
}
164
164
165
165
m := make(map[string]models.Pipeline)
···
238
238
})
239
239
}
240
240
241
-
func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {
241
+
func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {
242
242
if pull.State == models.PullMerged {
243
243
return types.MergeCheckResponse{}
244
244
}
···
305
305
return result
306
306
}
307
307
308
-
func (s *Pulls) branchDeleteStatus(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull) *models.BranchDeleteStatus {
308
+
func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {
309
309
if pull.State != models.PullMerged {
310
310
return nil
311
311
}
···
316
316
}
317
317
318
318
var branch string
319
-
var repo *models.Repo
320
319
// check if the branch exists
321
320
// NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates
322
321
if pull.IsBranchBased() {
323
322
branch = pull.PullSource.Branch
324
-
repo = &f.Repo
325
323
} else if pull.IsForkBased() {
326
324
branch = pull.PullSource.Branch
327
325
repo = pull.PullSource.Repo
···
360
358
}
361
359
}
362
360
363
-
func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {
361
+
func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {
364
362
if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {
365
363
return pages.Unknown
366
364
}
···
380
378
repoName = sourceRepo.Name
381
379
} else {
382
380
// pulls within the same repo
383
-
knot = f.Knot
384
-
ownerDid = f.Did
385
-
repoName = f.Name
381
+
knot = repo.Knot
382
+
ownerDid = repo.Did
383
+
repoName = repo.Name
386
384
}
387
385
388
386
scheme := "http"
···
394
392
Host: host,
395
393
}
396
394
397
-
repo := fmt.Sprintf("%s/%s", ownerDid, repoName)
398
-
branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo)
395
+
didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)
396
+
branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)
399
397
if err != nil {
400
398
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
401
399
log.Println("failed to call XRPC repo.branches", xrpcerr)
···
953
951
s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")
954
952
return
955
953
}
956
-
s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)
954
+
s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)
957
955
} else if isForkBased {
958
956
if !caps.PullRequests.ForkSubmissions {
959
957
s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")
960
958
return
961
959
}
962
-
s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
960
+
s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
963
961
} else if isPatchBased {
964
962
if !caps.PullRequests.PatchSubmissions {
965
963
s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")
966
964
return
967
965
}
968
-
s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)
966
+
s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)
969
967
}
970
968
return
971
969
}
···
974
972
func (s *Pulls) handleBranchBasedPull(
975
973
w http.ResponseWriter,
976
974
r *http.Request,
977
-
f *reporesolver.ResolvedRepo,
975
+
repo *models.Repo,
978
976
user *oauth.User,
979
977
title,
980
978
body,
···
986
984
if !s.config.Core.Dev {
987
985
scheme = "https"
988
986
}
989
-
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
987
+
host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
990
988
xrpcc := &indigoxrpc.Client{
991
989
Host: host,
992
990
}
993
991
994
-
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
995
-
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)
992
+
didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
993
+
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)
996
994
if err != nil {
997
995
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
998
996
log.Println("failed to call XRPC repo.compare", xrpcerr)
···
1029
1027
Sha: comparison.Rev2,
1030
1028
}
1031
1029
1032
-
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1030
+
s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1033
1031
}
1034
1032
1035
-
func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {
1033
+
func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {
1036
1034
if err := s.validator.ValidatePatch(&patch); err != nil {
1037
1035
s.logger.Error("patch validation failed", "err", err)
1038
1036
s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
1039
1037
return
1040
1038
}
1041
1039
1042
-
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
1040
+
s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
1043
1041
}
1044
1042
1045
-
func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
1043
+
func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
1046
1044
repoString := strings.SplitN(forkRepo, "/", 2)
1047
1045
forkOwnerDid := repoString[0]
1048
1046
repoName := repoString[1]
···
1144
1142
Sha: sourceRev,
1145
1143
}
1146
1144
1147
-
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1145
+
s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1148
1146
}
1149
1147
1150
1148
func (s *Pulls) createPullRequest(
1151
1149
w http.ResponseWriter,
1152
1150
r *http.Request,
1153
-
f *reporesolver.ResolvedRepo,
1151
+
repo *models.Repo,
1154
1152
user *oauth.User,
1155
1153
title, body, targetBranch string,
1156
1154
patch string,
···
1165
1163
s.createStackedPullRequest(
1166
1164
w,
1167
1165
r,
1168
-
f,
1166
+
repo,
1169
1167
user,
1170
1168
targetBranch,
1171
1169
patch,
···
1222
1220
Body: body,
1223
1221
TargetBranch: targetBranch,
1224
1222
OwnerDid: user.Did,
1225
-
RepoAt: f.RepoAt(),
1223
+
RepoAt: repo.RepoAt(),
1226
1224
Rkey: rkey,
1227
1225
Submissions: []*models.PullSubmission{
1228
1226
&initialSubmission,
···
1235
1233
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1236
1234
return
1237
1235
}
1238
-
pullId, err := db.NextPullId(tx, f.RepoAt())
1236
+
pullId, err := db.NextPullId(tx, repo.RepoAt())
1239
1237
if err != nil {
1240
1238
log.Println("failed to get pull id", err)
1241
1239
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
1250
1248
Val: &tangled.RepoPull{
1251
1249
Title: title,
1252
1250
Target: &tangled.RepoPull_Target{
1253
-
Repo: string(f.RepoAt()),
1251
+
Repo: string(repo.RepoAt()),
1254
1252
Branch: targetBranch,
1255
1253
},
1256
1254
Patch: patch,
···
1273
1271
1274
1272
s.notifier.NewPull(r.Context(), pull)
1275
1273
1276
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1274
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1277
1275
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))
1278
1276
}
1279
1277
1280
1278
func (s *Pulls) createStackedPullRequest(
1281
1279
w http.ResponseWriter,
1282
1280
r *http.Request,
1283
-
f *reporesolver.ResolvedRepo,
1281
+
repo *models.Repo,
1284
1282
user *oauth.User,
1285
1283
targetBranch string,
1286
1284
patch string,
···
1312
1310
1313
1311
// build a stack out of this patch
1314
1312
stackId := uuid.New()
1315
-
stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String())
1313
+
stack, err := newStack(repo, user, targetBranch, patch, pullSource, stackId.String())
1316
1314
if err != nil {
1317
1315
log.Println("failed to create stack", err)
1318
1316
s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))
···
1375
1373
return
1376
1374
}
1377
1375
1378
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1376
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1379
1377
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))
1380
1378
}
1381
1379
···
1647
1645
1648
1646
patch := r.FormValue("patch")
1649
1647
1650
-
s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")
1648
+
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")
1651
1649
}
1652
1650
1653
1651
func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
···
1712
1710
patch := comparison.FormatPatchRaw
1713
1711
combined := comparison.CombinedPatchRaw
1714
1712
1715
-
s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1713
+
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
1716
1714
}
1717
1715
1718
1716
func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
···
1809
1807
patch := comparison.FormatPatchRaw
1810
1808
combined := comparison.CombinedPatchRaw
1811
1809
1812
-
s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1810
+
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
1813
1811
}
1814
1812
1815
1813
func (s *Pulls) resubmitPullHelper(
1816
1814
w http.ResponseWriter,
1817
1815
r *http.Request,
1818
-
f *reporesolver.ResolvedRepo,
1816
+
repo *models.Repo,
1819
1817
user *oauth.User,
1820
1818
pull *models.Pull,
1821
1819
patch string,
···
1824
1822
) {
1825
1823
if pull.IsStacked() {
1826
1824
log.Println("resubmitting stacked PR")
1827
-
s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId)
1825
+
s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)
1828
1826
return
1829
1827
}
1830
1828
···
1904
1902
Val: &tangled.RepoPull{
1905
1903
Title: pull.Title,
1906
1904
Target: &tangled.RepoPull_Target{
1907
-
Repo: string(f.RepoAt()),
1905
+
Repo: string(repo.RepoAt()),
1908
1906
Branch: pull.TargetBranch,
1909
1907
},
1910
1908
Patch: patch, // new patch
···
1925
1923
return
1926
1924
}
1927
1925
1928
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1926
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1929
1927
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
1930
1928
}
1931
1929
1932
1930
func (s *Pulls) resubmitStackedPullHelper(
1933
1931
w http.ResponseWriter,
1934
1932
r *http.Request,
1935
-
f *reporesolver.ResolvedRepo,
1933
+
repo *models.Repo,
1936
1934
user *oauth.User,
1937
1935
pull *models.Pull,
1938
1936
patch string,
···
1941
1939
targetBranch := pull.TargetBranch
1942
1940
1943
1941
origStack, _ := r.Context().Value("stack").(models.Stack)
1944
-
newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)
1942
+
newStack, err := newStack(repo, user, targetBranch, patch, pull.PullSource, stackId)
1945
1943
if err != nil {
1946
1944
log.Println("failed to create resubmitted stack", err)
1947
1945
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
2119
2117
return
2120
2118
}
2121
2119
2122
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2120
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
2123
2121
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2124
2122
}
2125
2123
···
2389
2387
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2390
2388
}
2391
2389
2392
-
func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
2390
+
func newStack(repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
2393
2391
formatPatches, err := patchutil.ExtractPatches(patch)
2394
2392
if err != nil {
2395
2393
return nil, fmt.Errorf("Failed to extract patches: %v", err)
···
2424
2422
Body: body,
2425
2423
TargetBranch: targetBranch,
2426
2424
OwnerDid: user.Did,
2427
-
RepoAt: f.RepoAt(),
2425
+
RepoAt: repo.RepoAt(),
2428
2426
Rkey: rkey,
2429
2427
Submissions: []*models.PullSubmission{
2430
2428
&initialSubmission,
+3
-4
appview/repo/artifact.go
+3
-4
appview/repo/artifact.go
···
14
14
"tangled.org/core/appview/db"
15
15
"tangled.org/core/appview/models"
16
16
"tangled.org/core/appview/pages"
17
-
"tangled.org/core/appview/reporesolver"
18
17
"tangled.org/core/appview/xrpcclient"
19
18
"tangled.org/core/tid"
20
19
"tangled.org/core/types"
···
39
38
return
40
39
}
41
40
42
-
tag, err := rp.resolveTag(r.Context(), f, tagParam)
41
+
tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
43
42
if err != nil {
44
43
log.Println("failed to resolve tag", err)
45
44
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
···
147
146
tagParam := chi.URLParam(r, "tag")
148
147
filename := chi.URLParam(r, "file")
149
148
150
-
tag, err := rp.resolveTag(r.Context(), f, tagParam)
149
+
tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
151
150
if err != nil {
152
151
log.Println("failed to resolve tag", err)
153
152
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
···
297
296
w.Write([]byte{})
298
297
}
299
298
300
-
func (rp *Repo) resolveTag(ctx context.Context, f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) {
299
+
func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) {
301
300
tagParam, err := url.QueryUnescape(tagParam)
302
301
if err != nil {
303
302
return nil, err
+6
-6
appview/repo/blob.go
+6
-6
appview/repo/blob.go
···
74
74
}
75
75
76
76
// Create the blob view
77
-
blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())
77
+
blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())
78
78
79
79
user := rp.oauth.GetUser(r)
80
80
···
178
178
}
179
179
180
180
// NewBlobView creates a BlobView from the XRPC response
181
-
func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string, queryParams url.Values) models.BlobView {
181
+
func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, repo *models.Repo, ref, filePath string, queryParams url.Values) models.BlobView {
182
182
view := models.BlobView{
183
183
Contents: "",
184
184
Lines: 0,
···
200
200
201
201
// Determine if binary
202
202
if resp.IsBinary != nil && *resp.IsBinary {
203
-
view.ContentSrc = generateBlobURL(config, f, ref, filePath)
203
+
view.ContentSrc = generateBlobURL(config, repo, ref, filePath)
204
204
ext := strings.ToLower(filepath.Ext(resp.Path))
205
205
206
206
switch ext {
···
252
252
return view
253
253
}
254
254
255
-
func generateBlobURL(config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string) string {
255
+
func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string {
256
256
scheme := "http"
257
257
if !config.Core.Dev {
258
258
scheme = "https"
259
259
}
260
260
261
-
repoName := fmt.Sprintf("%s/%s", f.Did, f.Name)
261
+
repoName := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
262
262
baseURL := &url.URL{
263
263
Scheme: scheme,
264
-
Host: f.Knot,
264
+
Host: repo.Knot,
265
265
Path: "/xrpc/sh.tangled.repo.blob",
266
266
}
267
267
query := baseURL.Query()
+14
-15
appview/repo/index.go
+14
-15
appview/repo/index.go
···
22
22
"tangled.org/core/appview/db"
23
23
"tangled.org/core/appview/models"
24
24
"tangled.org/core/appview/pages"
25
-
"tangled.org/core/appview/reporesolver"
26
25
"tangled.org/core/appview/xrpcclient"
27
26
"tangled.org/core/types"
28
27
···
54
53
user := rp.oauth.GetUser(r)
55
54
56
55
// Build index response from multiple XRPC calls
57
-
result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
56
+
result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)
58
57
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
59
58
if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
60
59
l.Error("failed to call XRPC repo.index", "err", err)
···
129
128
}
130
129
131
130
// TODO: a bit dirty
132
-
languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
131
+
languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")
133
132
if err != nil {
134
133
l.Warn("failed to compute language percentages", "err", err)
135
134
// non-fatal
···
164
163
func (rp *Repo) getLanguageInfo(
165
164
ctx context.Context,
166
165
l *slog.Logger,
167
-
f *reporesolver.ResolvedRepo,
166
+
repo *models.Repo,
168
167
xrpcc *indigoxrpc.Client,
169
168
currentRef string,
170
169
isDefaultRef bool,
···
172
171
// first attempt to fetch from db
173
172
langs, err := db.GetRepoLanguages(
174
173
rp.db,
175
-
db.FilterEq("repo_at", f.RepoAt()),
174
+
db.FilterEq("repo_at", repo.RepoAt()),
176
175
db.FilterEq("ref", currentRef),
177
176
)
178
177
179
178
if err != nil || langs == nil {
180
179
// non-fatal, fetch langs from ks via XRPC
181
-
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
182
-
ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)
180
+
didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
181
+
ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)
183
182
if err != nil {
184
183
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
185
184
l.Error("failed to call XRPC repo.languages", "err", xrpcerr)
···
194
193
195
194
for _, lang := range ls.Languages {
196
195
langs = append(langs, models.RepoLanguage{
197
-
RepoAt: f.RepoAt(),
196
+
RepoAt: repo.RepoAt(),
198
197
Ref: currentRef,
199
198
IsDefaultRef: isDefaultRef,
200
199
Language: lang.Name,
···
209
208
defer tx.Rollback()
210
209
211
210
// update appview's cache
212
-
err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)
211
+
err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)
213
212
if err != nil {
214
213
// non-fatal
215
214
l.Error("failed to cache lang results", "err", err)
···
254
253
}
255
254
256
255
// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
257
-
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) {
258
-
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
256
+
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
257
+
didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
259
258
260
259
// first get branches to determine the ref if not specified
261
-
branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo)
260
+
branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)
262
261
if err != nil {
263
262
return nil, fmt.Errorf("failed to call repoBranches: %w", err)
264
263
}
···
302
301
wg.Add(1)
303
302
go func() {
304
303
defer wg.Done()
305
-
tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)
304
+
tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)
306
305
if err != nil {
307
306
errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
308
307
return
···
317
316
wg.Add(1)
318
317
go func() {
319
318
defer wg.Done()
320
-
resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo)
319
+
resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)
321
320
if err != nil {
322
321
errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
323
322
return
···
329
328
wg.Add(1)
330
329
go func() {
331
330
defer wg.Done()
332
-
logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo)
331
+
logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)
333
332
if err != nil {
334
333
errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
335
334
return