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

+166 -64

api/tangled/cbor_gen.go

··· 6939 6939 6940 6940 return nil 6941 6941 } 6942 6942 + func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error { 6943 6943 + if t == nil { 6944 6944 + _, err := w.Write(cbg.CborNull) 6945 6945 + return err 6946 6946 + } 6947 6947 + 6948 6948 + cw := cbg.NewCborWriter(w) 6949 6949 + 6950 6950 + if _, err := cw.Write([]byte{162}); err != nil { 6951 6951 + return err 6952 6952 + } 6953 6953 + 6954 6954 + // t.Repo (string) (string) 6955 6955 + if len("repo") > 1000000 { 6956 6956 + return xerrors.Errorf("Value in field \"repo\" was too long") 6957 6957 + } 6958 6958 + 6959 6959 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6960 6960 + return err 6961 6961 + } 6962 6962 + if _, err := cw.WriteString(string("repo")); err != nil { 6963 6963 + return err 6964 6964 + } 6965 6965 + 6966 6966 + if len(t.Repo) > 1000000 { 6967 6967 + return xerrors.Errorf("Value in field t.Repo was too long") 6968 6968 + } 6969 6969 + 6970 6970 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6971 6971 + return err 6972 6972 + } 6973 6973 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 6974 6974 + return err 6975 6975 + } 6976 6976 + 6977 6977 + // t.Branch (string) (string) 6978 6978 + if len("branch") > 1000000 { 6979 6979 + return xerrors.Errorf("Value in field \"branch\" was too long") 6980 6980 + } 6981 6981 + 6982 6982 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6983 6983 + return err 6984 6984 + } 6985 6985 + if _, err := cw.WriteString(string("branch")); err != nil { 6986 6986 + return err 6987 6987 + } 6988 6988 + 6989 6989 + if len(t.Branch) > 1000000 { 6990 6990 + return xerrors.Errorf("Value in field t.Branch was too long") 6991 6991 + } 6992 6992 + 6993 6993 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6994 6994 + return err 6995 6995 + } 6996 6996 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 6997 6997 + return err 6998 6998 + } 6999 6999 + return nil 7000 7000 + } 7001 7001 + 7002 7002 + func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) { 7003 7003 + *t = RepoPull_Target{} 7004 7004 + 7005 7005 + cr := cbg.NewCborReader(r) 7006 7006 + 7007 7007 + maj, extra, err := cr.ReadHeader() 7008 7008 + if err != nil { 7009 7009 + return err 7010 7010 + } 7011 7011 + defer func() { 7012 7012 + if err == io.EOF { 7013 7013 + err = io.ErrUnexpectedEOF 7014 7014 + } 7015 7015 + }() 7016 7016 + 7017 7017 + if maj != cbg.MajMap { 7018 7018 + return fmt.Errorf("cbor input should be of type map") 7019 7019 + } 7020 7020 + 7021 7021 + if extra > cbg.MaxLength { 7022 7022 + return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra) 7023 7023 + } 7024 7024 + 7025 7025 + n := extra 7026 7026 + 7027 7027 + nameBuf := make([]byte, 6) 7028 7028 + for i := uint64(0); i < n; i++ { 7029 7029 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7030 7030 + if err != nil { 7031 7031 + return err 7032 7032 + } 7033 7033 + 7034 7034 + if !ok { 7035 7035 + // Field doesn't exist on this type, so ignore it 7036 7036 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7037 7037 + return err 7038 7038 + } 7039 7039 + continue 7040 7040 + } 7041 7041 + 7042 7042 + switch string(nameBuf[:nameLen]) { 7043 7043 + // t.Repo (string) (string) 7044 7044 + case "repo": 7045 7045 + 7046 7046 + { 7047 7047 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7048 7048 + if err != nil { 7049 7049 + return err 7050 7050 + } 7051 7051 + 7052 7052 + t.Repo = string(sval) 7053 7053 + } 7054 7054 + // t.Branch (string) (string) 7055 7055 + case "branch": 7056 7056 + 7057 7057 + { 7058 7058 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7059 7059 + if err != nil { 7060 7060 + return err 7061 7061 + } 7062 7062 + 7063 7063 + t.Branch = string(sval) 7064 7064 + } 7065 7065 + 7066 7066 + default: 7067 7067 + // Field doesn't exist on this type, so ignore it 7068 7068 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7069 7069 + return err 7070 7070 + } 7071 7071 + } 7072 7072 + } 7073 7073 + 7074 7074 + return nil 7075 7075 + } 6942 7076 func (t *RepoPull) MarshalCBOR(w io.Writer) error { 6943 7077 if t == nil { 6944 7078 _, err := w.Write(cbg.CborNull) ··· 6946 7080 } 6947 7081 6948 7082 cw := cbg.NewCborWriter(w) 6949 6949 - fieldCount := 8 7083 7083 + fieldCount := 7 6950 7084 6951 7085 if t.Body == nil { 6952 7086 fieldCount-- ··· 7076 7210 } 7077 7211 } 7078 7212 7079 7079 - // t.CreatedAt (string) (string) 7080 7080 - if len("createdAt") > 1000000 { 7081 7081 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 7213 7213 + // t.Target (tangled.RepoPull_Target) (struct) 7214 7214 + if len("target") > 1000000 { 7215 7215 + return xerrors.Errorf("Value in field \"target\" was too long") 7082 7216 } 7083 7217 7084 7084 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7218 7218 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil { 7085 7219 return err 7086 7220 } 7087 7087 - if _, err := cw.WriteString(string("createdAt")); err != nil { 7221 7221 + if _, err := cw.WriteString(string("target")); err != nil { 7088 7222 return err 7089 7223 } 7090 7224 7091 7091 - if len(t.CreatedAt) > 1000000 { 7092 7092 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 7093 7093 - } 7094 7094 - 7095 7095 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 7096 7096 - return err 7097 7097 - } 7098 7098 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7099 7099 - return err 7100 7100 - } 7101 7101 - 7102 7102 - // t.TargetRepo (string) (string) 7103 7103 - if len("targetRepo") > 1000000 { 7104 7104 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 7105 7105 - } 7106 7106 - 7107 7107 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 7108 7108 - return err 7109 7109 - } 7110 7110 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 7225 7225 + if err := t.Target.MarshalCBOR(cw); err != nil { 7111 7226 return err 7112 7227 } 7113 7228 7114 7114 - if len(t.TargetRepo) > 1000000 { 7115 7115 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 7116 7116 - } 7117 7117 - 7118 7118 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 7119 7119 - return err 7120 7120 - } 7121 7121 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 7122 7122 - return err 7123 7123 - } 7124 7124 - 7125 7125 - // t.TargetBranch (string) (string) 7126 7126 - if len("targetBranch") > 1000000 { 7127 7127 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 7229 7229 + // t.CreatedAt (string) (string) 7230 7230 + if len("createdAt") > 1000000 { 7231 7231 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 7128 7232 } 7129 7233 7130 7130 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 7234 7234 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7131 7235 return err 7132 7236 } 7133 7133 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 7237 7237 + if _, err := cw.WriteString(string("createdAt")); err != nil { 7134 7238 return err 7135 7239 } 7136 7240 7137 7137 - if len(t.TargetBranch) > 1000000 { 7138 7138 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 7241 7241 + if len(t.CreatedAt) > 1000000 { 7242 7242 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 7139 7243 } 7140 7244 7141 7141 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 7245 7245 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 7142 7246 return err 7143 7247 } 7144 7144 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 7248 7248 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7145 7249 return err 7146 7250 } 7147 7251 return nil ··· 7172 7276 7173 7277 n := extra 7174 7278 7175 7175 - nameBuf := make([]byte, 12) 7279 7279 + nameBuf := make([]byte, 9) 7176 7280 for i := uint64(0); i < n; i++ { 7177 7281 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7178 7282 if err != nil { ··· 7262 7366 } 7263 7367 7264 7368 } 7265 7265 - // t.CreatedAt (string) (string) 7266 7266 - case "createdAt": 7369 7369 + // t.Target (tangled.RepoPull_Target) (struct) 7370 7370 + case "target": 7267 7371 7268 7372 { 7269 7269 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7270 7270 - if err != nil { 7271 7271 - return err 7272 7272 - } 7273 7373 7274 7274 - t.CreatedAt = string(sval) 7275 7275 - } 7276 7276 - // t.TargetRepo (string) (string) 7277 7277 - case "targetRepo": 7278 7278 - 7279 7279 - { 7280 7280 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7374 7374 + b, err := cr.ReadByte() 7281 7375 if err != nil { 7282 7376 return err 7283 7377 } 7378 7378 + if b != cbg.CborNull[0] { 7379 7379 + if err := cr.UnreadByte(); err != nil { 7380 7380 + return err 7381 7381 + } 7382 7382 + t.Target = new(RepoPull_Target) 7383 7383 + if err := t.Target.UnmarshalCBOR(cr); err != nil { 7384 7384 + return xerrors.Errorf("unmarshaling t.Target pointer: %w", err) 7385 7385 + } 7386 7386 + } 7284 7387 7285 7285 - t.TargetRepo = string(sval) 7286 7388 } 7287 7287 - // t.TargetBranch (string) (string) 7288 7288 - case "targetBranch": 7389 7389 + // t.CreatedAt (string) (string) 7390 7390 + case "createdAt": 7289 7391 7290 7392 { 7291 7393 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 7293 7395 return err 7294 7396 } 7295 7397 7296 7296 - t.TargetBranch = string(sval) 7398 7398 + t.CreatedAt = string(sval) 7297 7399 } 7298 7400 7299 7401 default:

+7 -2

api/tangled/repopull.go

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

+4 -2

appview/db/pulls.go

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

+8 -4

appview/pulls/pulls.go

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

+1

cmd/gen.go

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

+20 -8

lexicons/pulls/pull.json

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