+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)