appview/models: move db.Pull* into models

+7 -7

appview/db/profile.go

··· 75 75 } 76 76 77 77 type PullEvents struct { 78 - Items []*Pull 78 + Items []*models.Pull 79 79 } 80 80 81 81 func (p PullEvents) Stats() PullEventStats { 82 82 var open, merged, closed int 83 83 for _, pull := range p.Items { 84 84 switch pull.State { 85 - case PullOpen: 85 + case models.PullOpen: 86 86 open += 1 87 - case PullMerged: 87 + case models.PullMerged: 88 88 merged += 1 89 - case PullClosed: 89 + case models.PullClosed: 90 90 closed += 1 91 91 } 92 92 } ··· 546 546 switch stat { 547 547 case VanityStatMergedPRCount: 548 548 query = `select count(id) from pulls where owner_did = ? and state = ?` 549 - args = append(args, did, PullMerged) 549 + args = append(args, did, models.PullMerged) 550 550 case VanityStatClosedPRCount: 551 551 query = `select count(id) from pulls where owner_did = ? and state = ?` 552 - args = append(args, did, PullClosed) 552 + args = append(args, did, models.PullClosed) 553 553 case VanityStatOpenPRCount: 554 554 query = `select count(id) from pulls where owner_did = ? and state = ?` 555 - args = append(args, did, PullOpen) 555 + args = append(args, did, models.PullOpen) 556 556 case VanityStatOpenIssueCount: 557 557 query = `select count(id) from issues where did = ? and open = 1` 558 558 args = append(args, did)

+42 -342

appview/db/pulls.go

··· 4 4 "database/sql" 5 5 "fmt" 6 6 "log" 7 - "slices" 8 7 "sort" 9 8 "strings" 10 9 "time" 11 10 12 11 "github.com/bluesky-social/indigo/atproto/syntax" 13 - "tangled.org/core/api/tangled" 14 12 "tangled.org/core/appview/models" 15 - "tangled.org/core/patchutil" 16 - "tangled.org/core/types" 17 13 ) 18 14 19 - type PullState int 20 - 21 - const ( 22 - PullClosed PullState = iota 23 - PullOpen 24 - PullMerged 25 - PullDeleted 26 - ) 27 - 28 - func (p PullState) String() string { 29 - switch p { 30 - case PullOpen: 31 - return "open" 32 - case PullMerged: 33 - return "merged" 34 - case PullClosed: 35 - return "closed" 36 - case PullDeleted: 37 - return "deleted" 38 - default: 39 - return "closed" 40 - } 41 - } 42 - 43 - func (p PullState) IsOpen() bool { 44 - return p == PullOpen 45 - } 46 - func (p PullState) IsMerged() bool { 47 - return p == PullMerged 48 - } 49 - func (p PullState) IsClosed() bool { 50 - return p == PullClosed 51 - } 52 - func (p PullState) IsDeleted() bool { 53 - return p == PullDeleted 54 - } 55 - 56 - type Pull struct { 57 - // ids 58 - ID int 59 - PullId int 60 - 61 - // at ids 62 - RepoAt syntax.ATURI 63 - OwnerDid string 64 - Rkey string 65 - 66 - // content 67 - Title string 68 - Body string 69 - TargetBranch string 70 - State PullState 71 - Submissions []*PullSubmission 72 - 73 - // stacking 74 - StackId string // nullable string 75 - ChangeId string // nullable string 76 - ParentChangeId string // nullable string 77 - 78 - // meta 79 - Created time.Time 80 - PullSource *PullSource 81 - 82 - // optionally, populate this when querying for reverse mappings 83 - Repo *models.Repo 84 - } 85 - 86 - func (p Pull) AsRecord() tangled.RepoPull { 87 - var source *tangled.RepoPull_Source 88 - if p.PullSource != nil { 89 - s := p.PullSource.AsRecord() 90 - source = &s 91 - source.Sha = p.LatestSha() 92 - } 93 - 94 - record := tangled.RepoPull{ 95 - Title: p.Title, 96 - Body: &p.Body, 97 - CreatedAt: p.Created.Format(time.RFC3339), 98 - Target: &tangled.RepoPull_Target{ 99 - Repo: p.RepoAt.String(), 100 - Branch: p.TargetBranch, 101 - }, 102 - Patch: p.LatestPatch(), 103 - Source: source, 104 - } 105 - return record 106 - } 107 - 108 - type PullSource struct { 109 - Branch string 110 - RepoAt *syntax.ATURI 111 - 112 - // optionally populate this for reverse mappings 113 - Repo *models.Repo 114 - } 115 - 116 - func (p PullSource) AsRecord() tangled.RepoPull_Source { 117 - var repoAt *string 118 - if p.RepoAt != nil { 119 - s := p.RepoAt.String() 120 - repoAt = &s 121 - } 122 - record := tangled.RepoPull_Source{ 123 - Branch: p.Branch, 124 - Repo: repoAt, 125 - } 126 - return record 127 - } 128 - 129 - type PullSubmission struct { 130 - // ids 131 - ID int 132 - PullId int 133 - 134 - // at ids 135 - RepoAt syntax.ATURI 136 - 137 - // content 138 - RoundNumber int 139 - Patch string 140 - Comments []PullComment 141 - SourceRev string // include the rev that was used to create this submission: only for branch/fork PRs 142 - 143 - // meta 144 - Created time.Time 145 - } 146 - 147 - type PullComment struct { 148 - // ids 149 - ID int 150 - PullId int 151 - SubmissionId int 152 - 153 - // at ids 154 - RepoAt string 155 - OwnerDid string 156 - CommentAt string 157 - 158 - // content 159 - Body string 160 - 161 - // meta 162 - Created time.Time 163 - } 164 - 165 - func (p *Pull) LatestPatch() string { 166 - latestSubmission := p.Submissions[p.LastRoundNumber()] 167 - return latestSubmission.Patch 168 - } 169 - 170 - func (p *Pull) LatestSha() string { 171 - latestSubmission := p.Submissions[p.LastRoundNumber()] 172 - return latestSubmission.SourceRev 173 - } 174 - 175 - func (p *Pull) PullAt() syntax.ATURI { 176 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey)) 177 - } 178 - 179 - func (p *Pull) LastRoundNumber() int { 180 - return len(p.Submissions) - 1 181 - } 182 - 183 - func (p *Pull) IsPatchBased() bool { 184 - return p.PullSource == nil 185 - } 186 - 187 - func (p *Pull) IsBranchBased() bool { 188 - if p.PullSource != nil { 189 - if p.PullSource.RepoAt != nil { 190 - return p.PullSource.RepoAt == &p.RepoAt 191 - } else { 192 - // no repo specified 193 - return true 194 - } 195 - } 196 - return false 197 - } 198 - 199 - func (p *Pull) IsForkBased() bool { 200 - if p.PullSource != nil { 201 - if p.PullSource.RepoAt != nil { 202 - // make sure repos are different 203 - return p.PullSource.RepoAt != &p.RepoAt 204 - } 205 - } 206 - return false 207 - } 208 - 209 - func (p *Pull) IsStacked() bool { 210 - return p.StackId != "" 211 - } 212 - 213 - func (s PullSubmission) IsFormatPatch() bool { 214 - return patchutil.IsFormatPatch(s.Patch) 215 - } 216 - 217 - func (s PullSubmission) AsFormatPatch() []types.FormatPatch { 218 - patches, err := patchutil.ExtractPatches(s.Patch) 219 - if err != nil { 220 - log.Println("error extracting patches from submission:", err) 221 - return []types.FormatPatch{} 222 - } 223 - 224 - return patches 225 - } 226 - 227 - func NewPull(tx *sql.Tx, pull *Pull) error { 15 + func NewPull(tx *sql.Tx, pull *models.Pull) error { 228 16 _, err := tx.Exec(` 229 17 insert or ignore into repo_pull_seqs (repo_at, next_pull_id) 230 18 values (?, 1) ··· 33 245 } 34 246 35 247 pull.PullId = nextId 36 - pull.State = PullOpen 248 + pull.State = models.PullOpen 37 249 38 250 var sourceBranch, sourceRepoAt *string 39 251 if pull.PullSource != nil { ··· 100 312 return pullId - 1, err 101 313 } 102 314 103 - func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*Pull, error) { 104 - pulls := make(map[int]*Pull) 315 + func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*models.Pull, error) { 316 + pulls := make(map[int]*models.Pull) 105 317 106 318 var conditions []string 107 319 var args []any ··· 150 362 defer rows.Close() 151 363 152 364 for rows.Next() { 153 - var pull Pull 365 + var pull models.Pull 154 366 var createdAt string 155 367 var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString 156 368 err := rows.Scan( ··· 180 392 pull.Created = createdTime 181 393 182 394 if sourceBranch.Valid { 183 - pull.PullSource = &PullSource{ 395 + pull.PullSource = &models.PullSource{ 184 396 Branch: sourceBranch.String, 185 397 } 186 398 if sourceRepoAt.Valid { ··· 233 445 defer submissionsRows.Close() 234 446 235 447 for submissionsRows.Next() { 236 - var s PullSubmission 448 + var s models.PullSubmission 237 449 var sourceRev sql.NullString 238 450 var createdAt string 239 451 err := submissionsRows.Scan( ··· 259 471 } 260 472 261 473 if p, ok := pulls[s.PullId]; ok { 262 - p.Submissions = make([]*PullSubmission, s.RoundNumber+1) 474 + p.Submissions = make([]*models.PullSubmission, s.RoundNumber+1) 263 475 p.Submissions[s.RoundNumber] = &s 264 476 } 265 477 } ··· 300 512 return nil, err 301 513 } 302 514 if p, ok := pulls[pullId]; ok { 303 - p.Submissions[p.LastRoundNumber()].Comments = make([]PullComment, commentCount) 515 + p.Submissions[p.LastRoundNumber()].Comments = make([]models.PullComment, commentCount) 304 516 } 305 517 } 306 518 if err := rows.Err(); err != nil { 307 519 return nil, err 308 520 } 309 521 310 - orderedByPullId := []*Pull{} 522 + orderedByPullId := []*models.Pull{} 311 523 for _, p := range pulls { 312 524 orderedByPullId = append(orderedByPullId, p) 313 525 } ··· 318 530 return orderedByPullId, nil 319 531 } 320 532 321 - func GetPulls(e Execer, filters ...filter) ([]*Pull, error) { 533 + func GetPulls(e Execer, filters ...filter) ([]*models.Pull, error) { 322 534 return GetPullsWithLimit(e, 0, filters...) 323 535 } 324 536 325 - func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*Pull, error) { 537 + func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*models.Pull, error) { 326 538 query := ` 327 539 select 328 540 owner_did, ··· 346 558 ` 347 559 row := e.QueryRow(query, repoAt, pullId) 348 560 349 - var pull Pull 561 + var pull models.Pull 350 562 var createdAt string 351 563 var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString 352 564 err := row.Scan( ··· 377 589 378 590 // populate source 379 591 if sourceBranch.Valid { 380 - pull.PullSource = &PullSource{ 592 + pull.PullSource = &models.PullSource{ 381 593 Branch: sourceBranch.String, 382 594 } 383 595 if sourceRepoAt.Valid { ··· 413 625 } 414 626 defer submissionsRows.Close() 415 627 416 - submissionsMap := make(map[int]*PullSubmission) 628 + submissionsMap := make(map[int]*models.PullSubmission) 417 629 418 630 for submissionsRows.Next() { 419 - var submission PullSubmission 631 + var submission models.PullSubmission 420 632 var submissionCreatedStr string 421 633 var submissionSourceRev sql.NullString 422 634 err := submissionsRows.Scan( ··· 480 692 defer commentsRows.Close() 481 693 482 694 for commentsRows.Next() { 483 - var comment PullComment 695 + var comment models.PullComment 484 696 var commentCreatedStr string 485 697 err := commentsRows.Scan( 486 698 &comment.ID, ··· 524 736 } 525 737 } 526 738 527 - pull.Submissions = make([]*PullSubmission, len(submissionsMap)) 739 + pull.Submissions = make([]*models.PullSubmission, len(submissionsMap)) 528 740 for _, submission := range submissionsMap { 529 741 pull.Submissions[submission.RoundNumber] = submission 530 742 } ··· 534 746 535 747 // timeframe here is directly passed into the sql query filter, and any 536 748 // timeframe in the past should be negative; e.g.: "-3 months" 537 - func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]Pull, error) { 538 - var pulls []Pull 749 + func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]models.Pull, error) { 750 + var pulls []models.Pull 539 751 540 752 rows, err := e.Query(` 541 753 select ··· 564 776 defer rows.Close() 565 777 566 778 for rows.Next() { 567 - var pull Pull 779 + var pull models.Pull 568 780 var repo models.Repo 569 781 var pullCreatedAt, repoCreatedAt string 570 782 err := rows.Scan( ··· 608 820 return pulls, nil 609 821 } 610 822 611 - func NewPullComment(e Execer, comment *PullComment) (int64, error) { 823 + func NewPullComment(e Execer, comment *models.PullComment) (int64, error) { 612 824 query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)` 613 825 res, err := e.Exec( 614 826 query, ··· 631 843 return i, nil 632 844 } 633 845 634 - func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState PullState) error { 846 + func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState models.PullState) error { 635 847 _, err := e.Exec( 636 848 `update pulls set state = ? where repo_at = ? and pull_id = ? and (state <> ? or state <> ?)`, 637 849 pullState, 638 850 repoAt, 639 851 pullId, 640 - PullDeleted, // only update state of non-deleted pulls 641 - PullMerged, // only update state of non-merged pulls 852 + models.PullDeleted, // only update state of non-deleted pulls 853 + models.PullMerged, // only update state of non-merged pulls 642 854 ) 643 855 return err 644 856 } 645 857 646 858 func ClosePull(e Execer, repoAt syntax.ATURI, pullId int) error { 647 - err := SetPullState(e, repoAt, pullId, PullClosed) 859 + err := SetPullState(e, repoAt, pullId, models.PullClosed) 648 860 return err 649 861 } 650 862 651 863 func ReopenPull(e Execer, repoAt syntax.ATURI, pullId int) error { 652 - err := SetPullState(e, repoAt, pullId, PullOpen) 864 + err := SetPullState(e, repoAt, pullId, models.PullOpen) 653 865 return err 654 866 } 655 867 656 868 func MergePull(e Execer, repoAt syntax.ATURI, pullId int) error { 657 - err := SetPullState(e, repoAt, pullId, PullMerged) 869 + err := SetPullState(e, repoAt, pullId, models.PullMerged) 658 870 return err 659 871 } 660 872 661 873 func DeletePull(e Execer, repoAt syntax.ATURI, pullId int) error { 662 - err := SetPullState(e, repoAt, pullId, PullDeleted) 874 + err := SetPullState(e, repoAt, pullId, models.PullDeleted) 663 875 return err 664 876 } 665 877 666 - func ResubmitPull(e Execer, pull *Pull, newPatch, sourceRev string) error { 878 + func ResubmitPull(e Execer, pull *models.Pull, newPatch, sourceRev string) error { 667 879 newRoundNumber := len(pull.Submissions) 668 880 _, err := e.Exec(` 669 881 insert into pull_submissions (pull_id, repo_at, round_number, patch, source_rev) ··· 729 941 count(case when state = ? then 1 end) as deleted_count 730 942 from pulls 731 943 where repo_at = ?`, 732 - PullOpen, 733 - PullMerged, 734 - PullClosed, 735 - PullDeleted, 944 + models.PullOpen, 945 + models.PullMerged, 946 + models.PullClosed, 947 + models.PullDeleted, 736 948 repoAt, 737 949 ) 738 950 ··· 744 956 return count, nil 745 957 } 746 958 747 - type Stack []*Pull 748 - 749 959 // change-id parent-change-id 750 960 // 751 961 // 4 w ,-------- z (TOP) ··· 752 966 // 1 x <------' nil (BOT) 753 967 // 754 968 // `w` is parent of none, so it is the top of the stack 755 - func GetStack(e Execer, stackId string) (Stack, error) { 969 + func GetStack(e Execer, stackId string) (models.Stack, error) { 756 970 unorderedPulls, err := GetPulls( 757 971 e, 758 972 FilterEq("stack_id", stackId), 759 - FilterNotEq("state", PullDeleted), 973 + FilterNotEq("state", models.PullDeleted), 760 974 ) 761 975 if err != nil { 762 976 return nil, err 763 977 } 764 978 // map of parent-change-id to pull 765 - changeIdMap := make(map[string]*Pull, len(unorderedPulls)) 766 - parentMap := make(map[string]*Pull, len(unorderedPulls)) 979 + changeIdMap := make(map[string]*models.Pull, len(unorderedPulls)) 980 + parentMap := make(map[string]*models.Pull, len(unorderedPulls)) 767 981 for _, p := range unorderedPulls { 768 982 changeIdMap[p.ChangeId] = p 769 983 if p.ParentChangeId != "" { ··· 772 986 } 773 987 774 988 // the top of the stack is the pull that is not a parent of any pull 775 - var topPull *Pull 989 + var topPull *models.Pull 776 990 for _, maybeTop := range unorderedPulls { 777 991 if _, ok := parentMap[maybeTop.ChangeId]; !ok { 778 992 topPull = maybeTop ··· 780 994 } 781 995 } 782 996 783 - pulls := []*Pull{} 997 + pulls := []*models.Pull{} 784 998 for { 785 999 pulls = append(pulls, topPull) 786 1000 if topPull.ParentChangeId != "" { ··· 797 1011 return pulls, nil 798 1012 } 799 1013 800 - func GetAbandonedPulls(e Execer, stackId string) ([]*Pull, error) { 1014 + func GetAbandonedPulls(e Execer, stackId string) ([]*models.Pull, error) { 801 1015 pulls, err := GetPulls( 802 1016 e, 803 1017 FilterEq("stack_id", stackId), 804 - FilterEq("state", PullDeleted), 1018 + FilterEq("state", models.PullDeleted), 805 1019 ) 806 1020 if err != nil { 807 1021 return nil, err 808 1022 } 809 1023 810 1024 return pulls, nil 811 - } 812 - 813 - // position of this pull in the stack 814 - func (stack Stack) Position(pull *Pull) int { 815 - return slices.IndexFunc(stack, func(p *Pull) bool { 816 - return p.ChangeId == pull.ChangeId 817 - }) 818 - } 819 - 820 - // all pulls below this pull (including self) in this stack 821 - // 822 - // nil if this pull does not belong to this stack 823 - func (stack Stack) Below(pull *Pull) Stack { 824 - position := stack.Position(pull) 825 - 826 - if position < 0 { 827 - return nil 828 - } 829 - 830 - return stack[position:] 831 - } 832 - 833 - // all pulls below this pull (excluding self) in this stack 834 - func (stack Stack) StrictlyBelow(pull *Pull) Stack { 835 - below := stack.Below(pull) 836 - 837 - if len(below) > 0 { 838 - return below[1:] 839 - } 840 - 841 - return nil 842 - } 843 - 844 - // all pulls above this pull (including self) in this stack 845 - func (stack Stack) Above(pull *Pull) Stack { 846 - position := stack.Position(pull) 847 - 848 - if position < 0 { 849 - return nil 850 - } 851 - 852 - return stack[:position+1] 853 - } 854 - 855 - // all pulls below this pull (excluding self) in this stack 856 - func (stack Stack) StrictlyAbove(pull *Pull) Stack { 857 - above := stack.Above(pull) 858 - 859 - if len(above) > 0 { 860 - return above[:len(above)-1] 861 - } 862 - 863 - return nil 864 - } 865 - 866 - // the combined format-patches of all the newest submissions in this stack 867 - func (stack Stack) CombinedPatch() string { 868 - // go in reverse order because the bottom of the stack is the last element in the slice 869 - var combined strings.Builder 870 - for idx := range stack { 871 - pull := stack[len(stack)-1-idx] 872 - combined.WriteString(pull.LatestPatch()) 873 - combined.WriteString("\n") 874 - } 875 - return combined.String() 876 - } 877 - 878 - // filter out PRs that are "active" 879 - // 880 - // PRs that are still open are active 881 - func (stack Stack) Mergeable() Stack { 882 - var mergeable Stack 883 - 884 - for _, p := range stack { 885 - // stop at the first merged PR 886 - if p.State == PullMerged || p.State == PullClosed { 887 - break 888 - } 889 - 890 - // skip over deleted PRs 891 - if p.State != PullDeleted { 892 - mergeable = append(mergeable, p) 893 - } 894 - } 895 - 896 - return mergeable 897 1025 }

+4 -4

appview/db/repos.go

··· 237 237 inClause, 238 238 ) 239 239 args = append([]any{ 240 - PullOpen, 241 - PullMerged, 242 - PullClosed, 243 - PullDeleted, 240 + models.PullOpen, 241 + models.PullMerged, 242 + models.PullClosed, 243 + models.PullDeleted, 244 244 }, args...) 245 245 rows, err = e.Query( 246 246 pullCountQuery,

+310

appview/models/pull.go

··· 1 + package models 2 + 3 + import ( 4 + "fmt" 5 + "log" 6 + "slices" 7 + "strings" 8 + "time" 9 + 10 + "github.com/bluesky-social/indigo/atproto/syntax" 11 + "tangled.org/core/api/tangled" 12 + "tangled.org/core/patchutil" 13 + "tangled.org/core/types" 14 + ) 15 + 16 + type PullState int 17 + 18 + const ( 19 + PullClosed PullState = iota 20 + PullOpen 21 + PullMerged 22 + PullDeleted 23 + ) 24 + 25 + func (p PullState) String() string { 26 + switch p { 27 + case PullOpen: 28 + return "open" 29 + case PullMerged: 30 + return "merged" 31 + case PullClosed: 32 + return "closed" 33 + case PullDeleted: 34 + return "deleted" 35 + default: 36 + return "closed" 37 + } 38 + } 39 + 40 + func (p PullState) IsOpen() bool { 41 + return p == PullOpen 42 + } 43 + func (p PullState) IsMerged() bool { 44 + return p == PullMerged 45 + } 46 + func (p PullState) IsClosed() bool { 47 + return p == PullClosed 48 + } 49 + func (p PullState) IsDeleted() bool { 50 + return p == PullDeleted 51 + } 52 + 53 + type Pull struct { 54 + // ids 55 + ID int 56 + PullId int 57 + 58 + // at ids 59 + RepoAt syntax.ATURI 60 + OwnerDid string 61 + Rkey string 62 + 63 + // content 64 + Title string 65 + Body string 66 + TargetBranch string 67 + State PullState 68 + Submissions []*PullSubmission 69 + 70 + // stacking 71 + StackId string // nullable string 72 + ChangeId string // nullable string 73 + ParentChangeId string // nullable string 74 + 75 + // meta 76 + Created time.Time 77 + PullSource *PullSource 78 + 79 + // optionally, populate this when querying for reverse mappings 80 + Repo *Repo 81 + } 82 + 83 + func (p Pull) AsRecord() tangled.RepoPull { 84 + var source *tangled.RepoPull_Source 85 + if p.PullSource != nil { 86 + s := p.PullSource.AsRecord() 87 + source = &s 88 + source.Sha = p.LatestSha() 89 + } 90 + 91 + record := tangled.RepoPull{ 92 + Title: p.Title, 93 + Body: &p.Body, 94 + CreatedAt: p.Created.Format(time.RFC3339), 95 + Target: &tangled.RepoPull_Target{ 96 + Repo: p.RepoAt.String(), 97 + Branch: p.TargetBranch, 98 + }, 99 + Patch: p.LatestPatch(), 100 + Source: source, 101 + } 102 + return record 103 + } 104 + 105 + type PullSource struct { 106 + Branch string 107 + RepoAt *syntax.ATURI 108 + 109 + // optionally populate this for reverse mappings 110 + Repo *Repo 111 + } 112 + 113 + func (p PullSource) AsRecord() tangled.RepoPull_Source { 114 + var repoAt *string 115 + if p.RepoAt != nil { 116 + s := p.RepoAt.String() 117 + repoAt = &s 118 + } 119 + record := tangled.RepoPull_Source{ 120 + Branch: p.Branch, 121 + Repo: repoAt, 122 + } 123 + return record 124 + } 125 + 126 + type PullSubmission struct { 127 + // ids 128 + ID int 129 + PullId int 130 + 131 + // at ids 132 + RepoAt syntax.ATURI 133 + 134 + // content 135 + RoundNumber int 136 + Patch string 137 + Comments []PullComment 138 + SourceRev string // include the rev that was used to create this submission: only for branch/fork PRs 139 + 140 + // meta 141 + Created time.Time 142 + } 143 + 144 + type PullComment struct { 145 + // ids 146 + ID int 147 + PullId int 148 + SubmissionId int 149 + 150 + // at ids 151 + RepoAt string 152 + OwnerDid string 153 + CommentAt string 154 + 155 + // content 156 + Body string 157 + 158 + // meta 159 + Created time.Time 160 + } 161 + 162 + func (p *Pull) LatestPatch() string { 163 + latestSubmission := p.Submissions[p.LastRoundNumber()] 164 + return latestSubmission.Patch 165 + } 166 + 167 + func (p *Pull) LatestSha() string { 168 + latestSubmission := p.Submissions[p.LastRoundNumber()] 169 + return latestSubmission.SourceRev 170 + } 171 + 172 + func (p *Pull) PullAt() syntax.ATURI { 173 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey)) 174 + } 175 + 176 + func (p *Pull) LastRoundNumber() int { 177 + return len(p.Submissions) - 1 178 + } 179 + 180 + func (p *Pull) IsPatchBased() bool { 181 + return p.PullSource == nil 182 + } 183 + 184 + func (p *Pull) IsBranchBased() bool { 185 + if p.PullSource != nil { 186 + if p.PullSource.RepoAt != nil { 187 + return p.PullSource.RepoAt == &p.RepoAt 188 + } else { 189 + // no repo specified 190 + return true 191 + } 192 + } 193 + return false 194 + } 195 + 196 + func (p *Pull) IsForkBased() bool { 197 + if p.PullSource != nil { 198 + if p.PullSource.RepoAt != nil { 199 + // make sure repos are different 200 + return p.PullSource.RepoAt != &p.RepoAt 201 + } 202 + } 203 + return false 204 + } 205 + 206 + func (p *Pull) IsStacked() bool { 207 + return p.StackId != "" 208 + } 209 + 210 + func (s PullSubmission) IsFormatPatch() bool { 211 + return patchutil.IsFormatPatch(s.Patch) 212 + } 213 + 214 + func (s PullSubmission) AsFormatPatch() []types.FormatPatch { 215 + patches, err := patchutil.ExtractPatches(s.Patch) 216 + if err != nil { 217 + log.Println("error extracting patches from submission:", err) 218 + return []types.FormatPatch{} 219 + } 220 + 221 + return patches 222 + } 223 + 224 + type Stack []*Pull 225 + 226 + // position of this pull in the stack 227 + func (stack Stack) Position(pull *Pull) int { 228 + return slices.IndexFunc(stack, func(p *Pull) bool { 229 + return p.ChangeId == pull.ChangeId 230 + }) 231 + } 232 + 233 + // all pulls below this pull (including self) in this stack 234 + // 235 + // nil if this pull does not belong to this stack 236 + func (stack Stack) Below(pull *Pull) Stack { 237 + position := stack.Position(pull) 238 + 239 + if position < 0 { 240 + return nil 241 + } 242 + 243 + return stack[position:] 244 + } 245 + 246 + // all pulls below this pull (excluding self) in this stack 247 + func (stack Stack) StrictlyBelow(pull *Pull) Stack { 248 + below := stack.Below(pull) 249 + 250 + if len(below) > 0 { 251 + return below[1:] 252 + } 253 + 254 + return nil 255 + } 256 + 257 + // all pulls above this pull (including self) in this stack 258 + func (stack Stack) Above(pull *Pull) Stack { 259 + position := stack.Position(pull) 260 + 261 + if position < 0 { 262 + return nil 263 + } 264 + 265 + return stack[:position+1] 266 + } 267 + 268 + // all pulls below this pull (excluding self) in this stack 269 + func (stack Stack) StrictlyAbove(pull *Pull) Stack { 270 + above := stack.Above(pull) 271 + 272 + if len(above) > 0 { 273 + return above[:len(above)-1] 274 + } 275 + 276 + return nil 277 + } 278 + 279 + // the combined format-patches of all the newest submissions in this stack 280 + func (stack Stack) CombinedPatch() string { 281 + // go in reverse order because the bottom of the stack is the last element in the slice 282 + var combined strings.Builder 283 + for idx := range stack { 284 + pull := stack[len(stack)-1-idx] 285 + combined.WriteString(pull.LatestPatch()) 286 + combined.WriteString("\n") 287 + } 288 + return combined.String() 289 + } 290 + 291 + // filter out PRs that are "active" 292 + // 293 + // PRs that are still open are active 294 + func (stack Stack) Mergeable() Stack { 295 + var mergeable Stack 296 + 297 + for _, p := range stack { 298 + // stop at the first merged PR 299 + if p.State == PullMerged || p.State == PullClosed { 300 + break 301 + } 302 + 303 + // skip over deleted PRs 304 + if p.State != PullDeleted { 305 + mergeable = append(mergeable, p) 306 + } 307 + } 308 + 309 + return mergeable 310 + }

+2 -2

appview/notify/merged_notifier.go

··· 51 51 } 52 52 } 53 53 54 - func (m *mergedNotifier) NewPull(ctx context.Context, pull *db.Pull) { 54 + func (m *mergedNotifier) NewPull(ctx context.Context, pull *models.Pull) { 55 55 for _, notifier := range m.notifiers { 56 56 notifier.NewPull(ctx, pull) 57 57 } 58 58 } 59 - func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *db.PullComment) { 59 + func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.PullComment) { 60 60 for _, notifier := range m.notifiers { 61 61 notifier.NewPullComment(ctx, comment) 62 62 }

+4 -4

appview/notify/notifier.go

··· 18 18 NewFollow(ctx context.Context, follow *models.Follow) 19 19 DeleteFollow(ctx context.Context, follow *models.Follow) 20 20 21 - NewPull(ctx context.Context, pull *db.Pull) 22 - NewPullComment(ctx context.Context, comment *db.PullComment) 21 + NewPull(ctx context.Context, pull *models.Pull) 22 + NewPullComment(ctx context.Context, comment *models.PullComment) 23 23 24 24 UpdateProfile(ctx context.Context, profile *db.Profile) 25 25 ··· 43 43 func (m *BaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) {} 44 44 func (m *BaseNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {} 45 45 46 - func (m *BaseNotifier) NewPull(ctx context.Context, pull *db.Pull) {} 47 - func (m *BaseNotifier) NewPullComment(ctx context.Context, comment *db.PullComment) {} 46 + func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {} 47 + func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment) {} 48 48 49 49 func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *db.Profile) {} 50 50

+14 -14

appview/pages/pages.go

··· 1019 1019 type RepoPullsParams struct { 1020 1020 LoggedInUser *oauth.User 1021 1021 RepoInfo repoinfo.RepoInfo 1022 - Pulls []*db.Pull 1022 + Pulls []*models.Pull 1023 1023 Active string 1024 - FilteringBy db.PullState 1025 - Stacks map[string]db.Stack 1024 + FilteringBy models.PullState 1025 + Stacks map[string]models.Stack 1026 1026 Pipelines map[string]db.Pipeline 1027 1027 } 1028 1028 ··· 1053 1053 LoggedInUser *oauth.User 1054 1054 RepoInfo repoinfo.RepoInfo 1055 1055 Active string 1056 - Pull *db.Pull 1057 - Stack db.Stack 1058 - AbandonedPulls []*db.Pull 1056 + Pull *models.Pull 1057 + Stack models.Stack 1058 + AbandonedPulls []*models.Pull 1059 1059 MergeCheck types.MergeCheckResponse 1060 1060 ResubmitCheck ResubmitResult 1061 1061 Pipelines map[string]db.Pipeline ··· 1073 1073 type RepoPullPatchParams struct { 1074 1074 LoggedInUser *oauth.User 1075 1075 RepoInfo repoinfo.RepoInfo 1076 - Pull *db.Pull 1077 - Stack db.Stack 1076 + Pull *models.Pull 1077 + Stack models.Stack 1078 1078 Diff *types.NiceDiff 1079 1079 Round int 1080 - Submission *db.PullSubmission 1080 + Submission *models.PullSubmission 1081 1081 OrderedReactionKinds []db.ReactionKind 1082 1082 DiffOpts types.DiffOpts 1083 1083 } ··· 1090 1090 type RepoPullInterdiffParams struct { 1091 1091 LoggedInUser *oauth.User 1092 1092 RepoInfo repoinfo.RepoInfo 1093 - Pull *db.Pull 1093 + Pull *models.Pull 1094 1094 Round int 1095 1095 Interdiff *patchutil.InterdiffResult 1096 1096 OrderedReactionKinds []db.ReactionKind ··· 1143 1143 type PullResubmitParams struct { 1144 1144 LoggedInUser *oauth.User 1145 1145 RepoInfo repoinfo.RepoInfo 1146 - Pull *db.Pull 1146 + Pull *models.Pull 1147 1147 SubmissionId int 1148 1148 } 1149 1149 ··· 1154 1154 type PullActionsParams struct { 1155 1155 LoggedInUser *oauth.User 1156 1156 RepoInfo repoinfo.RepoInfo 1157 - Pull *db.Pull 1157 + Pull *models.Pull 1158 1158 RoundNumber int 1159 1159 MergeCheck types.MergeCheckResponse 1160 1160 ResubmitCheck ResubmitResult 1161 - Stack db.Stack 1161 + Stack models.Stack 1162 1162 } 1163 1163 1164 1164 func (p *Pages) PullActionsFragment(w io.Writer, params PullActionsParams) error { ··· 1168 1168 type PullNewCommentParams struct { 1169 1169 LoggedInUser *oauth.User 1170 1170 RepoInfo repoinfo.RepoInfo 1171 - Pull *db.Pull 1171 + Pull *models.Pull 1172 1172 RoundNumber int 1173 1173 } 1174 1174

+2 -2

appview/posthog/notifier.go

··· 71 71 } 72 72 } 73 73 74 - func (n *posthogNotifier) NewPull(ctx context.Context, pull *db.Pull) { 74 + func (n *posthogNotifier) NewPull(ctx context.Context, pull *models.Pull) { 75 75 err := n.client.Enqueue(posthog.Capture{ 76 76 DistinctId: pull.OwnerDid, 77 77 Event: "new_pull", ··· 85 85 } 86 86 } 87 87 88 - func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *db.PullComment) { 88 + func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.PullComment) { 89 89 err := n.client.Enqueue(posthog.Capture{ 90 90 DistinctId: comment.OwnerDid, 91 91 Event: "new_pull_comment",

+54 -54

appview/pulls/pulls.go

··· 76 76 return 77 77 } 78 78 79 - pull, ok := r.Context().Value("pull").(*db.Pull) 79 + pull, ok := r.Context().Value("pull").(*models.Pull) 80 80 if !ok { 81 81 log.Println("failed to get pull") 82 82 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 84 84 } 85 85 86 86 // can be nil if this pull is not stacked 87 - stack, _ := r.Context().Value("stack").(db.Stack) 87 + stack, _ := r.Context().Value("stack").(models.Stack) 88 88 89 89 roundNumberStr := chi.URLParam(r, "round") 90 90 roundNumber, err := strconv.Atoi(roundNumberStr) ··· 124 124 return 125 125 } 126 126 127 - pull, ok := r.Context().Value("pull").(*db.Pull) 127 + pull, ok := r.Context().Value("pull").(*models.Pull) 128 128 if !ok { 129 129 log.Println("failed to get pull") 130 130 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 132 132 } 133 133 134 134 // can be nil if this pull is not stacked 135 - stack, _ := r.Context().Value("stack").(db.Stack) 136 - abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*db.Pull) 135 + stack, _ := r.Context().Value("stack").(models.Stack) 136 + abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull) 137 137 138 138 totalIdents := 1 139 139 for _, submission := range pull.Submissions { ··· 216 216 }) 217 217 } 218 218 219 - func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) types.MergeCheckResponse { 220 - if pull.State == db.PullMerged { 219 + func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse { 220 + if pull.State == models.PullMerged { 221 221 return types.MergeCheckResponse{} 222 222 } 223 223 ··· 283 283 return result 284 284 } 285 285 286 - func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) pages.ResubmitResult { 287 - if pull.State == db.PullMerged || pull.State == db.PullDeleted || pull.PullSource == nil { 286 + func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult { 287 + if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil { 288 288 return pages.Unknown 289 289 } 290 290 ··· 357 357 diffOpts.Split = true 358 358 } 359 359 360 - pull, ok := r.Context().Value("pull").(*db.Pull) 360 + pull, ok := r.Context().Value("pull").(*models.Pull) 361 361 if !ok { 362 362 log.Println("failed to get pull") 363 363 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 364 364 return 365 365 } 366 366 367 - stack, _ := r.Context().Value("stack").(db.Stack) 367 + stack, _ := r.Context().Value("stack").(models.Stack) 368 368 369 369 roundId := chi.URLParam(r, "round") 370 370 roundIdInt, err := strconv.Atoi(roundId) ··· 404 404 diffOpts.Split = true 405 405 } 406 406 407 - pull, ok := r.Context().Value("pull").(*db.Pull) 407 + pull, ok := r.Context().Value("pull").(*models.Pull) 408 408 if !ok { 409 409 log.Println("failed to get pull") 410 410 s.pages.Notice(w, "pull-error", "Failed to get pull.") ··· 452 452 } 453 453 454 454 func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) { 455 - pull, ok := r.Context().Value("pull").(*db.Pull) 455 + pull, ok := r.Context().Value("pull").(*models.Pull) 456 456 if !ok { 457 457 log.Println("failed to get pull") 458 458 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 475 475 user := s.oauth.GetUser(r) 476 476 params := r.URL.Query() 477 477 478 - state := db.PullOpen 478 + state := models.PullOpen 479 479 switch params.Get("state") { 480 480 case "closed": 481 - state = db.PullClosed 481 + state = models.PullClosed 482 482 case "merged": 483 - state = db.PullMerged 483 + state = models.PullMerged 484 484 } 485 485 486 486 f, err := s.repoResolver.Resolve(r) ··· 516 516 } 517 517 518 518 // we want to group all stacked PRs into just one list 519 - stacks := make(map[string]db.Stack) 519 + stacks := make(map[string]models.Stack) 520 520 var shas []string 521 521 n := 0 522 522 for _, p := range pulls { ··· 575 575 return 576 576 } 577 577 578 - pull, ok := r.Context().Value("pull").(*db.Pull) 578 + pull, ok := r.Context().Value("pull").(*models.Pull) 579 579 if !ok { 580 580 log.Println("failed to get pull") 581 581 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 648 648 return 649 649 } 650 650 651 - comment := &db.PullComment{ 651 + comment := &models.PullComment{ 652 652 OwnerDid: user.Did, 653 653 RepoAt: f.RepoAt().String(), 654 654 PullId: pull.PullId, ··· 891 891 return 892 892 } 893 893 894 - pullSource := &db.PullSource{ 894 + pullSource := &models.PullSource{ 895 895 Branch: sourceBranch, 896 896 } 897 897 recordPullSource := &tangled.RepoPull_Source{ ··· 1001 1001 forkAtUri := fork.RepoAt() 1002 1002 forkAtUriStr := forkAtUri.String() 1003 1003 1004 - pullSource := &db.PullSource{ 1004 + pullSource := &models.PullSource{ 1005 1005 Branch: sourceBranch, 1006 1006 RepoAt: &forkAtUri, 1007 1007 } ··· 1022 1022 title, body, targetBranch string, 1023 1023 patch string, 1024 1024 sourceRev string, 1025 - pullSource *db.PullSource, 1025 + pullSource *models.PullSource, 1026 1026 recordPullSource *tangled.RepoPull_Source, 1027 1027 isStacked bool, 1028 1028 ) { ··· 1074 1074 } 1075 1075 1076 1076 rkey := tid.TID() 1077 - initialSubmission := db.PullSubmission{ 1077 + initialSubmission := models.PullSubmission{ 1078 1078 Patch: patch, 1079 1079 SourceRev: sourceRev, 1080 1080 } 1081 - pull := &db.Pull{ 1081 + pull := &models.Pull{ 1082 1082 Title: title, 1083 1083 Body: body, 1084 1084 TargetBranch: targetBranch, 1085 1085 OwnerDid: user.Did, 1086 1086 RepoAt: f.RepoAt(), 1087 1087 Rkey: rkey, 1088 - Submissions: []*db.PullSubmission{ 1088 + Submissions: []*models.PullSubmission{ 1089 1089 &initialSubmission, 1090 1090 }, 1091 1091 PullSource: pullSource, ··· 1144 1144 targetBranch string, 1145 1145 patch string, 1146 1146 sourceRev string, 1147 - pullSource *db.PullSource, 1147 + pullSource *models.PullSource, 1148 1148 ) { 1149 1149 // run some necessary checks for stacked-prs first 1150 1150 ··· 1452 1452 return 1453 1453 } 1454 1454 1455 - pull, ok := r.Context().Value("pull").(*db.Pull) 1455 + pull, ok := r.Context().Value("pull").(*models.Pull) 1456 1456 if !ok { 1457 1457 log.Println("failed to get pull") 1458 1458 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 1483 1483 func (s *Pulls) resubmitPatch(w http.ResponseWriter, r *http.Request) { 1484 1484 user := s.oauth.GetUser(r) 1485 1485 1486 - pull, ok := r.Context().Value("pull").(*db.Pull) 1486 + pull, ok := r.Context().Value("pull").(*models.Pull) 1487 1487 if !ok { 1488 1488 log.Println("failed to get pull") 1489 1489 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 1510 1510 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) { 1511 1511 user := s.oauth.GetUser(r) 1512 1512 1513 - pull, ok := r.Context().Value("pull").(*db.Pull) 1513 + pull, ok := r.Context().Value("pull").(*models.Pull) 1514 1514 if !ok { 1515 1515 log.Println("failed to get pull") 1516 1516 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.") ··· 1573 1573 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) { 1574 1574 user := s.oauth.GetUser(r) 1575 1575 1576 - pull, ok := r.Context().Value("pull").(*db.Pull) 1576 + pull, ok := r.Context().Value("pull").(*models.Pull) 1577 1577 if !ok { 1578 1578 log.Println("failed to get pull") 1579 1579 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.") ··· 1666 1666 } 1667 1667 1668 1668 // validate a resubmission against a pull request 1669 - func validateResubmittedPatch(pull *db.Pull, patch string) error { 1669 + func validateResubmittedPatch(pull *models.Pull, patch string) error { 1670 1670 if patch == "" { 1671 1671 return fmt.Errorf("Patch is empty.") 1672 1672 } ··· 1687 1687 r *http.Request, 1688 1688 f *reporesolver.ResolvedRepo, 1689 1689 user *oauth.User, 1690 - pull *db.Pull, 1690 + pull *models.Pull, 1691 1691 patch string, 1692 1692 sourceRev string, 1693 1693 ) { ··· 1791 1791 r *http.Request, 1792 1792 f *reporesolver.ResolvedRepo, 1793 1793 user *oauth.User, 1794 - pull *db.Pull, 1794 + pull *models.Pull, 1795 1795 patch string, 1796 1796 stackId string, 1797 1797 ) { 1798 1798 targetBranch := pull.TargetBranch 1799 1799 1800 - origStack, _ := r.Context().Value("stack").(db.Stack) 1800 + origStack, _ := r.Context().Value("stack").(models.Stack) 1801 1801 newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId) 1802 1802 if err != nil { 1803 1803 log.Println("failed to create resubmitted stack", err) ··· 1806 1806 } 1807 1807 1808 1808 // find the diff between the stacks, first, map them by changeId 1809 - origById := make(map[string]*db.Pull) 1810 - newById := make(map[string]*db.Pull) 1809 + origById := make(map[string]*models.Pull) 1810 + newById := make(map[string]*models.Pull) 1811 1811 for _, p := range origStack { 1812 1812 origById[p.ChangeId] = p 1813 1813 } ··· 1820 1820 // commits that got updated: corresponding pull is resubmitted & new round begins 1821 1821 // 1822 1822 // for commits that were unchanged: no changes, parent-change-id is updated as necessary 1823 - additions := make(map[string]*db.Pull) 1824 - deletions := make(map[string]*db.Pull) 1823 + additions := make(map[string]*models.Pull) 1824 + deletions := make(map[string]*models.Pull) 1825 1825 unchanged := make(map[string]struct{}) 1826 1826 updated := make(map[string]struct{}) 1827 1827 ··· 1881 1881 // deleted pulls are marked as deleted in the DB 1882 1882 for _, p := range deletions { 1883 1883 // do not do delete already merged PRs 1884 - if p.State == db.PullMerged { 1884 + if p.State == models.PullMerged { 1885 1885 continue 1886 1886 } 1887 1887 ··· 1926 1926 np, _ := newById[id] 1927 1927 1928 1928 // do not update already merged PRs 1929 - if op.State == db.PullMerged { 1929 + if op.State == models.PullMerged { 1930 1930 continue 1931 1931 } 1932 1932 ··· 2047 2047 return 2048 2048 } 2049 2049 2050 - pull, ok := r.Context().Value("pull").(*db.Pull) 2050 + pull, ok := r.Context().Value("pull").(*models.Pull) 2051 2051 if !ok { 2052 2052 log.Println("failed to get pull") 2053 2053 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.") 2054 2054 return 2055 2055 } 2056 2056 2057 - var pullsToMerge db.Stack 2057 + var pullsToMerge models.Stack 2058 2058 pullsToMerge = append(pullsToMerge, pull) 2059 2059 if pull.IsStacked() { 2060 - stack, ok := r.Context().Value("stack").(db.Stack) 2060 + stack, ok := r.Context().Value("stack").(models.Stack) 2061 2061 if !ok { 2062 2062 log.Println("failed to get stack") 2063 2063 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.") ··· 2159 2159 return 2160 2160 } 2161 2161 2162 - pull, ok := r.Context().Value("pull").(*db.Pull) 2162 + pull, ok := r.Context().Value("pull").(*models.Pull) 2163 2163 if !ok { 2164 2164 log.Println("failed to get pull") 2165 2165 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 2187 2187 } 2188 2188 defer tx.Rollback() 2189 2189 2190 - var pullsToClose []*db.Pull 2190 + var pullsToClose []*models.Pull 2191 2191 pullsToClose = append(pullsToClose, pull) 2192 2192 2193 2193 // if this PR is stacked, then we want to close all PRs below this one on the stack 2194 2194 if pull.IsStacked() { 2195 - stack := r.Context().Value("stack").(db.Stack) 2195 + stack := r.Context().Value("stack").(models.Stack) 2196 2196 subStack := stack.StrictlyBelow(pull) 2197 2197 pullsToClose = append(pullsToClose, subStack...) 2198 2198 } ··· 2227 2227 return 2228 2228 } 2229 2229 2230 - pull, ok := r.Context().Value("pull").(*db.Pull) 2230 + pull, ok := r.Context().Value("pull").(*models.Pull) 2231 2231 if !ok { 2232 2232 log.Println("failed to get pull") 2233 2233 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") ··· 2255 2255 } 2256 2256 defer tx.Rollback() 2257 2257 2258 - var pullsToReopen []*db.Pull 2258 + var pullsToReopen []*models.Pull 2259 2259 pullsToReopen = append(pullsToReopen, pull) 2260 2260 2261 2261 // if this PR is stacked, then we want to reopen all PRs above this one on the stack 2262 2262 if pull.IsStacked() { 2263 - stack := r.Context().Value("stack").(db.Stack) 2263 + stack := r.Context().Value("stack").(models.Stack) 2264 2264 subStack := stack.StrictlyAbove(pull) 2265 2265 pullsToReopen = append(pullsToReopen, subStack...) 2266 2266 } ··· 2285 2285 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId)) 2286 2286 } 2287 2287 2288 - func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *db.PullSource, stackId string) (db.Stack, error) { 2288 + func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) { 2289 2289 formatPatches, err := patchutil.ExtractPatches(patch) 2290 2290 if err != nil { 2291 2291 return nil, fmt.Errorf("Failed to extract patches: %v", err) ··· 2297 2297 } 2298 2298 2299 2299 // the stack is identified by a UUID 2300 - var stack db.Stack 2300 + var stack models.Stack 2301 2301 parentChangeId := "" 2302 2302 for _, fp := range formatPatches { 2303 2303 // all patches must have a jj change-id ··· 2310 2310 body := fp.Body 2311 2311 rkey := tid.TID() 2312 2312 2313 - initialSubmission := db.PullSubmission{ 2313 + initialSubmission := models.PullSubmission{ 2314 2314 Patch: fp.Raw, 2315 2315 SourceRev: fp.SHA, 2316 2316 } 2317 - pull := db.Pull{ 2317 + pull := models.Pull{ 2318 2318 Title: title, 2319 2319 Body: body, 2320 2320 TargetBranch: targetBranch, 2321 2321 OwnerDid: user.Did, 2322 2322 RepoAt: f.RepoAt(), 2323 2323 Rkey: rkey, 2324 - Submissions: []*db.PullSubmission{ 2324 + Submissions: []*models.PullSubmission{ 2325 2325 &initialSubmission, 2326 2326 }, 2327 2327 PullSource: pullSource,

+5 -5

appview/repo/feed.go

··· 71 71 return feed, nil 72 72 } 73 73 74 - func (rp *Repo) createPullItems(ctx context.Context, pull *db.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) { 74 + func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) { 75 75 owner, err := rp.idResolver.ResolveIdent(ctx, pull.OwnerDid) 76 76 if err != nil { 77 77 return nil, err ··· 129 129 }, nil 130 130 } 131 131 132 - func (rp *Repo) getPullState(pull *db.Pull) string { 133 - if pull.State == db.PullOpen { 132 + func (rp *Repo) getPullState(pull *models.Pull) string { 133 + if pull.State == models.PullOpen { 134 134 return "opened" 135 135 } 136 136 return pull.State.String() 137 137 } 138 138 139 - func (rp *Repo) buildPullDescription(handle syntax.Handle, state string, pull *db.Pull, repoName string) string { 139 + func (rp *Repo) buildPullDescription(handle syntax.Handle, state string, pull *models.Pull, repoName string) string { 140 140 base := fmt.Sprintf("@%s %s pull request #%d", handle, state, pull.PullId) 141 141 142 - if pull.State == db.PullMerged { 142 + if pull.State == models.PullMerged { 143 143 return fmt.Sprintf("%s (on round #%d) in %s", base, pull.LastRoundNumber(), repoName) 144 144 } 145 145

+2 -2

appview/state/profile.go

··· 454 454 return &feed, nil 455 455 } 456 456 457 - func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*db.Pull, author *feeds.Author) error { 457 + func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error { 458 458 for _, pull := range pulls { 459 459 owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did) 460 460 if err != nil { ··· 490 490 return nil 491 491 } 492 492 493 - func (s *State) createPullRequestItem(pull *db.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item { 493 + func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item { 494 494 return &feeds.Item{ 495 495 Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name), 496 496 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"},

Configure Feed

Configure Feed