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