lexicons: pulls: put target repo and branch together in their own object #404

+166 -64

api/tangled/cbor_gen.go

··· 6939 6940 return nil 6941 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6942 func (t *RepoPull) MarshalCBOR(w io.Writer) error { 6943 if t == nil { 6944 _, err := w.Write(cbg.CborNull) ··· 6946 } 6947 6948 cw := cbg.NewCborWriter(w) 6949 - fieldCount := 8 6950 6951 if t.Body == nil { 6952 fieldCount-- ··· 7076 } 7077 } 7078 7079 - // t.CreatedAt (string) (string) 7080 - if len("createdAt") > 1000000 { 7081 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 7082 } 7083 7084 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7085 return err 7086 } 7087 - if _, err := cw.WriteString(string("createdAt")); err != nil { 7088 return err 7089 } 7090 7091 - if len(t.CreatedAt) > 1000000 { 7092 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 7093 - } 7094 - 7095 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 7096 - return err 7097 - } 7098 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7099 - return err 7100 - } 7101 - 7102 - // t.TargetRepo (string) (string) 7103 - if len("targetRepo") > 1000000 { 7104 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 7105 - } 7106 - 7107 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 7108 - return err 7109 - } 7110 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 7111 return err 7112 } 7113 7114 - if len(t.TargetRepo) > 1000000 { 7115 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 7116 - } 7117 - 7118 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 7119 - return err 7120 - } 7121 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 7122 - return err 7123 - } 7124 - 7125 - // t.TargetBranch (string) (string) 7126 - if len("targetBranch") > 1000000 { 7127 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 7128 } 7129 7130 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 7131 return err 7132 } 7133 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 7134 return err 7135 } 7136 7137 - if len(t.TargetBranch) > 1000000 { 7138 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 7139 } 7140 7141 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 7142 return err 7143 } 7144 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 7145 return err 7146 } 7147 return nil ··· 7172 7173 n := extra 7174 7175 - nameBuf := make([]byte, 12) 7176 for i := uint64(0); i < n; i++ { 7177 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7178 if err != nil { ··· 7262 } 7263 7264 } 7265 - // t.CreatedAt (string) (string) 7266 - case "createdAt": 7267 7268 { 7269 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7270 - if err != nil { 7271 - return err 7272 - } 7273 7274 - t.CreatedAt = string(sval) 7275 - } 7276 - // t.TargetRepo (string) (string) 7277 - case "targetRepo": 7278 - 7279 - { 7280 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7281 if err != nil { 7282 return err 7283 } 0 0 0 0 0 0 0 0 0 7284 7285 - t.TargetRepo = string(sval) 7286 } 7287 - // t.TargetBranch (string) (string) 7288 - case "targetBranch": 7289 7290 { 7291 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 7293 return err 7294 } 7295 7296 - t.TargetBranch = string(sval) 7297 } 7298 7299 default:

