+36 -2

api/tangled/cbor_gen.go

··· 7008 7008 } 7009 7009 7010 7010 cw := cbg.NewCborWriter(w) 7011 7011 - fieldCount := 2 7011 7011 + fieldCount := 3 7012 7012 7013 7013 if t.Repo == nil { 7014 7014 fieldCount-- 7015 7015 } 7016 7016 7017 7017 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7018 7018 + return err 7019 7019 + } 7020 7020 + 7021 7021 + // t.Sha (string) (string) 7022 7022 + if len("sha") > 1000000 { 7023 7023 + return xerrors.Errorf("Value in field \"sha\" was too long") 7024 7024 + } 7025 7025 + 7026 7026 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil { 7027 7027 + return err 7028 7028 + } 7029 7029 + if _, err := cw.WriteString(string("sha")); err != nil { 7030 7030 + return err 7031 7031 + } 7032 7032 + 7033 7033 + if len(t.Sha) > 1000000 { 7034 7034 + return xerrors.Errorf("Value in field t.Sha was too long") 7035 7035 + } 7036 7036 + 7037 7037 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil { 7038 7038 + return err 7039 7039 + } 7040 7040 + if _, err := cw.WriteString(string(t.Sha)); err != nil { 7018 7041 return err 7019 7042 } 7020 7043 ··· 7116 7139 } 7117 7140 7118 7141 switch string(nameBuf[:nameLen]) { 7119 7119 - // t.Repo (string) (string) 7142 7142 + // t.Sha (string) (string) 7143 7143 + case "sha": 7144 7144 + 7145 7145 + { 7146 7146 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7147 7147 + if err != nil { 7148 7148 + return err 7149 7149 + } 7150 7150 + 7151 7151 + t.Sha = string(sval) 7152 7152 + } 7153 7153 + // t.Repo (string) (string) 7120 7154 case "repo": 7121 7155 7122 7156 {

+1

api/tangled/repopull.go

··· 32 32 type RepoPull_Source struct { 33 33 Branch string `json:"branch" cborgen:"branch"` 34 34 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 35 35 + Sha string `json:"sha" cborgen:"sha"` 35 36 }

+1 -1

appview/db/artifact.go

