+2 -1

appview/db/db.go

··· 264 264 return err 265 265 }) 266 266 267 267 - runMigration(db, "add-source-info-to-pulls", func(tx *sql.Tx) error { 267 267 + runMigration(db, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error { 268 268 _, err := tx.Exec(` 269 269 alter table pulls add column source_branch text; 270 270 alter table pulls add column source_repo_at text; 271 271 + alter table pull_submissions add column source_rev text; 271 272 `) 272 273 return err 273 274 })

+15 -8

appview/db/pulls.go

··· 83 83 RoundNumber int 84 84 Patch string 85 85 Comments []PullComment 86 86 + SourceRev string // include the rev that was used to create this submission: only for branch PRs 86 87 87 88 // meta 88 89 Created time.Time ··· 222 223 } 223 224 224 225 _, err = tx.Exec(` 225 225 - insert into pull_submissions (pull_id, repo_at, round_number, patch) 226 226 - values (?, ?, ?, ?) 227 227 - `, pull.PullId, pull.RepoAt, 0, pull.Submissions[0].Patch) 226 226 + insert into pull_submissions (pull_id, repo_at, round_number, patch, source_rev) 227 227 + values (?, ?, ?, ?, ?) 228 228 + `, pull.PullId, pull.RepoAt, 0, pull.Submissions[0].Patch, pull.Submissions[0].SourceRev) 228 229 if err != nil { 229 230 return err 230 231 } ··· 395 396 396 397 submissionsQuery := ` 397 398 select 398 398 - id, pull_id, repo_at, round_number, patch, created 399 399 + id, pull_id, repo_at, round_number, patch, created, source_rev 399 400 from 400 401 pull_submissions 401 402 where ··· 412 413 for submissionsRows.Next() { 413 414 var submission PullSubmission 414 415 var submissionCreatedStr string 416 416 + var submissionSourceRev sql.NullString 415 417 err := submissionsRows.Scan( 416 418 &submission.ID, 417 419 &submission.PullId, ··· 419 421 &submission.RoundNumber, 420 422 &submission.Patch, 421 423 &submissionCreatedStr, 424 424 + &submissionSourceRev, 422 425 ) 423 426 if err != nil { 424 427 return nil, err ··· 430 433 } 431 434 submission.Created = submissionCreatedTime 432 435 436 436 + if submissionSourceRev.Valid { 437 437 + submission.SourceRev = submissionSourceRev.String 438 438 + } 439 439 + 433 440 submissionsMap[submission.ID] = &submission 434 441 } 435 442 if err = submissionsRows.Close(); err != nil { ··· 604 611 return err 605 612 } 606 613 607 607 - func ResubmitPull(e Execer, pull *Pull, newPatch string) error { 614 614 + func ResubmitPull(e Execer, pull *Pull, newPatch, sourceRev string) error { 608 615 newRoundNumber := len(pull.Submissions) 609 616 _, err := e.Exec(` 610 610 - insert into pull_submissions (pull_id, repo_at, round_number, patch) 611 611 - values (?, ?, ?, ?) 612 612 - `, pull.PullId, pull.RepoAt, newRoundNumber, newPatch) 617 617 + insert into pull_submissions (pull_id, repo_at, round_number, patch, source_rev) 618 618 + values (?, ?, ?, ?, ?) 619 619 + `, pull.PullId, pull.RepoAt, newRoundNumber, newPatch, sourceRev) 613 620 614 621 return err 615 622 }

+31 -11

appview/pages/pages.go

··· 586 586 return p.executeRepo("repo/pulls/pulls", w, params) 587 587 } 588 588 589 589 + type ResubmitResult uint64 590 590 + 591 591 + const ( 592 592 + ShouldResubmit ResubmitResult = iota 593 593 + ShouldNotResubmit 594 594 + Unknown 595 595 + ) 596 596 + 597 597 + func (r ResubmitResult) Yes() bool { 598 598 + return r == ShouldResubmit 599 599 + } 600 600 + func (r ResubmitResult) No() bool { 601 601 + return r == ShouldNotResubmit 602 602 + } 603 603 + func (r ResubmitResult) Unknown() bool { 604 604 + return r == Unknown 605 605 + } 606 606 + 589 607 type RepoSinglePullParams struct { 590 590 - LoggedInUser *auth.User 591 591 - RepoInfo RepoInfo 592 592 - Active string 593 593 - DidHandleMap map[string]string 594 594 - Pull *db.Pull 595 595 - MergeCheck types.MergeCheckResponse 608 608 + LoggedInUser *auth.User 609 609 + RepoInfo RepoInfo 610 610 + Active string 611 611 + DidHandleMap map[string]string 612 612 + Pull *db.Pull 613 613 + MergeCheck types.MergeCheckResponse 614 614 + ResubmitCheck ResubmitResult 596 615 } 597 616 598 617 func (p *Pages) RepoSinglePull(w io.Writer, params RepoSinglePullParams) error { ··· 627 646 } 628 647 629 648 type PullActionsParams struct { 630 630 - LoggedInUser *auth.User 631 631 - RepoInfo RepoInfo 632 632 - Pull *db.Pull 633 633 - RoundNumber int 634 634 - MergeCheck types.MergeCheckResponse 649 649 + LoggedInUser *auth.User 650 650 + RepoInfo RepoInfo 651 651 + Pull *db.Pull 652 652 + RoundNumber int 653 653 + MergeCheck types.MergeCheckResponse 654 654 + ResubmitCheck ResubmitResult 635 655 } 636 656 637 657 func (p *Pages) PullActionsFragment(w io.Writer, params PullActionsParams) error {

+13 -1

appview/pages/templates/fragments/pullActions.html

··· 10 10 {{ $isPullAuthor := and .LoggedInUser (eq .LoggedInUser.Did .Pull.OwnerDid) }} 11 11 {{ $isLastRound := eq $roundNumber $lastIdx }} 12 12 {{ $isSameRepoBranch := .Pull.IsSameRepoBranch }} 13 13 + {{ $isUpToDate := .ResubmitCheck.No }} 13 14 <div class="relative w-fit"> 14 15 <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 15 16 <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2"> ··· 37 38 {{ end }} 38 39 39 40 {{ if and $isPullAuthor $isOpen $isLastRound }} 41 41 + {{ $disabled := "" }} 42 42 + {{ if $isUpToDate }} 43 43 + {{ $disabled = "disabled" }} 44 44 + {{ end }} 40 45 <button id="resubmitBtn" 41 46 {{ if $isSameRepoBranch }} 42 47 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit" ··· 47 52 {{ end }} 48 53 49 54 hx-disabled-elt="#resubmitBtn" 50 50 - class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed"> 55 55 + class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed" {{ $disabled }} 56 56 + 57 57 + {{ if $disabled }} 58 58 + title="Update this branch to resubmit this pull request" 59 59 + {{ else }} 60 60 + title="Resubmit this pull request" 61 61 + {{ end }} 62 62 + > 51 63 {{ i "rotate-ccw" "w-4 h-4" }} 52 64 <span>resubmit</span> 53 65 </button>

+14 -1

appview/pages/templates/repo/pulls/pull.html

··· 135 135 136 136 {{ if eq $lastIdx .RoundNumber }} 137 137 {{ block "mergeStatus" $ }} {{ end }} 138 138 + {{ block "resubmitStatus" $ }} {{ end }} 138 139 {{ end }} 139 140 140 141 {{ if $.LoggedInUser }} 141 141 - {{ template "fragments/pullActions" (dict "LoggedInUser" $.LoggedInUser "Pull" $.Pull "RepoInfo" $.RepoInfo "RoundNumber" .RoundNumber "MergeCheck" $.MergeCheck) }} 142 142 + {{ template "fragments/pullActions" (dict "LoggedInUser" $.LoggedInUser "Pull" $.Pull "RepoInfo" $.RepoInfo "RoundNumber" .RoundNumber "MergeCheck" $.MergeCheck "ResubmitCheck" $.ResubmitCheck) }} 142 143 {{ else }} 143 144 <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm px-6 py-4 w-fit dark:text-white"> 144 145 <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> ··· 209 210 </div> 210 211 {{ end }} 211 212 {{ end }} 213 213 + 214 214 + {{ define "resubmitStatus" }} 215 215 + {{ if .ResubmitCheck.Yes }} 216 216 + <div class="bg-amber-50 dark:bg-amber-900 border border-amber-500 rounded drop-shadow-sm px-6 py-2 relative w-fit"> 217 217 + <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 218 218 + <div class="flex items-center gap-2 text-amber-500 dark:text-amber-300"> 219 219 + {{ i "triangle-alert" "w-4 h-4" }} 220 220 + <span class="font-medium">this branch has been updated, consider resubmitting</span> 221 221 + </div> 222 222 + </div> 223 223 + {{ end }} 224 224 + {{ end }}

+91 -28

appview/state/pull.go

··· 50 50 } 51 51 52 52 mergeCheckResponse := s.mergeCheck(f, pull) 53 53 + var resubmitResult pages.ResubmitResult 54 54 + if user.Did == pull.OwnerDid { 55 55 + resubmitResult = s.resubmitCheck(f, pull) 56 56 + } 53 57 54 58 s.pages.PullActionsFragment(w, pages.PullActionsParams{ 55 55 - LoggedInUser: user, 56 56 - RepoInfo: f.RepoInfo(s, user), 57 57 - Pull: pull, 58 58 - RoundNumber: roundNumber, 59 59 - MergeCheck: mergeCheckResponse, 59 59 + LoggedInUser: user, 60 60 + RepoInfo: f.RepoInfo(s, user), 61 61 + Pull: pull, 62 62 + RoundNumber: roundNumber, 63 63 + MergeCheck: mergeCheckResponse, 64 64 + ResubmitCheck: resubmitResult, 60 65 }) 61 66 return 62 67 } ··· 105 110 } 106 111 107 112 mergeCheckResponse := s.mergeCheck(f, pull) 113 113 + var resubmitResult pages.ResubmitResult 114 114 + if user.Did == pull.OwnerDid { 115 115 + resubmitResult = s.resubmitCheck(f, pull) 116 116 + } 108 117 109 118 s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{ 110 110 - LoggedInUser: user, 111 111 - RepoInfo: f.RepoInfo(s, user), 112 112 - DidHandleMap: didHandleMap, 113 113 - Pull: pull, 114 114 - MergeCheck: mergeCheckResponse, 119 119 + LoggedInUser: user, 120 120 + RepoInfo: f.RepoInfo(s, user), 121 121 + DidHandleMap: didHandleMap, 122 122 + Pull: pull, 123 123 + MergeCheck: mergeCheckResponse, 124 124 + ResubmitCheck: resubmitResult, 115 125 }) 116 126 } 117 127 ··· 175 185 return mergeCheckResponse 176 186 } 177 187 188 188 + func (s *State) resubmitCheck(f *FullyResolvedRepo, pull *db.Pull) pages.ResubmitResult { 189 189 + if pull.State == db.PullMerged { 190 190 + return pages.Unknown 191 191 + } 192 192 + 193 193 + if pull.PullSource == nil { 194 194 + return pages.Unknown 195 195 + } 196 196 + 197 197 + us, err := NewUnsignedClient(f.Knot, s.config.Dev) 198 198 + if err != nil { 199 199 + log.Printf("failed to setup signed client for %s; ignoring: %v", f.Knot, err) 200 200 + return pages.Unknown 201 201 + } 202 202 + 203 203 + resp, err := us.Branch(f.OwnerDid(), f.RepoName, pull.PullSource.Branch) 204 204 + if err != nil { 205 205 + log.Println("failed to reach knotserver", err) 206 206 + return pages.Unknown 207 207 + } 208 208 + 209 209 + body, err := io.ReadAll(resp.Body) 210 210 + if err != nil { 211 211 + log.Printf("Error reading response body: %v", err) 212 212 + return pages.Unknown 213 213 + } 214 214 + 215 215 + var result types.RepoBranchResponse 216 216 + err = json.Unmarshal(body, &result) 217 217 + if err != nil { 218 218 + log.Println("failed to parse response:", err) 219 219 + return pages.Unknown 220 220 + } 221 221 + 222 222 + if pull.Submissions[pull.LastRoundNumber()].SourceRev != result.Branch.Hash { 223 223 + log.Println(pull.Submissions[pull.LastRoundNumber()].SourceRev, result.Branch.Hash) 224 224 + return pages.ShouldResubmit 225 225 + } else { 226 226 + return pages.ShouldNotResubmit 227 227 + } 228 228 + } 229 229 + 178 230 func (s *State) RepoPullPatch(w http.ResponseWriter, r *http.Request) { 179 231 user := s.auth.GetUser(r) 180 232 f, err := fullyResolvedRepo(r) ··· 457 509 sourceBranch := r.FormValue("sourceBranch") 458 510 patch := r.FormValue("patch") 459 511 460 460 - if patch == "" { 461 461 - if isPushAllowed && sourceBranch == "" { 462 462 - s.pages.Notice(w, "pull", "Neither source branch nor patch supplied.") 463 463 - return 464 464 - } 465 465 - s.pages.Notice(w, "pull", "Patch is empty.") 512 512 + isBranchBased := isPushAllowed && (sourceBranch != "") 513 513 + isPatchBased := patch != "" 514 514 + 515 515 + if !isBranchBased && !isPatchBased { 516 516 + s.pages.Notice(w, "pull", "Neither source branch nor patch supplied.") 466 517 return 467 518 } 468 519 469 469 - if patch != "" && sourceBranch != "" { 520 520 + if isBranchBased && isPatchBased { 470 521 s.pages.Notice(w, "pull", "Cannot select both patch and source branch.") 471 522 return 472 523 } ··· 477 528 } 478 529 479 530 // TODO: check if knot has this capability 531 531 + var sourceRev string 480 532 var pullSource *db.PullSource 481 481 - if sourceBranch != "" && isPushAllowed { 533 533 + var recordPullSource *tangled.RepoPull_Source 534 534 + if isBranchBased { 482 535 pullSource = &db.PullSource{ 483 536 Branch: sourceBranch, 484 537 } 538 538 + recordPullSource = &tangled.RepoPull_Source{ 539 539 + Branch: sourceBranch, 540 540 + } 485 541 // generate a patch using /compare 486 542 ksClient, err := NewUnsignedClient(f.Knot, s.config.Dev) 487 543 if err != nil { ··· 489 545 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 490 546 return 491 547 } 492 492 - 493 493 - log.Println(targetBranch, sourceBranch) 494 548 495 549 resp, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch) 496 550 switch resp.StatusCode { ··· 510 564 err = json.Unmarshal(respBody, &diffTreeResponse) 511 565 if err != nil { 512 566 log.Println("failed to unmarshal diff tree response", err) 513 513 - log.Println(string(respBody)) 514 567 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 515 568 } 516 569 570 570 + sourceRev = diffTreeResponse.DiffTree.Rev2 517 571 patch = diffTreeResponse.DiffTree.Patch 518 572 } 519 573 520 520 - log.Println(patch) 521 521 - 522 574 // Validate patch format 523 575 if !isPatchValid(patch) { 524 576 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") ··· 535 587 536 588 rkey := s.TID() 537 589 initialSubmission := db.PullSubmission{ 538 538 - Patch: patch, 590 590 + Patch: patch, 591 591 + SourceRev: sourceRev, 539 592 } 540 593 err = db.NewPull(tx, &db.Pull{ 541 594 Title: title, ··· 573 626 TargetRepo: string(f.RepoAt), 574 627 TargetBranch: targetBranch, 575 628 Patch: patch, 629 629 + Source: recordPullSource, 576 630 }, 577 631 }, 578 632 }) ··· 613 667 return 614 668 case http.MethodPost: 615 669 patch := r.FormValue("patch") 670 670 + var sourceRev string 671 671 + var recordPullSource *tangled.RepoPull_Source 616 672 617 673 // this pull is a branch based pull 618 674 isPushAllowed := f.RepoInfo(s, user).Roles.IsPushAllowed() 619 675 if pull.IsSameRepoBranch() && isPushAllowed { 620 676 sourceBranch := pull.PullSource.Branch 621 677 targetBranch := pull.TargetBranch 678 678 + recordPullSource = &tangled.RepoPull_Source{ 679 679 + Branch: sourceBranch, 680 680 + } 622 681 // extract patch by performing compare 623 682 ksClient, err := NewUnsignedClient(f.Knot, s.config.Dev) 624 683 if err != nil { ··· 627 686 return 628 687 } 629 688 630 630 - log.Println(targetBranch, sourceBranch) 631 631 - 632 689 resp, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch) 633 690 switch resp.StatusCode { 634 691 case 404: ··· 647 704 err = json.Unmarshal(respBody, &diffTreeResponse) 648 705 if err != nil { 649 706 log.Println("failed to unmarshal diff tree response", err) 650 650 - log.Println(string(respBody)) 651 707 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 652 708 } 653 709 710 710 + sourceRev = diffTreeResponse.DiffTree.Rev2 654 711 patch = diffTreeResponse.DiffTree.Patch 655 712 } 656 713 ··· 664 721 return 665 722 } 666 723 724 724 + if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev { 725 725 + s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.") 726 726 + return 727 727 + } 728 728 + 667 729 // Validate patch format 668 730 if !isPatchValid(patch) { 669 731 s.pages.Notice(w, "resubmit-error", "Invalid patch format. Please provide a valid diff.") ··· 678 740 } 679 741 defer tx.Rollback() 680 742 681 681 - err = db.ResubmitPull(tx, pull, patch) 743 743 + err = db.ResubmitPull(tx, pull, patch, sourceRev) 682 744 if err != nil { 683 745 log.Println("failed to create pull request", err) 684 746 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") ··· 705 767 TargetRepo: string(f.RepoAt), 706 768 TargetBranch: pull.TargetBranch, 707 769 Patch: patch, // new patch 770 770 + Source: recordPullSource, 708 771 }, 709 772 }, 710 773 })

+15

appview/state/signer.go

··· 287 287 return us.client.Do(req) 288 288 } 289 289 290 290 + func (us *UnsignedClient) Branch(ownerDid, repoName, branch string) (*http.Response, error) { 291 291 + const ( 292 292 + Method = "GET" 293 293 + ) 294 294 + 295 295 + endpoint := fmt.Sprintf("/%s/%s/branches/%s", ownerDid, repoName, branch) 296 296 + 297 297 + req, err := us.newRequest(Method, endpoint, nil) 298 298 + if err != nil { 299 299 + return nil, err 300 300 + } 301 301 + 302 302 + return us.client.Do(req) 303 303 + } 304 304 + 290 305 func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*http.Response, error) { 291 306 const ( 292 307 Method = "GET"

-2

knotserver/git/diff.go

··· 97 97 return nil, fmt.Errorf("Invalid revision: %s", rev2) 98 98 } 99 99 100 100 - log.Println(commit1, commit2) 101 101 - 102 100 tree1, err := commit1.Tree() 103 101 if err != nil { 104 102 return nil, err

+13

knotserver/git/git.go

··· 238 238 return branches, nil 239 239 } 240 240 241 241 + func (g *GitRepo) Branch(name string) (*plumbing.Reference, error) { 242 242 + ref, err := g.r.Reference(plumbing.NewBranchReferenceName(name), false) 243 243 + if err != nil { 244 244 + return nil, fmt.Errorf("branch: %w", err) 245 245 + } 246 246 + 247 247 + if !ref.Name().IsBranch() { 248 248 + return nil, fmt.Errorf("branch: %s is not a branch", ref.Name()) 249 249 + } 250 250 + 251 251 + return ref, nil 252 252 + } 253 253 + 241 254 func (g *GitRepo) SetDefaultBranch(branch string) error { 242 255 ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(branch)) 243 256 return g.r.Storer.SetReference(ref)

+1

knotserver/handler.go

··· 106 106 r.Get("/tags", h.Tags) 107 107 r.Route("/branches", func(r chi.Router) { 108 108 r.Get("/", h.Branches) 109 109 + r.Get("/{branch}", h.Branch) 109 110 r.Route("/default", func(r chi.Router) { 110 111 r.Get("/", h.DefaultBranch) 111 112 r.With(h.VerifySignature).Put("/", h.SetDefaultBranch)

+31

knotserver/routes.go

··· 456 456 return 457 457 } 458 458 459 459 + func (h *Handle) Branch(w http.ResponseWriter, r *http.Request) { 460 460 + path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 461 461 + branchName := chi.URLParam(r, "branch") 462 462 + l := h.l.With("handler", "Branch") 463 463 + 464 464 + gr, err := git.PlainOpen(path) 465 465 + if err != nil { 466 466 + notFound(w) 467 467 + return 468 468 + } 469 469 + 470 470 + ref, err := gr.Branch(branchName) 471 471 + if err != nil { 472 472 + l.Error("getting branches", "error", err.Error()) 473 473 + writeError(w, err.Error(), http.StatusInternalServerError) 474 474 + return 475 475 + } 476 476 + 477 477 + resp := types.RepoBranchResponse{ 478 478 + Branch: types.Branch{ 479 479 + Reference: types.Reference{ 480 480 + Name: ref.Name().Short(), 481 481 + Hash: ref.Hash().String(), 482 482 + }, 483 483 + }, 484 484 + } 485 485 + 486 486 + writeJSON(w, resp) 487 487 + return 488 488 + } 489 489 + 459 490 func (h *Handle) Keys(w http.ResponseWriter, r *http.Request) { 460 491 l := h.l.With("handler", "Keys") 461 492

+4

types/repo.go

··· 67 67 Branches []Branch `json:"branches,omitempty"` 68 68 } 69 69 70 70 + type RepoBranchResponse struct { 71 71 + Branch Branch `json:"branch,omitempty"` 72 72 + } 73 73 + 70 74 type RepoDefaultBranchResponse struct { 71 75 Branch string `json:"branch,omitempty"` 72 76 }