··· 6939 6940 return nil 6941 } 6942 + func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error { 6943 + if t == nil { 6944 + _, err := w.Write(cbg.CborNull) 6945 + return err 6946 + } 6947 + 6948 + cw := cbg.NewCborWriter(w) 6949 + 6950 + if _, err := cw.Write([]byte{162}); err != nil { 6951 + return err 6952 + } 6953 + 6954 + // t.Repo (string) (string) 6955 + if len("repo") > 1000000 { 6956 + return xerrors.Errorf("Value in field \"repo\" was too long") 6957 + } 6958 + 6959 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6960 + return err 6961 + } 6962 + if _, err := cw.WriteString(string("repo")); err != nil { 6963 + return err 6964 + } 6965 + 6966 + if len(t.Repo) > 1000000 { 6967 + return xerrors.Errorf("Value in field t.Repo was too long") 6968 + } 6969 + 6970 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6971 + return err 6972 + } 6973 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 6974 + return err 6975 + } 6976 + 6977 + // t.Branch (string) (string) 6978 + if len("branch") > 1000000 { 6979 + return xerrors.Errorf("Value in field \"branch\" was too long") 6980 + } 6981 + 6982 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6983 + return err 6984 + } 6985 + if _, err := cw.WriteString(string("branch")); err != nil { 6986 + return err 6987 + } 6988 + 6989 + if len(t.Branch) > 1000000 { 6990 + return xerrors.Errorf("Value in field t.Branch was too long") 6991 + } 6992 + 6993 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6994 + return err 6995 + } 6996 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 6997 + return err 6998 + } 6999 + return nil 7000 + } 7001 + 7002 + func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) { 7003 + *t = RepoPull_Target{} 7004 + 7005 + cr := cbg.NewCborReader(r) 7006 + 7007 + maj, extra, err := cr.ReadHeader() 7008 + if err != nil { 7009 + return err 7010 + } 7011 + defer func() { 7012 + if err == io.EOF { 7013 + err = io.ErrUnexpectedEOF 7014 + } 7015 + }() 7016 + 7017 + if maj != cbg.MajMap { 7018 + return fmt.Errorf("cbor input should be of type map") 7019 + } 7020 + 7021 + if extra > cbg.MaxLength { 7022 + return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra) 7023 + } 7024 + 7025 + n := extra 7026 + 7027 + nameBuf := make([]byte, 6) 7028 + for i := uint64(0); i < n; i++ { 7029 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7030 + if err != nil { 7031 + return err 7032 + } 7033 + 7034 + if !ok { 7035 + // Field doesn't exist on this type, so ignore it 7036 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7037 + return err 7038 + } 7039 + continue 7040 + } 7041 + 7042 + switch string(nameBuf[:nameLen]) { 7043 + // t.Repo (string) (string) 7044 + case "repo": 7045 + 7046 + { 7047 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7048 + if err != nil { 7049 + return err 7050 + } 7051 + 7052 + t.Repo = string(sval) 7053 + } 7054 + // t.Branch (string) (string) 7055 + case "branch": 7056 + 7057 + { 7058 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7059 + if err != nil { 7060 + return err 7061 + } 7062 + 7063 + t.Branch = string(sval) 7064 + } 7065 + 7066 + default: 7067 + // Field doesn't exist on this type, so ignore it 7068 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7069 + return err 7070 + } 7071 + } 7072 + } 7073 + 7074 + return nil 7075 + } 7076 func (t *RepoPull) MarshalCBOR(w io.Writer) error { 7077 if t == nil { 7078 _, err := w.Write(cbg.CborNull) ··· 7080 } 7081 7082 cw := cbg.NewCborWriter(w) 7083 + fieldCount := 7 7084 7085 if t.Body == nil { 7086 fieldCount-- ··· 7210 } 7211 } 7212 7213 + // t.Target (tangled.RepoPull_Target) (struct) 7214 + if len("target") > 1000000 { 7215 + return xerrors.Errorf("Value in field \"target\" was too long") 7216 } 7217 7218 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil { 7219 return err 7220 } 7221 + if _, err := cw.WriteString(string("target")); err != nil { 7222 return err 7223 } 7224 7225 + if err := t.Target.MarshalCBOR(cw); err != nil { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7226 return err 7227 } 7228 7229 + // t.CreatedAt (string) (string) 7230 + if len("createdAt") > 1000000 { 7231 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 0 0 0 0 0 0 0 0 0 0 0 7232 } 7233 7234 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7235 return err 7236 } 7237 + if _, err := cw.WriteString(string("createdAt")); err != nil { 7238 return err 7239 } 7240 7241 + if len(t.CreatedAt) > 1000000 { 7242 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 7243 } 7244 7245 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 7246 return err 7247 } 7248 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7249 return err 7250 } 7251 return nil ··· 7276 7277 n := extra 7278 7279 + nameBuf := make([]byte, 9) 7280 for i := uint64(0); i < n; i++ { 7281 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7282 if err != nil { ··· 7366 } 7367 7368 } 7369 + // t.Target (tangled.RepoPull_Target) (struct) 7370 + case "target": 7371 7372 { 0 0 0 0 7373 7374 + b, err := cr.ReadByte() 0 0 0 0 0 0 7375 if err != nil { 7376 return err 7377 } 7378 + if b != cbg.CborNull[0] { 7379 + if err := cr.UnreadByte(); err != nil { 7380 + return err 7381 + } 7382 + t.Target = new(RepoPull_Target) 7383 + if err := t.Target.UnmarshalCBOR(cr); err != nil { 7384 + return xerrors.Errorf("unmarshaling t.Target pointer: %w", err) 7385 + } 7386 + } 7387 0 7388 } 7389 + // t.CreatedAt (string) (string) 7390 + case "createdAt": 7391 7392 { 7393 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 7395 return err 7396 } 7397 7398 + t.CreatedAt = string(sval) 7399 } 7400 7401 default:

+7 -2

api/tangled/repopull.go

··· 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Patch string `json:"patch" cborgen:"patch"` 24 Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 25 - TargetBranch string `json:"targetBranch" cborgen:"targetBranch"` 26 - TargetRepo string `json:"targetRepo" cborgen:"targetRepo"` 27 Title string `json:"title" cborgen:"title"` 28 } 29 ··· 33 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 34 Sha string `json:"sha" cborgen:"sha"` 35 } 0 0 0 0 0 0