··· 27 27 } 28 28 29 29 func (a *Artifact) ArtifactAt() syntax.ATURI { 30 30 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoPullNSID, a.Rkey)) 30 30 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey)) 31 31 } 32 32 33 33 func AddArtifact(e Execer, artifact Artifact) error {

+6

appview/db/pulls.go

··· 87 87 if p.PullSource != nil { 88 88 s := p.PullSource.AsRecord() 89 89 source = &s 90 90 + source.Sha = p.LatestSha() 90 91 } 91 92 92 93 record := tangled.RepoPull{ ··· 162 163 func (p *Pull) LatestPatch() string { 163 164 latestSubmission := p.Submissions[p.LastRoundNumber()] 164 165 return latestSubmission.Patch 166 166 + } 167 167 + 168 168 + func (p *Pull) LatestSha() string { 169 169 + latestSubmission := p.Submissions[p.LastRoundNumber()] 170 170 + return latestSubmission.SourceRev 165 171 } 166 172 167 173 func (p *Pull) PullAt() syntax.ATURI {

+21 -11

appview/pulls/pulls.go

··· 798 798 sourceBranch string, 799 799 isStacked bool, 800 800 ) { 801 801 - pullSource := &db.PullSource{ 802 802 - Branch: sourceBranch, 803 803 - } 804 804 - recordPullSource := &tangled.RepoPull_Source{ 805 805 - Branch: sourceBranch, 806 806 - } 807 807 - 808 801 // Generate a patch using /compare 809 802 ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev) 810 803 if err != nil { ··· 826 819 if !patchutil.IsPatchValid(patch) { 827 820 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 828 821 return 822 822 + } 823 823 + 824 824 + pullSource := &db.PullSource{ 825 825 + Branch: sourceBranch, 826 826 + } 827 827 + recordPullSource := &tangled.RepoPull_Source{ 828 828 + Branch: sourceBranch, 829 829 + Sha: comparison.Rev2, 829 830 } 830 831 831 832 s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked) ··· 914 915 return 915 916 } 916 917 917 917 - s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, &db.PullSource{ 918 918 + pullSource := &db.PullSource{ 918 919 Branch: sourceBranch, 919 920 RepoAt: &forkAtUri, 920 920 - }, &tangled.RepoPull_Source{Branch: sourceBranch, Repo: &fork.AtUri}, isStacked) 921 921 + } 922 922 + recordPullSource := &tangled.RepoPull_Source{ 923 923 + Branch: sourceBranch, 924 924 + Repo: &fork.AtUri, 925 925 + Sha: sourceRev, 926 926 + } 927 927 + 928 928 + s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked) 921 929 } 922 930 923 931 func (s *Pulls) createPullRequest( ··· 934 942 ) { 935 943 if isStacked { 936 944 // creates a series of PRs, each linking to the previous, identified by jj's change-id 937 937 - s.createStackedPulLRequest( 945 945 + s.createStackedPullRequest( 938 946 w, 939 947 r, 940 948 f, ··· 1049 1057 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId)) 1050 1058 } 1051 1059 1052 1052 - func (s *Pulls) createStackedPulLRequest( 1060 1060 + func (s *Pulls) createStackedPullRequest( 1053 1061 w http.ResponseWriter, 1054 1062 r *http.Request, 1055 1063 f *reporesolver.ResolvedRepo, ··· 1566 1574 if pull.IsBranchBased() { 1567 1575 recordPullSource = &tangled.RepoPull_Source{ 1568 1576 Branch: pull.PullSource.Branch, 1577 1577 + Sha: sourceRev, 1569 1578 } 1570 1579 } 1571 1580 if pull.IsForkBased() { ··· 1573 1582 recordPullSource = &tangled.RepoPull_Source{ 1574 1583 Branch: pull.PullSource.Branch, 1575 1584 Repo: &repoAt, 1585 1585 + Sha: sourceRev, 1576 1586 } 1577 1587 } 1578 1588

+1 -1

appview/repo/index.go

··· 133 133 for _, c := range commitsTrunc { 134 134 shas = append(shas, c.Hash.String()) 135 135 } 136 136 - pipelines, err := rp.getPipelineStatuses(repoInfo, shas) 136 136 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 137 137 if err != nil { 138 138 log.Printf("failed to fetch pipeline statuses: %s", err) 139 139 // non-fatal

+2 -2

appview/repo/repo.go

··· 139 139 for _, c := range repolog.Commits { 140 140 shas = append(shas, c.Hash.String()) 141 141 } 142 142 - pipelines, err := rp.getPipelineStatuses(repoInfo, shas) 142 142 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 143 143 if err != nil { 144 144 log.Println(err) 145 145 // non-fatal ··· 304 304 305 305 user := rp.oauth.GetUser(r) 306 306 repoInfo := f.RepoInfo(user) 307 307 - pipelines, err := rp.getPipelineStatuses(repoInfo, []string{result.Diff.Commit.This}) 307 307 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 308 308 if err != nil { 309 309 log.Println(err) 310 310 // non-fatal

+3 -2

appview/repo/repo_util.go

··· 105 105 // grab pipelines from DB and munge that into a hashmap with commit sha as key 106 106 // 107 107 // golang is so blessed that it requires 35 lines of imperative code for this 108 108 - func (rp *Repo) getPipelineStatuses( 108 108 + func getPipelineStatuses( 109 109 + d *db.DB, 109 110 repoInfo repoinfo.RepoInfo, 110 111 shas []string, 111 112 ) (map[string]db.Pipeline, error) { ··· 116 117 } 117 118 118 119 ps, err := db.GetPipelineStatuses( 119 119 - rp.db, 120 120 + d, 120 121 db.FilterEq("repo_owner", repoInfo.OwnerDid), 121 122 db.FilterEq("repo_name", repoInfo.Name), 122 123 db.FilterEq("knot", repoInfo.Knot),

+7 -1

lexicons/pulls/pull.json

··· 51 51 "source": { 52 52 "type": "object", 53 53 "required": [ 54 54 - "branch" 54 54 + "branch", 55 55 + "sha" 55 56 ], 56 57 "properties": { 57 58 "branch": { 58 59 "type": "string" 60 60 + }, 61 61 + "sha": { 62 62 + "type": "string", 63 63 + "minLength": 40, 64 64 + "maxLength": 40 59 65 }, 60 66 "repo": { 61 67 "type": "string",