··· 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Patch string `json:"patch" cborgen:"patch"` 24 Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 25 + Target *RepoPull_Target `json:"target" cborgen:"target"` 0 26 Title string `json:"title" cborgen:"title"` 27 } 28 ··· 32 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 33 Sha string `json:"sha" cborgen:"sha"` 34 } 35 + 36 + // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 37 + type RepoPull_Target struct { 38 + Branch string `json:"branch" cborgen:"branch"` 39 + Repo string `json:"repo" cborgen:"repo"` 40 + }

+4 -2

appview/db/pulls.go

··· 94 Title: p.Title, 95 Body: &p.Body, 96 CreatedAt: p.Created.Format(time.RFC3339), 97 - TargetRepo: p.RepoAt.String(), 98 - TargetBranch: p.TargetBranch, 0 0 99 Patch: p.LatestPatch(), 100 Source: source, 101 }

··· 94 Title: p.Title, 95 Body: &p.Body, 96 CreatedAt: p.Created.Format(time.RFC3339), 97 + Target: &tangled.RepoPull_Target{ 98 + Repo: p.RepoAt.String(), 99 + Branch: p.TargetBranch, 100 + }, 101 Patch: p.LatestPatch(), 102 Source: source, 103 }

+8 -4

appview/pulls/pulls.go

··· 1091 Record: &lexutil.LexiconTypeDecoder{ 1092 Val: &tangled.RepoPull{ 1093 Title: title, 1094 - TargetRepo: string(f.RepoAt), 1095 - TargetBranch: targetBranch, 0 0 1096 Patch: patch, 1097 Source: recordPullSource, 1098 }, ··· 1652 Record: &lexutil.LexiconTypeDecoder{ 1653 Val: &tangled.RepoPull{ 1654 Title: pull.Title, 1655 - TargetRepo: string(f.RepoAt), 1656 - TargetBranch: pull.TargetBranch, 0 0 1657 Patch: patch, // new patch 1658 Source: recordPullSource, 1659 },

··· 1091 Record: &lexutil.LexiconTypeDecoder{ 1092 Val: &tangled.RepoPull{ 1093 Title: title, 1094 + Target: &tangled.RepoPull_Target{ 1095 + Repo: string(f.RepoAt), 1096 + Branch: targetBranch, 1097 + }, 1098 Patch: patch, 1099 Source: recordPullSource, 1100 }, ··· 1654 Record: &lexutil.LexiconTypeDecoder{ 1655 Val: &tangled.RepoPull{ 1656 Title: pull.Title, 1657 + Target: &tangled.RepoPull_Target{ 1658 + Repo: string(f.RepoAt), 1659 + Branch: pull.TargetBranch, 1660 + }, 1661 Patch: patch, // new patch 1662 Source: recordPullSource, 1663 },

+1

cmd/gen.go

··· 47 tangled.RepoPull{}, 48 tangled.RepoPullComment{}, 49 tangled.RepoPull_Source{}, 0 50 tangled.RepoPullStatus{}, 51 tangled.Spindle{}, 52 tangled.SpindleMember{},

··· 47 tangled.RepoPull{}, 48 tangled.RepoPullComment{}, 49 tangled.RepoPull_Source{}, 50 + tangled.RepoPull_Target{}, 51 tangled.RepoPullStatus{}, 52 tangled.Spindle{}, 53 tangled.SpindleMember{},

+20 -8

lexicons/pulls/pull.json

··· 10 "record": { 11 "type": "object", 12 "required": [ 13 - "targetRepo", 14 - "targetBranch", 15 "title", 16 "patch", 17 "createdAt" 18 ], 19 "properties": { 20 - "targetRepo": { 21 - "type": "string", 22 - "format": "at-uri" 23 - }, 24 - "targetBranch": { 25 - "type": "string" 26 }, 27 "title": { 28 "type": "string" ··· 44 } 45 } 46 }, 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 47 "source": { 48 "type": "object", 49 "required": [

··· 10 "record": { 11 "type": "object", 12 "required": [ 13 + "target", 0 14 "title", 15 "patch", 16 "createdAt" 17 ], 18 "properties": { 19 + "target": { 20 + "type": "ref", 21 + "ref": "#target" 0 0 0 22 }, 23 "title": { 24 "type": "string" ··· 40 } 41 } 42 }, 43 + "target": { 44 + "type": "object", 45 + "required": [ 46 + "repo", 47 + "branch" 48 + ], 49 + "properties": { 50 + "repo": { 51 + "type": "string", 52 + "format": "at-uri" 53 + }, 54 + "branch": { 55 + "type": "string" 56 + } 57 + } 58 + }, 59 "source": { 60 "type": "object", 61 "required": [