+3717 -1115

api/tangled/cbor_gen.go

··· 19 19 var _ = math.E 20 20 var _ = sort.Sort 21 21 22 22 + func (t *ActorProfile) MarshalCBOR(w io.Writer) error { 23 23 + if t == nil { 24 24 + _, err := w.Write(cbg.CborNull) 25 25 + return err 26 26 + } 27 27 + 28 28 + cw := cbg.NewCborWriter(w) 29 29 + fieldCount := 7 30 30 + 31 31 + if t.Description == nil { 32 32 + fieldCount-- 33 33 + } 34 34 + 35 35 + if t.Links == nil { 36 36 + fieldCount-- 37 37 + } 38 38 + 39 39 + if t.Location == nil { 40 40 + fieldCount-- 41 41 + } 42 42 + 43 43 + if t.PinnedRepositories == nil { 44 44 + fieldCount-- 45 45 + } 46 46 + 47 47 + if t.Stats == nil { 48 48 + fieldCount-- 49 49 + } 50 50 + 51 51 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 52 52 + return err 53 53 + } 54 54 + 55 55 + // t.LexiconTypeID (string) (string) 56 56 + if len("$type") > 1000000 { 57 57 + return xerrors.Errorf("Value in field \"$type\" was too long") 58 58 + } 59 59 + 60 60 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 61 61 + return err 62 62 + } 63 63 + if _, err := cw.WriteString(string("$type")); err != nil { 64 64 + return err 65 65 + } 66 66 + 67 67 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil { 68 68 + return err 69 69 + } 70 70 + if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil { 71 71 + return err 72 72 + } 73 73 + 74 74 + // t.Links ([]string) (slice) 75 75 + if t.Links != nil { 76 76 + 77 77 + if len("links") > 1000000 { 78 78 + return xerrors.Errorf("Value in field \"links\" was too long") 79 79 + } 80 80 + 81 81 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil { 82 82 + return err 83 83 + } 84 84 + if _, err := cw.WriteString(string("links")); err != nil { 85 85 + return err 86 86 + } 87 87 + 88 88 + if len(t.Links) > 8192 { 89 89 + return xerrors.Errorf("Slice value in field t.Links was too long") 90 90 + } 91 91 + 92 92 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil { 93 93 + return err 94 94 + } 95 95 + for _, v := range t.Links { 96 96 + if len(v) > 1000000 { 97 97 + return xerrors.Errorf("Value in field v was too long") 98 98 + } 99 99 + 100 100 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 101 101 + return err 102 102 + } 103 103 + if _, err := cw.WriteString(string(v)); err != nil { 104 104 + return err 105 105 + } 106 106 + 107 107 + } 108 108 + } 109 109 + 110 110 + // t.Stats ([]string) (slice) 111 111 + if t.Stats != nil { 112 112 + 113 113 + if len("stats") > 1000000 { 114 114 + return xerrors.Errorf("Value in field \"stats\" was too long") 115 115 + } 116 116 + 117 117 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil { 118 118 + return err 119 119 + } 120 120 + if _, err := cw.WriteString(string("stats")); err != nil { 121 121 + return err 122 122 + } 123 123 + 124 124 + if len(t.Stats) > 8192 { 125 125 + return xerrors.Errorf("Slice value in field t.Stats was too long") 126 126 + } 127 127 + 128 128 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil { 129 129 + return err 130 130 + } 131 131 + for _, v := range t.Stats { 132 132 + if len(v) > 1000000 { 133 133 + return xerrors.Errorf("Value in field v was too long") 134 134 + } 135 135 + 136 136 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 137 137 + return err 138 138 + } 139 139 + if _, err := cw.WriteString(string(v)); err != nil { 140 140 + return err 141 141 + } 142 142 + 143 143 + } 144 144 + } 145 145 + 146 146 + // t.Bluesky (bool) (bool) 147 147 + if len("bluesky") > 1000000 { 148 148 + return xerrors.Errorf("Value in field \"bluesky\" was too long") 149 149 + } 150 150 + 151 151 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil { 152 152 + return err 153 153 + } 154 154 + if _, err := cw.WriteString(string("bluesky")); err != nil { 155 155 + return err 156 156 + } 157 157 + 158 158 + if err := cbg.WriteBool(w, t.Bluesky); err != nil { 159 159 + return err 160 160 + } 161 161 + 162 162 + // t.Location (string) (string) 163 163 + if t.Location != nil { 164 164 + 165 165 + if len("location") > 1000000 { 166 166 + return xerrors.Errorf("Value in field \"location\" was too long") 167 167 + } 168 168 + 169 169 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil { 170 170 + return err 171 171 + } 172 172 + if _, err := cw.WriteString(string("location")); err != nil { 173 173 + return err 174 174 + } 175 175 + 176 176 + if t.Location == nil { 177 177 + if _, err := cw.Write(cbg.CborNull); err != nil { 178 178 + return err 179 179 + } 180 180 + } else { 181 181 + if len(*t.Location) > 1000000 { 182 182 + return xerrors.Errorf("Value in field t.Location was too long") 183 183 + } 184 184 + 185 185 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil { 186 186 + return err 187 187 + } 188 188 + if _, err := cw.WriteString(string(*t.Location)); err != nil { 189 189 + return err 190 190 + } 191 191 + } 192 192 + } 193 193 + 194 194 + // t.Description (string) (string) 195 195 + if t.Description != nil { 196 196 + 197 197 + if len("description") > 1000000 { 198 198 + return xerrors.Errorf("Value in field \"description\" was too long") 199 199 + } 200 200 + 201 201 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 202 202 + return err 203 203 + } 204 204 + if _, err := cw.WriteString(string("description")); err != nil { 205 205 + return err 206 206 + } 207 207 + 208 208 + if t.Description == nil { 209 209 + if _, err := cw.Write(cbg.CborNull); err != nil { 210 210 + return err 211 211 + } 212 212 + } else { 213 213 + if len(*t.Description) > 1000000 { 214 214 + return xerrors.Errorf("Value in field t.Description was too long") 215 215 + } 216 216 + 217 217 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 218 218 + return err 219 219 + } 220 220 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 221 221 + return err 222 222 + } 223 223 + } 224 224 + } 225 225 + 226 226 + // t.PinnedRepositories ([]string) (slice) 227 227 + if t.PinnedRepositories != nil { 228 228 + 229 229 + if len("pinnedRepositories") > 1000000 { 230 230 + return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long") 231 231 + } 232 232 + 233 233 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil { 234 234 + return err 235 235 + } 236 236 + if _, err := cw.WriteString(string("pinnedRepositories")); err != nil { 237 237 + return err 238 238 + } 239 239 + 240 240 + if len(t.PinnedRepositories) > 8192 { 241 241 + return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long") 242 242 + } 243 243 + 244 244 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil { 245 245 + return err 246 246 + } 247 247 + for _, v := range t.PinnedRepositories { 248 248 + if len(v) > 1000000 { 249 249 + return xerrors.Errorf("Value in field v was too long") 250 250 + } 251 251 + 252 252 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 253 253 + return err 254 254 + } 255 255 + if _, err := cw.WriteString(string(v)); err != nil { 256 256 + return err 257 257 + } 258 258 + 259 259 + } 260 260 + } 261 261 + return nil 262 262 + } 263 263 + 264 264 + func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) { 265 265 + *t = ActorProfile{} 266 266 + 267 267 + cr := cbg.NewCborReader(r) 268 268 + 269 269 + maj, extra, err := cr.ReadHeader() 270 270 + if err != nil { 271 271 + return err 272 272 + } 273 273 + defer func() { 274 274 + if err == io.EOF { 275 275 + err = io.ErrUnexpectedEOF 276 276 + } 277 277 + }() 278 278 + 279 279 + if maj != cbg.MajMap { 280 280 + return fmt.Errorf("cbor input should be of type map") 281 281 + } 282 282 + 283 283 + if extra > cbg.MaxLength { 284 284 + return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 285 285 + } 286 286 + 287 287 + n := extra 288 288 + 289 289 + nameBuf := make([]byte, 18) 290 290 + for i := uint64(0); i < n; i++ { 291 291 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 292 292 + if err != nil { 293 293 + return err 294 294 + } 295 295 + 296 296 + if !ok { 297 297 + // Field doesn't exist on this type, so ignore it 298 298 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 299 299 + return err 300 300 + } 301 301 + continue 302 302 + } 303 303 + 304 304 + switch string(nameBuf[:nameLen]) { 305 305 + // t.LexiconTypeID (string) (string) 306 306 + case "$type": 307 307 + 308 308 + { 309 309 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 310 310 + if err != nil { 311 311 + return err 312 312 + } 313 313 + 314 314 + t.LexiconTypeID = string(sval) 315 315 + } 316 316 + // t.Links ([]string) (slice) 317 317 + case "links": 318 318 + 319 319 + maj, extra, err = cr.ReadHeader() 320 320 + if err != nil { 321 321 + return err 322 322 + } 323 323 + 324 324 + if extra > 8192 { 325 325 + return fmt.Errorf("t.Links: array too large (%d)", extra) 326 326 + } 327 327 + 328 328 + if maj != cbg.MajArray { 329 329 + return fmt.Errorf("expected cbor array") 330 330 + } 331 331 + 332 332 + if extra > 0 { 333 333 + t.Links = make([]string, extra) 334 334 + } 335 335 + 336 336 + for i := 0; i < int(extra); i++ { 337 337 + { 338 338 + var maj byte 339 339 + var extra uint64 340 340 + var err error 341 341 + _ = maj 342 342 + _ = extra 343 343 + _ = err 344 344 + 345 345 + { 346 346 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 347 347 + if err != nil { 348 348 + return err 349 349 + } 350 350 + 351 351 + t.Links[i] = string(sval) 352 352 + } 353 353 + 354 354 + } 355 355 + } 356 356 + // t.Stats ([]string) (slice) 357 357 + case "stats": 358 358 + 359 359 + maj, extra, err = cr.ReadHeader() 360 360 + if err != nil { 361 361 + return err 362 362 + } 363 363 + 364 364 + if extra > 8192 { 365 365 + return fmt.Errorf("t.Stats: array too large (%d)", extra) 366 366 + } 367 367 + 368 368 + if maj != cbg.MajArray { 369 369 + return fmt.Errorf("expected cbor array") 370 370 + } 371 371 + 372 372 + if extra > 0 { 373 373 + t.Stats = make([]string, extra) 374 374 + } 375 375 + 376 376 + for i := 0; i < int(extra); i++ { 377 377 + { 378 378 + var maj byte 379 379 + var extra uint64 380 380 + var err error 381 381 + _ = maj 382 382 + _ = extra 383 383 + _ = err 384 384 + 385 385 + { 386 386 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 387 387 + if err != nil { 388 388 + return err 389 389 + } 390 390 + 391 391 + t.Stats[i] = string(sval) 392 392 + } 393 393 + 394 394 + } 395 395 + } 396 396 + // t.Bluesky (bool) (bool) 397 397 + case "bluesky": 398 398 + 399 399 + maj, extra, err = cr.ReadHeader() 400 400 + if err != nil { 401 401 + return err 402 402 + } 403 403 + if maj != cbg.MajOther { 404 404 + return fmt.Errorf("booleans must be major type 7") 405 405 + } 406 406 + switch extra { 407 407 + case 20: 408 408 + t.Bluesky = false 409 409 + case 21: 410 410 + t.Bluesky = true 411 411 + default: 412 412 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 413 413 + } 414 414 + // t.Location (string) (string) 415 415 + case "location": 416 416 + 417 417 + { 418 418 + b, err := cr.ReadByte() 419 419 + if err != nil { 420 420 + return err 421 421 + } 422 422 + if b != cbg.CborNull[0] { 423 423 + if err := cr.UnreadByte(); err != nil { 424 424 + return err 425 425 + } 426 426 + 427 427 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 428 428 + if err != nil { 429 429 + return err 430 430 + } 431 431 + 432 432 + t.Location = (*string)(&sval) 433 433 + } 434 434 + } 435 435 + // t.Description (string) (string) 436 436 + case "description": 437 437 + 438 438 + { 439 439 + b, err := cr.ReadByte() 440 440 + if err != nil { 441 441 + return err 442 442 + } 443 443 + if b != cbg.CborNull[0] { 444 444 + if err := cr.UnreadByte(); err != nil { 445 445 + return err 446 446 + } 447 447 + 448 448 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 449 449 + if err != nil { 450 450 + return err 451 451 + } 452 452 + 453 453 + t.Description = (*string)(&sval) 454 454 + } 455 455 + } 456 456 + // t.PinnedRepositories ([]string) (slice) 457 457 + case "pinnedRepositories": 458 458 + 459 459 + maj, extra, err = cr.ReadHeader() 460 460 + if err != nil { 461 461 + return err 462 462 + } 463 463 + 464 464 + if extra > 8192 { 465 465 + return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra) 466 466 + } 467 467 + 468 468 + if maj != cbg.MajArray { 469 469 + return fmt.Errorf("expected cbor array") 470 470 + } 471 471 + 472 472 + if extra > 0 { 473 473 + t.PinnedRepositories = make([]string, extra) 474 474 + } 475 475 + 476 476 + for i := 0; i < int(extra); i++ { 477 477 + { 478 478 + var maj byte 479 479 + var extra uint64 480 480 + var err error 481 481 + _ = maj 482 482 + _ = extra 483 483 + _ = err 484 484 + 485 485 + { 486 486 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 487 487 + if err != nil { 488 488 + return err 489 489 + } 490 490 + 491 491 + t.PinnedRepositories[i] = string(sval) 492 492 + } 493 493 + 494 494 + } 495 495 + } 496 496 + 497 497 + default: 498 498 + // Field doesn't exist on this type, so ignore it 499 499 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 500 500 + return err 501 501 + } 502 502 + } 503 503 + } 504 504 + 505 505 + return nil 506 506 + } 22 507 func (t *FeedStar) MarshalCBOR(w io.Writer) error { 23 508 if t == nil { 24 509 _, err := w.Write(cbg.CborNull) ··· 183 668 184 669 return nil 185 670 } 671 671 + func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { 672 672 + if t == nil { 673 673 + _, err := w.Write(cbg.CborNull) 674 674 + return err 675 675 + } 676 676 + 677 677 + cw := cbg.NewCborWriter(w) 678 678 + 679 679 + if _, err := cw.Write([]byte{167}); err != nil { 680 680 + return err 681 681 + } 682 682 + 683 683 + // t.Ref (string) (string) 684 684 + if len("ref") > 1000000 { 685 685 + return xerrors.Errorf("Value in field \"ref\" was too long") 686 686 + } 687 687 + 688 688 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 689 689 + return err 690 690 + } 691 691 + if _, err := cw.WriteString(string("ref")); err != nil { 692 692 + return err 693 693 + } 694 694 + 695 695 + if len(t.Ref) > 1000000 { 696 696 + return xerrors.Errorf("Value in field t.Ref was too long") 697 697 + } 698 698 + 699 699 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 700 700 + return err 701 701 + } 702 702 + if _, err := cw.WriteString(string(t.Ref)); err != nil { 703 703 + return err 704 704 + } 705 705 + 706 706 + // t.LexiconTypeID (string) (string) 707 707 + if len("$type") > 1000000 { 708 708 + return xerrors.Errorf("Value in field \"$type\" was too long") 709 709 + } 710 710 + 711 711 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 712 712 + return err 713 713 + } 714 714 + if _, err := cw.WriteString(string("$type")); err != nil { 715 715 + return err 716 716 + } 717 717 + 718 718 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil { 719 719 + return err 720 720 + } 721 721 + if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil { 722 722 + return err 723 723 + } 724 724 + 725 725 + // t.NewSha (string) (string) 726 726 + if len("newSha") > 1000000 { 727 727 + return xerrors.Errorf("Value in field \"newSha\" was too long") 728 728 + } 729 729 + 730 730 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 731 731 + return err 732 732 + } 733 733 + if _, err := cw.WriteString(string("newSha")); err != nil { 734 734 + return err 735 735 + } 736 736 + 737 737 + if len(t.NewSha) > 1000000 { 738 738 + return xerrors.Errorf("Value in field t.NewSha was too long") 739 739 + } 740 740 + 741 741 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 742 742 + return err 743 743 + } 744 744 + if _, err := cw.WriteString(string(t.NewSha)); err != nil { 745 745 + return err 746 746 + } 747 747 + 748 748 + // t.OldSha (string) (string) 749 749 + if len("oldSha") > 1000000 { 750 750 + return xerrors.Errorf("Value in field \"oldSha\" was too long") 751 751 + } 752 752 + 753 753 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 754 754 + return err 755 755 + } 756 756 + if _, err := cw.WriteString(string("oldSha")); err != nil { 757 757 + return err 758 758 + } 759 759 + 760 760 + if len(t.OldSha) > 1000000 { 761 761 + return xerrors.Errorf("Value in field t.OldSha was too long") 762 762 + } 763 763 + 764 764 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 765 765 + return err 766 766 + } 767 767 + if _, err := cw.WriteString(string(t.OldSha)); err != nil { 768 768 + return err 769 769 + } 770 770 + 771 771 + // t.RepoDid (string) (string) 772 772 + if len("repoDid") > 1000000 { 773 773 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 774 774 + } 775 775 + 776 776 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 777 777 + return err 778 778 + } 779 779 + if _, err := cw.WriteString(string("repoDid")); err != nil { 780 780 + return err 781 781 + } 782 782 + 783 783 + if len(t.RepoDid) > 1000000 { 784 784 + return xerrors.Errorf("Value in field t.RepoDid was too long") 785 785 + } 786 786 + 787 787 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 788 788 + return err 789 789 + } 790 790 + if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 791 791 + return err 792 792 + } 793 793 + 794 794 + // t.RepoName (string) (string) 795 795 + if len("repoName") > 1000000 { 796 796 + return xerrors.Errorf("Value in field \"repoName\" was too long") 797 797 + } 798 798 + 799 799 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil { 800 800 + return err 801 801 + } 802 802 + if _, err := cw.WriteString(string("repoName")); err != nil { 803 803 + return err 804 804 + } 805 805 + 806 806 + if len(t.RepoName) > 1000000 { 807 807 + return xerrors.Errorf("Value in field t.RepoName was too long") 808 808 + } 809 809 + 810 810 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil { 811 811 + return err 812 812 + } 813 813 + if _, err := cw.WriteString(string(t.RepoName)); err != nil { 814 814 + return err 815 815 + } 816 816 + 817 817 + // t.CommitterDid (string) (string) 818 818 + if len("committerDid") > 1000000 { 819 819 + return xerrors.Errorf("Value in field \"committerDid\" was too long") 820 820 + } 821 821 + 822 822 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 823 823 + return err 824 824 + } 825 825 + if _, err := cw.WriteString(string("committerDid")); err != nil { 826 826 + return err 827 827 + } 828 828 + 829 829 + if len(t.CommitterDid) > 1000000 { 830 830 + return xerrors.Errorf("Value in field t.CommitterDid was too long") 831 831 + } 832 832 + 833 833 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 834 834 + return err 835 835 + } 836 836 + if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 837 837 + return err 838 838 + } 839 839 + return nil 840 840 + } 841 841 + 842 842 + func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 843 843 + *t = GitRefUpdate{} 844 844 + 845 845 + cr := cbg.NewCborReader(r) 846 846 + 847 847 + maj, extra, err := cr.ReadHeader() 848 848 + if err != nil { 849 849 + return err 850 850 + } 851 851 + defer func() { 852 852 + if err == io.EOF { 853 853 + err = io.ErrUnexpectedEOF 854 854 + } 855 855 + }() 856 856 + 857 857 + if maj != cbg.MajMap { 858 858 + return fmt.Errorf("cbor input should be of type map") 859 859 + } 860 860 + 861 861 + if extra > cbg.MaxLength { 862 862 + return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra) 863 863 + } 864 864 + 865 865 + n := extra 866 866 + 867 867 + nameBuf := make([]byte, 12) 868 868 + for i := uint64(0); i < n; i++ { 869 869 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 870 870 + if err != nil { 871 871 + return err 872 872 + } 873 873 + 874 874 + if !ok { 875 875 + // Field doesn't exist on this type, so ignore it 876 876 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 877 877 + return err 878 878 + } 879 879 + continue 880 880 + } 881 881 + 882 882 + switch string(nameBuf[:nameLen]) { 883 883 + // t.Ref (string) (string) 884 884 + case "ref": 885 885 + 886 886 + { 887 887 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 888 888 + if err != nil { 889 889 + return err 890 890 + } 891 891 + 892 892 + t.Ref = string(sval) 893 893 + } 894 894 + // t.LexiconTypeID (string) (string) 895 895 + case "$type": 896 896 + 897 897 + { 898 898 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 899 899 + if err != nil { 900 900 + return err 901 901 + } 902 902 + 903 903 + t.LexiconTypeID = string(sval) 904 904 + } 905 905 + // t.NewSha (string) (string) 906 906 + case "newSha": 907 907 + 908 908 + { 909 909 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 910 910 + if err != nil { 911 911 + return err 912 912 + } 913 913 + 914 914 + t.NewSha = string(sval) 915 915 + } 916 916 + // t.OldSha (string) (string) 917 917 + case "oldSha": 918 918 + 919 919 + { 920 920 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 921 921 + if err != nil { 922 922 + return err 923 923 + } 924 924 + 925 925 + t.OldSha = string(sval) 926 926 + } 927 927 + // t.RepoDid (string) (string) 928 928 + case "repoDid": 929 929 + 930 930 + { 931 931 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 932 932 + if err != nil { 933 933 + return err 934 934 + } 935 935 + 936 936 + t.RepoDid = string(sval) 937 937 + } 938 938 + // t.RepoName (string) (string) 939 939 + case "repoName": 940 940 + 941 941 + { 942 942 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 943 943 + if err != nil { 944 944 + return err 945 945 + } 946 946 + 947 947 + t.RepoName = string(sval) 948 948 + } 949 949 + // t.CommitterDid (string) (string) 950 950 + case "committerDid": 951 951 + 952 952 + { 953 953 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 954 954 + if err != nil { 955 955 + return err 956 956 + } 957 957 + 958 958 + t.CommitterDid = string(sval) 959 959 + } 960 960 + 961 961 + default: 962 962 + // Field doesn't exist on this type, so ignore it 963 963 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 964 964 + return err 965 965 + } 966 966 + } 967 967 + } 968 968 + 969 969 + return nil 970 970 + } 186 971 func (t *GraphFollow) MarshalCBOR(w io.Writer) error { 187 972 if t == nil { 188 973 _, err := w.Write(cbg.CborNull) ··· 545 1330 546 1331 return nil 547 1332 } 548 548 - func (t *PublicKey) MarshalCBOR(w io.Writer) error { 1333 1333 + func (t *Pipeline) MarshalCBOR(w io.Writer) error { 549 1334 if t == nil { 550 1335 _, err := w.Write(cbg.CborNull) 551 1336 return err ··· 553 1338 554 1339 cw := cbg.NewCborWriter(w) 555 1340 556 556 - if _, err := cw.Write([]byte{164}); err != nil { 1341 1341 + if _, err := cw.Write([]byte{163}); err != nil { 1342 1342 + return err 1343 1343 + } 1344 1344 + 1345 1345 + // t.LexiconTypeID (string) (string) 1346 1346 + if len("$type") > 1000000 { 1347 1347 + return xerrors.Errorf("Value in field \"$type\" was too long") 1348 1348 + } 1349 1349 + 1350 1350 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1351 1351 + return err 1352 1352 + } 1353 1353 + if _, err := cw.WriteString(string("$type")); err != nil { 1354 1354 + return err 1355 1355 + } 1356 1356 + 1357 1357 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { 1358 1358 + return err 1359 1359 + } 1360 1360 + if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { 557 1361 return err 558 1362 } 559 1363 560 560 - // t.Key (string) (string) 561 561 - if len("key") > 1000000 { 562 562 - return xerrors.Errorf("Value in field \"key\" was too long") 1364 1364 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 1365 1365 + if len("workflows") > 1000000 { 1366 1366 + return xerrors.Errorf("Value in field \"workflows\" was too long") 563 1367 } 564 1368 565 565 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 1369 1369 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { 1370 1370 + return err 1371 1371 + } 1372 1372 + if _, err := cw.WriteString(string("workflows")); err != nil { 566 1373 return err 567 1374 } 568 568 - if _, err := cw.WriteString(string("key")); err != nil { 1375 1375 + 1376 1376 + if len(t.Workflows) > 8192 { 1377 1377 + return xerrors.Errorf("Slice value in field t.Workflows was too long") 1378 1378 + } 1379 1379 + 1380 1380 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { 569 1381 return err 570 1382 } 1383 1383 + for _, v := range t.Workflows { 1384 1384 + if err := v.MarshalCBOR(cw); err != nil { 1385 1385 + return err 1386 1386 + } 571 1387 572 572 - if len(t.Key) > 1000000 { 573 573 - return xerrors.Errorf("Value in field t.Key was too long") 1388 1388 + } 1389 1389 + 1390 1390 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 1391 1391 + if len("triggerMetadata") > 1000000 { 1392 1392 + return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") 1393 1393 + } 1394 1394 + 1395 1395 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { 1396 1396 + return err 1397 1397 + } 1398 1398 + if _, err := cw.WriteString(string("triggerMetadata")); err != nil { 1399 1399 + return err 574 1400 } 575 1401 576 576 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 1402 1402 + if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { 577 1403 return err 578 1404 } 579 579 - if _, err := cw.WriteString(string(t.Key)); err != nil { 1405 1405 + return nil 1406 1406 + } 1407 1407 + 1408 1408 + func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { 1409 1409 + *t = Pipeline{} 1410 1410 + 1411 1411 + cr := cbg.NewCborReader(r) 1412 1412 + 1413 1413 + maj, extra, err := cr.ReadHeader() 1414 1414 + if err != nil { 1415 1415 + return err 1416 1416 + } 1417 1417 + defer func() { 1418 1418 + if err == io.EOF { 1419 1419 + err = io.ErrUnexpectedEOF 1420 1420 + } 1421 1421 + }() 1422 1422 + 1423 1423 + if maj != cbg.MajMap { 1424 1424 + return fmt.Errorf("cbor input should be of type map") 1425 1425 + } 1426 1426 + 1427 1427 + if extra > cbg.MaxLength { 1428 1428 + return fmt.Errorf("Pipeline: map struct too large (%d)", extra) 1429 1429 + } 1430 1430 + 1431 1431 + n := extra 1432 1432 + 1433 1433 + nameBuf := make([]byte, 15) 1434 1434 + for i := uint64(0); i < n; i++ { 1435 1435 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1436 1436 + if err != nil { 1437 1437 + return err 1438 1438 + } 1439 1439 + 1440 1440 + if !ok { 1441 1441 + // Field doesn't exist on this type, so ignore it 1442 1442 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1443 1443 + return err 1444 1444 + } 1445 1445 + continue 1446 1446 + } 1447 1447 + 1448 1448 + switch string(nameBuf[:nameLen]) { 1449 1449 + // t.LexiconTypeID (string) (string) 1450 1450 + case "$type": 1451 1451 + 1452 1452 + { 1453 1453 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1454 1454 + if err != nil { 1455 1455 + return err 1456 1456 + } 1457 1457 + 1458 1458 + t.LexiconTypeID = string(sval) 1459 1459 + } 1460 1460 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 1461 1461 + case "workflows": 1462 1462 + 1463 1463 + maj, extra, err = cr.ReadHeader() 1464 1464 + if err != nil { 1465 1465 + return err 1466 1466 + } 1467 1467 + 1468 1468 + if extra > 8192 { 1469 1469 + return fmt.Errorf("t.Workflows: array too large (%d)", extra) 1470 1470 + } 1471 1471 + 1472 1472 + if maj != cbg.MajArray { 1473 1473 + return fmt.Errorf("expected cbor array") 1474 1474 + } 1475 1475 + 1476 1476 + if extra > 0 { 1477 1477 + t.Workflows = make([]*Pipeline_Workflow, extra) 1478 1478 + } 1479 1479 + 1480 1480 + for i := 0; i < int(extra); i++ { 1481 1481 + { 1482 1482 + var maj byte 1483 1483 + var extra uint64 1484 1484 + var err error 1485 1485 + _ = maj 1486 1486 + _ = extra 1487 1487 + _ = err 1488 1488 + 1489 1489 + { 1490 1490 + 1491 1491 + b, err := cr.ReadByte() 1492 1492 + if err != nil { 1493 1493 + return err 1494 1494 + } 1495 1495 + if b != cbg.CborNull[0] { 1496 1496 + if err := cr.UnreadByte(); err != nil { 1497 1497 + return err 1498 1498 + } 1499 1499 + t.Workflows[i] = new(Pipeline_Workflow) 1500 1500 + if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { 1501 1501 + return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) 1502 1502 + } 1503 1503 + } 1504 1504 + 1505 1505 + } 1506 1506 + 1507 1507 + } 1508 1508 + } 1509 1509 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 1510 1510 + case "triggerMetadata": 1511 1511 + 1512 1512 + { 1513 1513 + 1514 1514 + b, err := cr.ReadByte() 1515 1515 + if err != nil { 1516 1516 + return err 1517 1517 + } 1518 1518 + if b != cbg.CborNull[0] { 1519 1519 + if err := cr.UnreadByte(); err != nil { 1520 1520 + return err 1521 1521 + } 1522 1522 + t.TriggerMetadata = new(Pipeline_TriggerMetadata) 1523 1523 + if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { 1524 1524 + return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) 1525 1525 + } 1526 1526 + } 1527 1527 + 1528 1528 + } 1529 1529 + 1530 1530 + default: 1531 1531 + // Field doesn't exist on this type, so ignore it 1532 1532 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1533 1533 + return err 1534 1534 + } 1535 1535 + } 1536 1536 + } 1537 1537 + 1538 1538 + return nil 1539 1539 + } 1540 1540 + func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error { 1541 1541 + if t == nil { 1542 1542 + _, err := w.Write(cbg.CborNull) 1543 1543 + return err 1544 1544 + } 1545 1545 + 1546 1546 + cw := cbg.NewCborWriter(w) 1547 1547 + 1548 1548 + if _, err := cw.Write([]byte{163}); err != nil { 1549 1549 + return err 1550 1550 + } 1551 1551 + 1552 1552 + // t.Skip (bool) (bool) 1553 1553 + if len("skip") > 1000000 { 1554 1554 + return xerrors.Errorf("Value in field \"skip\" was too long") 1555 1555 + } 1556 1556 + 1557 1557 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil { 1558 1558 + return err 1559 1559 + } 1560 1560 + if _, err := cw.WriteString(string("skip")); err != nil { 1561 1561 + return err 1562 1562 + } 1563 1563 + 1564 1564 + if err := cbg.WriteBool(w, t.Skip); err != nil { 1565 1565 + return err 1566 1566 + } 1567 1567 + 1568 1568 + // t.Depth (int64) (int64) 1569 1569 + if len("depth") > 1000000 { 1570 1570 + return xerrors.Errorf("Value in field \"depth\" was too long") 1571 1571 + } 1572 1572 + 1573 1573 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil { 1574 1574 + return err 1575 1575 + } 1576 1576 + if _, err := cw.WriteString(string("depth")); err != nil { 1577 1577 + return err 1578 1578 + } 1579 1579 + 1580 1580 + if t.Depth >= 0 { 1581 1581 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil { 1582 1582 + return err 1583 1583 + } 1584 1584 + } else { 1585 1585 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil { 1586 1586 + return err 1587 1587 + } 1588 1588 + } 1589 1589 + 1590 1590 + // t.Submodules (bool) (bool) 1591 1591 + if len("submodules") > 1000000 { 1592 1592 + return xerrors.Errorf("Value in field \"submodules\" was too long") 1593 1593 + } 1594 1594 + 1595 1595 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil { 1596 1596 + return err 1597 1597 + } 1598 1598 + if _, err := cw.WriteString(string("submodules")); err != nil { 1599 1599 + return err 1600 1600 + } 1601 1601 + 1602 1602 + if err := cbg.WriteBool(w, t.Submodules); err != nil { 1603 1603 + return err 1604 1604 + } 1605 1605 + return nil 1606 1606 + } 1607 1607 + 1608 1608 + func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { 1609 1609 + *t = Pipeline_CloneOpts{} 1610 1610 + 1611 1611 + cr := cbg.NewCborReader(r) 1612 1612 + 1613 1613 + maj, extra, err := cr.ReadHeader() 1614 1614 + if err != nil { 1615 1615 + return err 1616 1616 + } 1617 1617 + defer func() { 1618 1618 + if err == io.EOF { 1619 1619 + err = io.ErrUnexpectedEOF 1620 1620 + } 1621 1621 + }() 1622 1622 + 1623 1623 + if maj != cbg.MajMap { 1624 1624 + return fmt.Errorf("cbor input should be of type map") 1625 1625 + } 1626 1626 + 1627 1627 + if extra > cbg.MaxLength { 1628 1628 + return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra) 1629 1629 + } 1630 1630 + 1631 1631 + n := extra 1632 1632 + 1633 1633 + nameBuf := make([]byte, 10) 1634 1634 + for i := uint64(0); i < n; i++ { 1635 1635 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1636 1636 + if err != nil { 1637 1637 + return err 1638 1638 + } 1639 1639 + 1640 1640 + if !ok { 1641 1641 + // Field doesn't exist on this type, so ignore it 1642 1642 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1643 1643 + return err 1644 1644 + } 1645 1645 + continue 1646 1646 + } 1647 1647 + 1648 1648 + switch string(nameBuf[:nameLen]) { 1649 1649 + // t.Skip (bool) (bool) 1650 1650 + case "skip": 1651 1651 + 1652 1652 + maj, extra, err = cr.ReadHeader() 1653 1653 + if err != nil { 1654 1654 + return err 1655 1655 + } 1656 1656 + if maj != cbg.MajOther { 1657 1657 + return fmt.Errorf("booleans must be major type 7") 1658 1658 + } 1659 1659 + switch extra { 1660 1660 + case 20: 1661 1661 + t.Skip = false 1662 1662 + case 21: 1663 1663 + t.Skip = true 1664 1664 + default: 1665 1665 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 1666 1666 + } 1667 1667 + // t.Depth (int64) (int64) 1668 1668 + case "depth": 1669 1669 + { 1670 1670 + maj, extra, err := cr.ReadHeader() 1671 1671 + if err != nil { 1672 1672 + return err 1673 1673 + } 1674 1674 + var extraI int64 1675 1675 + switch maj { 1676 1676 + case cbg.MajUnsignedInt: 1677 1677 + extraI = int64(extra) 1678 1678 + if extraI < 0 { 1679 1679 + return fmt.Errorf("int64 positive overflow") 1680 1680 + } 1681 1681 + case cbg.MajNegativeInt: 1682 1682 + extraI = int64(extra) 1683 1683 + if extraI < 0 { 1684 1684 + return fmt.Errorf("int64 negative overflow") 1685 1685 + } 1686 1686 + extraI = -1 - extraI 1687 1687 + default: 1688 1688 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1689 1689 + } 1690 1690 + 1691 1691 + t.Depth = int64(extraI) 1692 1692 + } 1693 1693 + // t.Submodules (bool) (bool) 1694 1694 + case "submodules": 1695 1695 + 1696 1696 + maj, extra, err = cr.ReadHeader() 1697 1697 + if err != nil { 1698 1698 + return err 1699 1699 + } 1700 1700 + if maj != cbg.MajOther { 1701 1701 + return fmt.Errorf("booleans must be major type 7") 1702 1702 + } 1703 1703 + switch extra { 1704 1704 + case 20: 1705 1705 + t.Submodules = false 1706 1706 + case 21: 1707 1707 + t.Submodules = true 1708 1708 + default: 1709 1709 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 1710 1710 + } 1711 1711 + 1712 1712 + default: 1713 1713 + // Field doesn't exist on this type, so ignore it 1714 1714 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1715 1715 + return err 1716 1716 + } 1717 1717 + } 1718 1718 + } 1719 1719 + 1720 1720 + return nil 1721 1721 + } 1722 1722 + func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { 1723 1723 + if t == nil { 1724 1724 + _, err := w.Write(cbg.CborNull) 1725 1725 + return err 1726 1726 + } 1727 1727 + 1728 1728 + cw := cbg.NewCborWriter(w) 1729 1729 + 1730 1730 + if _, err := cw.Write([]byte{165}); err != nil { 580 1731 return err 581 1732 } 582 1733 ··· 603 1754 return err 604 1755 } 605 1756 606 606 - // t.LexiconTypeID (string) (string) 607 607 - if len("$type") > 1000000 { 608 608 - return xerrors.Errorf("Value in field \"$type\" was too long") 1757 1757 + // t.Clone (tangled.Pipeline_CloneOpts) (struct) 1758 1758 + if len("clone") > 1000000 { 1759 1759 + return xerrors.Errorf("Value in field \"clone\" was too long") 609 1760 } 610 1761 611 611 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1762 1762 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil { 1763 1763 + return err 1764 1764 + } 1765 1765 + if _, err := cw.WriteString(string("clone")); err != nil { 612 1766 return err 613 1767 } 614 614 - if _, err := cw.WriteString(string("$type")); err != nil { 1768 1768 + 1769 1769 + if err := t.Clone.MarshalCBOR(cw); err != nil { 615 1770 return err 616 1771 } 617 1772 618 618 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil { 1773 1773 + // t.Steps ([]*tangled.Pipeline_Step) (slice) 1774 1774 + if len("steps") > 1000000 { 1775 1775 + return xerrors.Errorf("Value in field \"steps\" was too long") 1776 1776 + } 1777 1777 + 1778 1778 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil { 619 1779 return err 620 1780 } 621 621 - if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil { 1781 1781 + if _, err := cw.WriteString(string("steps")); err != nil { 622 1782 return err 623 1783 } 624 1784 625 625 - // t.CreatedAt (string) (string) 626 626 - if len("createdAt") > 1000000 { 627 627 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 1785 1785 + if len(t.Steps) > 8192 { 1786 1786 + return xerrors.Errorf("Slice value in field t.Steps was too long") 628 1787 } 629 1788 630 630 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 1789 1789 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil { 631 1790 return err 632 1791 } 633 633 - if _, err := cw.WriteString(string("createdAt")); err != nil { 1792 1792 + for _, v := range t.Steps { 1793 1793 + if err := v.MarshalCBOR(cw); err != nil { 1794 1794 + return err 1795 1795 + } 1796 1796 + 1797 1797 + } 1798 1798 + 1799 1799 + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 1800 1800 + if len("environment") > 1000000 { 1801 1801 + return xerrors.Errorf("Value in field \"environment\" was too long") 1802 1802 + } 1803 1803 + 1804 1804 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil { 1805 1805 + return err 1806 1806 + } 1807 1807 + if _, err := cw.WriteString(string("environment")); err != nil { 634 1808 return err 635 1809 } 636 1810 637 637 - if len(t.CreatedAt) > 1000000 { 638 638 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 1811 1811 + if len(t.Environment) > 8192 { 1812 1812 + return xerrors.Errorf("Slice value in field t.Environment was too long") 639 1813 } 640 1814 641 641 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 1815 1815 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil { 642 1816 return err 643 1817 } 644 644 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 1818 1818 + for _, v := range t.Environment { 1819 1819 + if err := v.MarshalCBOR(cw); err != nil { 1820 1820 + return err 1821 1821 + } 1822 1822 + 1823 1823 + } 1824 1824 + 1825 1825 + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 1826 1826 + if len("dependencies") > 1000000 { 1827 1827 + return xerrors.Errorf("Value in field \"dependencies\" was too long") 1828 1828 + } 1829 1829 + 1830 1830 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil { 645 1831 return err 646 1832 } 1833 1833 + if _, err := cw.WriteString(string("dependencies")); err != nil { 1834 1834 + return err 1835 1835 + } 1836 1836 + 1837 1837 + if len(t.Dependencies) > 8192 { 1838 1838 + return xerrors.Errorf("Slice value in field t.Dependencies was too long") 1839 1839 + } 1840 1840 + 1841 1841 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil { 1842 1842 + return err 1843 1843 + } 1844 1844 + for _, v := range t.Dependencies { 1845 1845 + if err := v.MarshalCBOR(cw); err != nil { 1846 1846 + return err 1847 1847 + } 1848 1848 + 1849 1849 + } 647 1850 return nil 648 1851 } 649 1852 650 650 - func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) { 651 651 - *t = PublicKey{} 1853 1853 + func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { 1854 1854 + *t = Pipeline_Workflow{} 652 1855 653 1856 cr := cbg.NewCborReader(r) 654 1857 ··· 667 1870 } 668 1871 669 1872 if extra > cbg.MaxLength { 670 670 - return fmt.Errorf("PublicKey: map struct too large (%d)", extra) 1873 1873 + return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra) 671 1874 } 672 1875 673 1876 n := extra 674 1877 675 675 - nameBuf := make([]byte, 9) 1878 1878 + nameBuf := make([]byte, 12) 676 1879 for i := uint64(0); i < n; i++ { 677 1880 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 678 1881 if err != nil { ··· 688 1891 } 689 1892 690 1893 switch string(nameBuf[:nameLen]) { 691 691 - // t.Key (string) (string) 692 692 - case "key": 1894 1894 + // t.Name (string) (string) 1895 1895 + case "name": 693 1896 694 1897 { 695 1898 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 697 1900 return err 698 1901 } 699 1902 700 700 - t.Key = string(sval) 1903 1903 + t.Name = string(sval) 701 1904 } 702 702 - // t.Name (string) (string) 703 703 - case "name": 1905 1905 + // t.Clone (tangled.Pipeline_CloneOpts) (struct) 1906 1906 + case "clone": 704 1907 705 1908 { 706 706 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1909 1909 + 1910 1910 + b, err := cr.ReadByte() 707 1911 if err != nil { 708 1912 return err 709 1913 } 1914 1914 + if b != cbg.CborNull[0] { 1915 1915 + if err := cr.UnreadByte(); err != nil { 1916 1916 + return err 1917 1917 + } 1918 1918 + t.Clone = new(Pipeline_CloneOpts) 1919 1919 + if err := t.Clone.UnmarshalCBOR(cr); err != nil { 1920 1920 + return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err) 1921 1921 + } 1922 1922 + } 710 1923 711 711 - t.Name = string(sval) 1924 1924 + } 1925 1925 + // t.Steps ([]*tangled.Pipeline_Step) (slice) 1926 1926 + case "steps": 1927 1927 + 1928 1928 + maj, extra, err = cr.ReadHeader() 1929 1929 + if err != nil { 1930 1930 + return err 1931 1931 + } 1932 1932 + 1933 1933 + if extra > 8192 { 1934 1934 + return fmt.Errorf("t.Steps: array too large (%d)", extra) 1935 1935 + } 1936 1936 + 1937 1937 + if maj != cbg.MajArray { 1938 1938 + return fmt.Errorf("expected cbor array") 712 1939 } 713 713 - // t.LexiconTypeID (string) (string) 714 714 - case "$type": 1940 1940 + 1941 1941 + if extra > 0 { 1942 1942 + t.Steps = make([]*Pipeline_Step, extra) 1943 1943 + } 1944 1944 + 1945 1945 + for i := 0; i < int(extra); i++ { 1946 1946 + { 1947 1947 + var maj byte 1948 1948 + var extra uint64 1949 1949 + var err error 1950 1950 + _ = maj 1951 1951 + _ = extra 1952 1952 + _ = err 1953 1953 + 1954 1954 + { 1955 1955 + 1956 1956 + b, err := cr.ReadByte() 1957 1957 + if err != nil { 1958 1958 + return err 1959 1959 + } 1960 1960 + if b != cbg.CborNull[0] { 1961 1961 + if err := cr.UnreadByte(); err != nil { 1962 1962 + return err 1963 1963 + } 1964 1964 + t.Steps[i] = new(Pipeline_Step) 1965 1965 + if err := t.Steps[i].UnmarshalCBOR(cr); err != nil { 1966 1966 + return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err) 1967 1967 + } 1968 1968 + } 1969 1969 + 1970 1970 + } 715 1971 716 716 - { 717 717 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 718 718 - if err != nil { 719 719 - return err 720 1972 } 1973 1973 + } 1974 1974 + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 1975 1975 + case "environment": 721 1976 722 722 - t.LexiconTypeID = string(sval) 1977 1977 + maj, extra, err = cr.ReadHeader() 1978 1978 + if err != nil { 1979 1979 + return err 723 1980 } 724 724 - // t.CreatedAt (string) (string) 725 725 - case "createdAt": 726 1981 727 727 - { 728 728 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 729 729 - if err != nil { 730 730 - return err 1982 1982 + if extra > 8192 { 1983 1983 + return fmt.Errorf("t.Environment: array too large (%d)", extra) 1984 1984 + } 1985 1985 + 1986 1986 + if maj != cbg.MajArray { 1987 1987 + return fmt.Errorf("expected cbor array") 1988 1988 + } 1989 1989 + 1990 1990 + if extra > 0 { 1991 1991 + t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) 1992 1992 + } 1993 1993 + 1994 1994 + for i := 0; i < int(extra); i++ { 1995 1995 + { 1996 1996 + var maj byte 1997 1997 + var extra uint64 1998 1998 + var err error 1999 1999 + _ = maj 2000 2000 + _ = extra 2001 2001 + _ = err 2002 2002 + 2003 2003 + { 2004 2004 + 2005 2005 + b, err := cr.ReadByte() 2006 2006 + if err != nil { 2007 2007 + return err 2008 2008 + } 2009 2009 + if b != cbg.CborNull[0] { 2010 2010 + if err := cr.UnreadByte(); err != nil { 2011 2011 + return err 2012 2012 + } 2013 2013 + t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) 2014 2014 + if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 2015 2015 + return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 2016 2016 + } 2017 2017 + } 2018 2018 + 2019 2019 + } 2020 2020 + 731 2021 } 2022 2022 + } 2023 2023 + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 2024 2024 + case "dependencies": 732 2025 733 733 - t.CreatedAt = string(sval) 2026 2026 + maj, extra, err = cr.ReadHeader() 2027 2027 + if err != nil { 2028 2028 + return err 2029 2029 + } 2030 2030 + 2031 2031 + if extra > 8192 { 2032 2032 + return fmt.Errorf("t.Dependencies: array too large (%d)", extra) 2033 2033 + } 2034 2034 + 2035 2035 + if maj != cbg.MajArray { 2036 2036 + return fmt.Errorf("expected cbor array") 2037 2037 + } 2038 2038 + 2039 2039 + if extra > 0 { 2040 2040 + t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) 2041 2041 + } 2042 2042 + 2043 2043 + for i := 0; i < int(extra); i++ { 2044 2044 + { 2045 2045 + var maj byte 2046 2046 + var extra uint64 2047 2047 + var err error 2048 2048 + _ = maj 2049 2049 + _ = extra 2050 2050 + _ = err 2051 2051 + 2052 2052 + { 2053 2053 + 2054 2054 + if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 2055 2055 + return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) 2056 2056 + } 2057 2057 + 2058 2058 + } 2059 2059 + 2060 2060 + } 734 2061 } 735 2062 736 2063 default: ··· 743 2070 744 2071 return nil 745 2072 } 746 746 - func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error { 2073 2073 + func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 747 2074 if t == nil { 748 2075 _, err := w.Write(cbg.CborNull) 749 2076 return err 750 2077 } 751 2078 752 2079 cw := cbg.NewCborWriter(w) 753 753 - fieldCount := 7 2080 2080 + 2081 2081 + if _, err := cw.Write([]byte{162}); err != nil { 2082 2082 + return err 2083 2083 + } 754 2084 755 755 - if t.CommentId == nil { 756 756 - fieldCount-- 2085 2085 + // t.Key (string) (string) 2086 2086 + if len("key") > 1000000 { 2087 2087 + return xerrors.Errorf("Value in field \"key\" was too long") 757 2088 } 758 2089 759 759 - if t.Owner == nil { 760 760 - fieldCount-- 2090 2090 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 2091 2091 + return err 2092 2092 + } 2093 2093 + if _, err := cw.WriteString(string("key")); err != nil { 2094 2094 + return err 761 2095 } 762 2096 763 763 - if t.Repo == nil { 764 764 - fieldCount-- 2097 2097 + if len(t.Key) > 1000000 { 2098 2098 + return xerrors.Errorf("Value in field t.Key was too long") 765 2099 } 766 2100 767 767 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2101 2101 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 2102 2102 + return err 2103 2103 + } 2104 2104 + if _, err := cw.WriteString(string(t.Key)); err != nil { 768 2105 return err 769 2106 } 770 2107 771 771 - // t.Body (string) (string) 772 772 - if len("body") > 1000000 { 773 773 - return xerrors.Errorf("Value in field \"body\" was too long") 2108 2108 + // t.Value (string) (string) 2109 2109 + if len("value") > 1000000 { 2110 2110 + return xerrors.Errorf("Value in field \"value\" was too long") 774 2111 } 775 2112 776 776 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 2113 2113 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 777 2114 return err 778 2115 } 779 779 - if _, err := cw.WriteString(string("body")); err != nil { 2116 2116 + if _, err := cw.WriteString(string("value")); err != nil { 780 2117 return err 781 2118 } 782 2119 783 783 - if len(t.Body) > 1000000 { 784 784 - return xerrors.Errorf("Value in field t.Body was too long") 2120 2120 + if len(t.Value) > 1000000 { 2121 2121 + return xerrors.Errorf("Value in field t.Value was too long") 785 2122 } 786 2123 787 787 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 2124 2124 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 788 2125 return err 789 2126 } 790 790 - if _, err := cw.WriteString(string(t.Body)); err != nil { 2127 2127 + if _, err := cw.WriteString(string(t.Value)); err != nil { 791 2128 return err 792 2129 } 2130 2130 + return nil 2131 2131 + } 793 2132 794 794 - // t.Repo (string) (string) 795 795 - if t.Repo != nil { 2133 2133 + func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2134 2134 + *t = Pipeline_Workflow_Environment_Elem{} 2135 2135 + 2136 2136 + cr := cbg.NewCborReader(r) 796 2137 797 797 - if len("repo") > 1000000 { 798 798 - return xerrors.Errorf("Value in field \"repo\" was too long") 2138 2138 + maj, extra, err := cr.ReadHeader() 2139 2139 + if err != nil { 2140 2140 + return err 2141 2141 + } 2142 2142 + defer func() { 2143 2143 + if err == io.EOF { 2144 2144 + err = io.ErrUnexpectedEOF 799 2145 } 2146 2146 + }() 800 2147 801 801 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 802 802 - return err 803 803 - } 804 804 - if _, err := cw.WriteString(string("repo")); err != nil { 2148 2148 + if maj != cbg.MajMap { 2149 2149 + return fmt.Errorf("cbor input should be of type map") 2150 2150 + } 2151 2151 + 2152 2152 + if extra > cbg.MaxLength { 2153 2153 + return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 2154 2154 + } 2155 2155 + 2156 2156 + n := extra 2157 2157 + 2158 2158 + nameBuf := make([]byte, 5) 2159 2159 + for i := uint64(0); i < n; i++ { 2160 2160 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2161 2161 + if err != nil { 805 2162 return err 806 2163 } 807 2164 808 808 - if t.Repo == nil { 809 809 - if _, err := cw.Write(cbg.CborNull); err != nil { 2165 2165 + if !ok { 2166 2166 + // Field doesn't exist on this type, so ignore it 2167 2167 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 810 2168 return err 811 2169 } 812 812 - } else { 813 813 - if len(*t.Repo) > 1000000 { 814 814 - return xerrors.Errorf("Value in field t.Repo was too long") 2170 2170 + continue 2171 2171 + } 2172 2172 + 2173 2173 + switch string(nameBuf[:nameLen]) { 2174 2174 + // t.Key (string) (string) 2175 2175 + case "key": 2176 2176 + 2177 2177 + { 2178 2178 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2179 2179 + if err != nil { 2180 2180 + return err 2181 2181 + } 2182 2182 + 2183 2183 + t.Key = string(sval) 815 2184 } 2185 2185 + // t.Value (string) (string) 2186 2186 + case "value": 816 2187 817 817 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 818 818 - return err 2188 2188 + { 2189 2189 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2190 2190 + if err != nil { 2191 2191 + return err 2192 2192 + } 2193 2193 + 2194 2194 + t.Value = string(sval) 819 2195 } 820 820 - if _, err := cw.WriteString(string(*t.Repo)); err != nil { 2196 2196 + 2197 2197 + default: 2198 2198 + // Field doesn't exist on this type, so ignore it 2199 2199 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 821 2200 return err 822 2201 } 823 2202 } 824 2203 } 825 2204 826 826 - // t.LexiconTypeID (string) (string) 827 827 - if len("$type") > 1000000 { 828 828 - return xerrors.Errorf("Value in field \"$type\" was too long") 2205 2205 + return nil 2206 2206 + } 2207 2207 + func (t *Pipeline_Dependencies_Elem) MarshalCBOR(w io.Writer) error { 2208 2208 + if t == nil { 2209 2209 + _, err := w.Write(cbg.CborNull) 2210 2210 + return err 829 2211 } 830 2212 831 831 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2213 2213 + cw := cbg.NewCborWriter(w) 2214 2214 + 2215 2215 + if _, err := cw.Write([]byte{162}); err != nil { 832 2216 return err 833 2217 } 834 834 - if _, err := cw.WriteString(string("$type")); err != nil { 2218 2218 + 2219 2219 + // t.Packages ([]string) (slice) 2220 2220 + if len("packages") > 1000000 { 2221 2221 + return xerrors.Errorf("Value in field \"packages\" was too long") 2222 2222 + } 2223 2223 + 2224 2224 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("packages"))); err != nil { 2225 2225 + return err 2226 2226 + } 2227 2227 + if _, err := cw.WriteString(string("packages")); err != nil { 835 2228 return err 836 2229 } 837 2230 838 838 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil { 2231 2231 + if len(t.Packages) > 8192 { 2232 2232 + return xerrors.Errorf("Slice value in field t.Packages was too long") 2233 2233 + } 2234 2234 + 2235 2235 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Packages))); err != nil { 839 2236 return err 840 2237 } 841 841 - if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil { 842 842 - return err 2238 2238 + for _, v := range t.Packages { 2239 2239 + if len(v) > 1000000 { 2240 2240 + return xerrors.Errorf("Value in field v was too long") 2241 2241 + } 2242 2242 + 2243 2243 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 2244 2244 + return err 2245 2245 + } 2246 2246 + if _, err := cw.WriteString(string(v)); err != nil { 2247 2247 + return err 2248 2248 + } 2249 2249 + 843 2250 } 844 2251 845 845 - // t.Issue (string) (string) 846 846 - if len("issue") > 1000000 { 847 847 - return xerrors.Errorf("Value in field \"issue\" was too long") 2252 2252 + // t.Registry (string) (string) 2253 2253 + if len("registry") > 1000000 { 2254 2254 + return xerrors.Errorf("Value in field \"registry\" was too long") 848 2255 } 849 2256 850 850 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 2257 2257 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("registry"))); err != nil { 851 2258 return err 852 2259 } 853 853 - if _, err := cw.WriteString(string("issue")); err != nil { 2260 2260 + if _, err := cw.WriteString(string("registry")); err != nil { 854 2261 return err 855 2262 } 856 2263 857 857 - if len(t.Issue) > 1000000 { 858 858 - return xerrors.Errorf("Value in field t.Issue was too long") 2264 2264 + if len(t.Registry) > 1000000 { 2265 2265 + return xerrors.Errorf("Value in field t.Registry was too long") 859 2266 } 860 2267 861 861 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 2268 2268 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Registry))); err != nil { 862 2269 return err 863 2270 } 864 864 - if _, err := cw.WriteString(string(t.Issue)); err != nil { 2271 2271 + if _, err := cw.WriteString(string(t.Registry)); err != nil { 865 2272 return err 866 2273 } 2274 2274 + return nil 2275 2275 + } 867 2276 868 868 - // t.Owner (string) (string) 869 869 - if t.Owner != nil { 2277 2277 + func (t *Pipeline_Dependencies_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2278 2278 + *t = Pipeline_Dependencies_Elem{} 2279 2279 + 2280 2280 + cr := cbg.NewCborReader(r) 870 2281 871 871 - if len("owner") > 1000000 { 872 872 - return xerrors.Errorf("Value in field \"owner\" was too long") 2282 2282 + maj, extra, err := cr.ReadHeader() 2283 2283 + if err != nil { 2284 2284 + return err 2285 2285 + } 2286 2286 + defer func() { 2287 2287 + if err == io.EOF { 2288 2288 + err = io.ErrUnexpectedEOF 873 2289 } 2290 2290 + }() 874 2291 875 875 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 2292 2292 + if maj != cbg.MajMap { 2293 2293 + return fmt.Errorf("cbor input should be of type map") 2294 2294 + } 2295 2295 + 2296 2296 + if extra > cbg.MaxLength { 2297 2297 + return fmt.Errorf("Pipeline_Dependencies_Elem: map struct too large (%d)", extra) 2298 2298 + } 2299 2299 + 2300 2300 + n := extra 2301 2301 + 2302 2302 + nameBuf := make([]byte, 8) 2303 2303 + for i := uint64(0); i < n; i++ { 2304 2304 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2305 2305 + if err != nil { 876 2306 return err 877 2307 } 878 878 - if _, err := cw.WriteString(string("owner")); err != nil { 879 879 - return err 2308 2308 + 2309 2309 + if !ok { 2310 2310 + // Field doesn't exist on this type, so ignore it 2311 2311 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2312 2312 + return err 2313 2313 + } 2314 2314 + continue 880 2315 } 881 2316 882 882 - if t.Owner == nil { 883 883 - if _, err := cw.Write(cbg.CborNull); err != nil { 2317 2317 + switch string(nameBuf[:nameLen]) { 2318 2318 + // t.Packages ([]string) (slice) 2319 2319 + case "packages": 2320 2320 + 2321 2321 + maj, extra, err = cr.ReadHeader() 2322 2322 + if err != nil { 884 2323 return err 885 2324 } 886 886 - } else { 887 887 - if len(*t.Owner) > 1000000 { 888 888 - return xerrors.Errorf("Value in field t.Owner was too long") 2325 2325 + 2326 2326 + if extra > 8192 { 2327 2327 + return fmt.Errorf("t.Packages: array too large (%d)", extra) 2328 2328 + } 2329 2329 + 2330 2330 + if maj != cbg.MajArray { 2331 2331 + return fmt.Errorf("expected cbor array") 889 2332 } 890 2333 891 891 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil { 892 892 - return err 2334 2334 + if extra > 0 { 2335 2335 + t.Packages = make([]string, extra) 893 2336 } 894 894 - if _, err := cw.WriteString(string(*t.Owner)); err != nil { 2337 2337 + 2338 2338 + for i := 0; i < int(extra); i++ { 2339 2339 + { 2340 2340 + var maj byte 2341 2341 + var extra uint64 2342 2342 + var err error 2343 2343 + _ = maj 2344 2344 + _ = extra 2345 2345 + _ = err 2346 2346 + 2347 2347 + { 2348 2348 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2349 2349 + if err != nil { 2350 2350 + return err 2351 2351 + } 2352 2352 + 2353 2353 + t.Packages[i] = string(sval) 2354 2354 + } 2355 2355 + 2356 2356 + } 2357 2357 + } 2358 2358 + // t.Registry (string) (string) 2359 2359 + case "registry": 2360 2360 + 2361 2361 + { 2362 2362 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2363 2363 + if err != nil { 2364 2364 + return err 2365 2365 + } 2366 2366 + 2367 2367 + t.Registry = string(sval) 2368 2368 + } 2369 2369 + 2370 2370 + default: 2371 2371 + // Field doesn't exist on this type, so ignore it 2372 2372 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 895 2373 return err 896 2374 } 897 2375 } 898 2376 } 899 2377 900 900 - // t.CommentId (int64) (int64) 901 901 - if t.CommentId != nil { 2378 2378 + return nil 2379 2379 + } 2380 2380 + func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error { 2381 2381 + if t == nil { 2382 2382 + _, err := w.Write(cbg.CborNull) 2383 2383 + return err 2384 2384 + } 2385 2385 + 2386 2386 + cw := cbg.NewCborWriter(w) 2387 2387 + fieldCount := 1 2388 2388 + 2389 2389 + if t.Inputs == nil { 2390 2390 + fieldCount-- 2391 2391 + } 2392 2392 + 2393 2393 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2394 2394 + return err 2395 2395 + } 2396 2396 + 2397 2397 + // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2398 2398 + if t.Inputs != nil { 2399 2399 + 2400 2400 + if len("inputs") > 1000000 { 2401 2401 + return xerrors.Errorf("Value in field \"inputs\" was too long") 2402 2402 + } 2403 2403 + 2404 2404 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 2405 2405 + return err 2406 2406 + } 2407 2407 + if _, err := cw.WriteString(string("inputs")); err != nil { 2408 2408 + return err 2409 2409 + } 902 2410 903 903 - if len("commentId") > 1000000 { 904 904 - return xerrors.Errorf("Value in field \"commentId\" was too long") 2411 2411 + if len(t.Inputs) > 8192 { 2412 2412 + return xerrors.Errorf("Slice value in field t.Inputs was too long") 905 2413 } 906 2414 907 907 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil { 2415 2415 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 908 2416 return err 909 2417 } 910 910 - if _, err := cw.WriteString(string("commentId")); err != nil { 2418 2418 + for _, v := range t.Inputs { 2419 2419 + if err := v.MarshalCBOR(cw); err != nil { 2420 2420 + return err 2421 2421 + } 2422 2422 + 2423 2423 + } 2424 2424 + } 2425 2425 + return nil 2426 2426 + } 2427 2427 + 2428 2428 + func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) { 2429 2429 + *t = Pipeline_ManualTriggerData{} 2430 2430 + 2431 2431 + cr := cbg.NewCborReader(r) 2432 2432 + 2433 2433 + maj, extra, err := cr.ReadHeader() 2434 2434 + if err != nil { 2435 2435 + return err 2436 2436 + } 2437 2437 + defer func() { 2438 2438 + if err == io.EOF { 2439 2439 + err = io.ErrUnexpectedEOF 2440 2440 + } 2441 2441 + }() 2442 2442 + 2443 2443 + if maj != cbg.MajMap { 2444 2444 + return fmt.Errorf("cbor input should be of type map") 2445 2445 + } 2446 2446 + 2447 2447 + if extra > cbg.MaxLength { 2448 2448 + return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra) 2449 2449 + } 2450 2450 + 2451 2451 + n := extra 2452 2452 + 2453 2453 + nameBuf := make([]byte, 6) 2454 2454 + for i := uint64(0); i < n; i++ { 2455 2455 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2456 2456 + if err != nil { 911 2457 return err 912 2458 } 913 2459 914 914 - if t.CommentId == nil { 915 915 - if _, err := cw.Write(cbg.CborNull); err != nil { 2460 2460 + if !ok { 2461 2461 + // Field doesn't exist on this type, so ignore it 2462 2462 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 916 2463 return err 917 2464 } 918 918 - } else { 919 919 - if *t.CommentId >= 0 { 920 920 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil { 921 921 - return err 922 922 - } 923 923 - } else { 924 924 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil { 925 925 - return err 2465 2465 + continue 2466 2466 + } 2467 2467 + 2468 2468 + switch string(nameBuf[:nameLen]) { 2469 2469 + // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2470 2470 + case "inputs": 2471 2471 + 2472 2472 + maj, extra, err = cr.ReadHeader() 2473 2473 + if err != nil { 2474 2474 + return err 2475 2475 + } 2476 2476 + 2477 2477 + if extra > 8192 { 2478 2478 + return fmt.Errorf("t.Inputs: array too large (%d)", extra) 2479 2479 + } 2480 2480 + 2481 2481 + if maj != cbg.MajArray { 2482 2482 + return fmt.Errorf("expected cbor array") 2483 2483 + } 2484 2484 + 2485 2485 + if extra > 0 { 2486 2486 + t.Inputs = make([]*Pipeline_ManualTriggerData_Inputs_Elem, extra) 2487 2487 + } 2488 2488 + 2489 2489 + for i := 0; i < int(extra); i++ { 2490 2490 + { 2491 2491 + var maj byte 2492 2492 + var extra uint64 2493 2493 + var err error 2494 2494 + _ = maj 2495 2495 + _ = extra 2496 2496 + _ = err 2497 2497 + 2498 2498 + { 2499 2499 + 2500 2500 + b, err := cr.ReadByte() 2501 2501 + if err != nil { 2502 2502 + return err 2503 2503 + } 2504 2504 + if b != cbg.CborNull[0] { 2505 2505 + if err := cr.UnreadByte(); err != nil { 2506 2506 + return err 2507 2507 + } 2508 2508 + t.Inputs[i] = new(Pipeline_ManualTriggerData_Inputs_Elem) 2509 2509 + if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 2510 2510 + return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 2511 2511 + } 2512 2512 + } 2513 2513 + 2514 2514 + } 2515 2515 + 926 2516 } 927 2517 } 2518 2518 + 2519 2519 + default: 2520 2520 + // Field doesn't exist on this type, so ignore it 2521 2521 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2522 2522 + return err 2523 2523 + } 928 2524 } 2525 2525 + } 929 2526 2527 2527 + return nil 2528 2528 + } 2529 2529 + func (t *Pipeline_ManualTriggerData_Inputs_Elem) MarshalCBOR(w io.Writer) error { 2530 2530 + if t == nil { 2531 2531 + _, err := w.Write(cbg.CborNull) 2532 2532 + return err 930 2533 } 931 2534 932 932 - // t.CreatedAt (string) (string) 933 933 - if len("createdAt") > 1000000 { 934 934 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 2535 2535 + cw := cbg.NewCborWriter(w) 2536 2536 + 2537 2537 + if _, err := cw.Write([]byte{162}); err != nil { 2538 2538 + return err 2539 2539 + } 2540 2540 + 2541 2541 + // t.Key (string) (string) 2542 2542 + if len("key") > 1000000 { 2543 2543 + return xerrors.Errorf("Value in field \"key\" was too long") 2544 2544 + } 2545 2545 + 2546 2546 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 2547 2547 + return err 2548 2548 + } 2549 2549 + if _, err := cw.WriteString(string("key")); err != nil { 2550 2550 + return err 2551 2551 + } 2552 2552 + 2553 2553 + if len(t.Key) > 1000000 { 2554 2554 + return xerrors.Errorf("Value in field t.Key was too long") 935 2555 } 936 2556 937 937 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2557 2557 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 938 2558 return err 939 2559 } 940 940 - if _, err := cw.WriteString(string("createdAt")); err != nil { 2560 2560 + if _, err := cw.WriteString(string(t.Key)); err != nil { 941 2561 return err 942 2562 } 943 2563 944 944 - if len(t.CreatedAt) > 1000000 { 945 945 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 2564 2564 + // t.Value (string) (string) 2565 2565 + if len("value") > 1000000 { 2566 2566 + return xerrors.Errorf("Value in field \"value\" was too long") 946 2567 } 947 2568 948 948 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2569 2569 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 949 2570 return err 950 2571 } 951 951 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2572 2572 + if _, err := cw.WriteString(string("value")); err != nil { 2573 2573 + return err 2574 2574 + } 2575 2575 + 2576 2576 + if len(t.Value) > 1000000 { 2577 2577 + return xerrors.Errorf("Value in field t.Value was too long") 2578 2578 + } 2579 2579 + 2580 2580 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 2581 2581 + return err 2582 2582 + } 2583 2583 + if _, err := cw.WriteString(string(t.Value)); err != nil { 952 2584 return err 953 2585 } 954 2586 return nil 955 2587 } 956 2588 957 957 - func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) { 958 958 - *t = RepoIssueComment{} 2589 2589 + func (t *Pipeline_ManualTriggerData_Inputs_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2590 2590 + *t = Pipeline_ManualTriggerData_Inputs_Elem{} 959 2591 960 2592 cr := cbg.NewCborReader(r) 961 2593 ··· 974 2606 } 975 2607 976 2608 if extra > cbg.MaxLength { 977 977 - return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra) 2609 2609 + return fmt.Errorf("Pipeline_ManualTriggerData_Inputs_Elem: map struct too large (%d)", extra) 978 2610 } 979 2611 980 2612 n := extra 981 2613 982 982 - nameBuf := make([]byte, 9) 2614 2614 + nameBuf := make([]byte, 5) 983 2615 for i := uint64(0); i < n; i++ { 984 2616 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 985 2617 if err != nil { ··· 995 2627 } 996 2628 997 2629 switch string(nameBuf[:nameLen]) { 998 998 - // t.Body (string) (string) 999 999 - case "body": 2630 2630 + // t.Key (string) (string) 2631 2631 + case "key": 1000 2632 1001 2633 { 1002 2634 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1004 2636 return err 1005 2637 } 1006 2638 1007 1007 - t.Body = string(sval) 2639 2639 + t.Key = string(sval) 1008 2640 } 1009 1009 - // t.Repo (string) (string) 1010 1010 - case "repo": 2641 2641 + // t.Value (string) (string) 2642 2642 + case "value": 1011 2643 1012 2644 { 1013 1013 - b, err := cr.ReadByte() 2645 2645 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1014 2646 if err != nil { 1015 2647 return err 1016 2648 } 1017 1017 - if b != cbg.CborNull[0] { 1018 1018 - if err := cr.UnreadByte(); err != nil { 1019 1019 - return err 1020 1020 - } 1021 2649 1022 1022 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1023 1023 - if err != nil { 1024 1024 - return err 1025 1025 - } 2650 2650 + t.Value = string(sval) 2651 2651 + } 1026 2652 1027 1027 - t.Repo = (*string)(&sval) 1028 1028 - } 2653 2653 + default: 2654 2654 + // Field doesn't exist on this type, so ignore it 2655 2655 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2656 2656 + return err 1029 2657 } 1030 1030 - // t.LexiconTypeID (string) (string) 1031 1031 - case "$type": 2658 2658 + } 2659 2659 + } 1032 2660 1033 1033 - { 1034 1034 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1035 1035 - if err != nil { 1036 1036 - return err 1037 1037 - } 2661 2661 + return nil 2662 2662 + } 2663 2663 + func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error { 2664 2664 + if t == nil { 2665 2665 + _, err := w.Write(cbg.CborNull) 2666 2666 + return err 2667 2667 + } 1038 2668 1039 1039 - t.LexiconTypeID = string(sval) 2669 2669 + cw := cbg.NewCborWriter(w) 2670 2670 + 2671 2671 + if _, err := cw.Write([]byte{164}); err != nil { 2672 2672 + return err 2673 2673 + } 2674 2674 + 2675 2675 + // t.Action (string) (string) 2676 2676 + if len("action") > 1000000 { 2677 2677 + return xerrors.Errorf("Value in field \"action\" was too long") 2678 2678 + } 2679 2679 + 2680 2680 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil { 2681 2681 + return err 2682 2682 + } 2683 2683 + if _, err := cw.WriteString(string("action")); err != nil { 2684 2684 + return err 2685 2685 + } 2686 2686 + 2687 2687 + if len(t.Action) > 1000000 { 2688 2688 + return xerrors.Errorf("Value in field t.Action was too long") 2689 2689 + } 2690 2690 + 2691 2691 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil { 2692 2692 + return err 2693 2693 + } 2694 2694 + if _, err := cw.WriteString(string(t.Action)); err != nil { 2695 2695 + return err 2696 2696 + } 2697 2697 + 2698 2698 + // t.SourceSha (string) (string) 2699 2699 + if len("sourceSha") > 1000000 { 2700 2700 + return xerrors.Errorf("Value in field \"sourceSha\" was too long") 2701 2701 + } 2702 2702 + 2703 2703 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil { 2704 2704 + return err 2705 2705 + } 2706 2706 + if _, err := cw.WriteString(string("sourceSha")); err != nil { 2707 2707 + return err 2708 2708 + } 2709 2709 + 2710 2710 + if len(t.SourceSha) > 1000000 { 2711 2711 + return xerrors.Errorf("Value in field t.SourceSha was too long") 2712 2712 + } 2713 2713 + 2714 2714 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil { 2715 2715 + return err 2716 2716 + } 2717 2717 + if _, err := cw.WriteString(string(t.SourceSha)); err != nil { 2718 2718 + return err 2719 2719 + } 2720 2720 + 2721 2721 + // t.SourceBranch (string) (string) 2722 2722 + if len("sourceBranch") > 1000000 { 2723 2723 + return xerrors.Errorf("Value in field \"sourceBranch\" was too long") 2724 2724 + } 2725 2725 + 2726 2726 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil { 2727 2727 + return err 2728 2728 + } 2729 2729 + if _, err := cw.WriteString(string("sourceBranch")); err != nil { 2730 2730 + return err 2731 2731 + } 2732 2732 + 2733 2733 + if len(t.SourceBranch) > 1000000 { 2734 2734 + return xerrors.Errorf("Value in field t.SourceBranch was too long") 2735 2735 + } 2736 2736 + 2737 2737 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil { 2738 2738 + return err 2739 2739 + } 2740 2740 + if _, err := cw.WriteString(string(t.SourceBranch)); err != nil { 2741 2741 + return err 2742 2742 + } 2743 2743 + 2744 2744 + // t.TargetBranch (string) (string) 2745 2745 + if len("targetBranch") > 1000000 { 2746 2746 + return xerrors.Errorf("Value in field \"targetBranch\" was too long") 2747 2747 + } 2748 2748 + 2749 2749 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 2750 2750 + return err 2751 2751 + } 2752 2752 + if _, err := cw.WriteString(string("targetBranch")); err != nil { 2753 2753 + return err 2754 2754 + } 2755 2755 + 2756 2756 + if len(t.TargetBranch) > 1000000 { 2757 2757 + return xerrors.Errorf("Value in field t.TargetBranch was too long") 2758 2758 + } 2759 2759 + 2760 2760 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 2761 2761 + return err 2762 2762 + } 2763 2763 + if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 2764 2764 + return err 2765 2765 + } 2766 2766 + return nil 2767 2767 + } 2768 2768 + 2769 2769 + func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) { 2770 2770 + *t = Pipeline_PullRequestTriggerData{} 2771 2771 + 2772 2772 + cr := cbg.NewCborReader(r) 2773 2773 + 2774 2774 + maj, extra, err := cr.ReadHeader() 2775 2775 + if err != nil { 2776 2776 + return err 2777 2777 + } 2778 2778 + defer func() { 2779 2779 + if err == io.EOF { 2780 2780 + err = io.ErrUnexpectedEOF 2781 2781 + } 2782 2782 + }() 2783 2783 + 2784 2784 + if maj != cbg.MajMap { 2785 2785 + return fmt.Errorf("cbor input should be of type map") 2786 2786 + } 2787 2787 + 2788 2788 + if extra > cbg.MaxLength { 2789 2789 + return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra) 2790 2790 + } 2791 2791 + 2792 2792 + n := extra 2793 2793 + 2794 2794 + nameBuf := make([]byte, 12) 2795 2795 + for i := uint64(0); i < n; i++ { 2796 2796 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2797 2797 + if err != nil { 2798 2798 + return err 2799 2799 + } 2800 2800 + 2801 2801 + if !ok { 2802 2802 + // Field doesn't exist on this type, so ignore it 2803 2803 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2804 2804 + return err 1040 2805 } 1041 1041 - // t.Issue (string) (string) 1042 1042 - case "issue": 2806 2806 + continue 2807 2807 + } 2808 2808 + 2809 2809 + switch string(nameBuf[:nameLen]) { 2810 2810 + // t.Action (string) (string) 2811 2811 + case "action": 1043 2812 1044 2813 { 1045 2814 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1047 2816 return err 1048 2817 } 1049 2818 1050 1050 - t.Issue = string(sval) 2819 2819 + t.Action = string(sval) 1051 2820 } 1052 1052 - // t.Owner (string) (string) 1053 1053 - case "owner": 2821 2821 + // t.SourceSha (string) (string) 2822 2822 + case "sourceSha": 1054 2823 1055 2824 { 1056 1056 - b, err := cr.ReadByte() 2825 2825 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1057 2826 if err != nil { 1058 2827 return err 1059 2828 } 1060 1060 - if b != cbg.CborNull[0] { 1061 1061 - if err := cr.UnreadByte(); err != nil { 1062 1062 - return err 1063 1063 - } 1064 2829 1065 1065 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1066 1066 - if err != nil { 1067 1067 - return err 1068 1068 - } 1069 1069 - 1070 1070 - t.Owner = (*string)(&sval) 1071 1071 - } 2830 2830 + t.SourceSha = string(sval) 1072 2831 } 1073 1073 - // t.CommentId (int64) (int64) 1074 1074 - case "commentId": 1075 1075 - { 2832 2832 + // t.SourceBranch (string) (string) 2833 2833 + case "sourceBranch": 1076 2834 1077 1077 - b, err := cr.ReadByte() 2835 2835 + { 2836 2836 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1078 2837 if err != nil { 1079 2838 return err 1080 2839 } 1081 1081 - if b != cbg.CborNull[0] { 1082 1082 - if err := cr.UnreadByte(); err != nil { 1083 1083 - return err 1084 1084 - } 1085 1085 - maj, extra, err := cr.ReadHeader() 1086 1086 - if err != nil { 1087 1087 - return err 1088 1088 - } 1089 1089 - var extraI int64 1090 1090 - switch maj { 1091 1091 - case cbg.MajUnsignedInt: 1092 1092 - extraI = int64(extra) 1093 1093 - if extraI < 0 { 1094 1094 - return fmt.Errorf("int64 positive overflow") 1095 1095 - } 1096 1096 - case cbg.MajNegativeInt: 1097 1097 - extraI = int64(extra) 1098 1098 - if extraI < 0 { 1099 1099 - return fmt.Errorf("int64 negative overflow") 1100 1100 - } 1101 1101 - extraI = -1 - extraI 1102 1102 - default: 1103 1103 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1104 1104 - } 1105 2840 1106 1106 - t.CommentId = (*int64)(&extraI) 1107 1107 - } 2841 2841 + t.SourceBranch = string(sval) 1108 2842 } 1109 1109 - // t.CreatedAt (string) (string) 1110 1110 - case "createdAt": 2843 2843 + // t.TargetBranch (string) (string) 2844 2844 + case "targetBranch": 1111 2845 1112 2846 { 1113 2847 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1115 2849 return err 1116 2850 } 1117 2851 1118 1118 - t.CreatedAt = string(sval) 2852 2852 + t.TargetBranch = string(sval) 1119 2853 } 1120 2854 1121 2855 default: ··· 1128 2862 1129 2863 return nil 1130 2864 } 1131 1131 - func (t *RepoIssueState) MarshalCBOR(w io.Writer) error { 2865 2865 + func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error { 1132 2866 if t == nil { 1133 2867 _, err := w.Write(cbg.CborNull) 1134 2868 return err ··· 1140 2874 return err 1141 2875 } 1142 2876 1143 1143 - // t.LexiconTypeID (string) (string) 1144 1144 - if len("$type") > 1000000 { 1145 1145 - return xerrors.Errorf("Value in field \"$type\" was too long") 2877 2877 + // t.Ref (string) (string) 2878 2878 + if len("ref") > 1000000 { 2879 2879 + return xerrors.Errorf("Value in field \"ref\" was too long") 1146 2880 } 1147 2881 1148 1148 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2882 2882 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 1149 2883 return err 1150 2884 } 1151 1151 - if _, err := cw.WriteString(string("$type")); err != nil { 2885 2885 + if _, err := cw.WriteString(string("ref")); err != nil { 1152 2886 return err 1153 2887 } 1154 2888 1155 1155 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil { 2889 2889 + if len(t.Ref) > 1000000 { 2890 2890 + return xerrors.Errorf("Value in field t.Ref was too long") 2891 2891 + } 2892 2892 + 2893 2893 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 1156 2894 return err 1157 2895 } 1158 1158 - if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil { 2896 2896 + if _, err := cw.WriteString(string(t.Ref)); err != nil { 1159 2897 return err 1160 2898 } 1161 2899 1162 1162 - // t.Issue (string) (string) 1163 1163 - if len("issue") > 1000000 { 1164 1164 - return xerrors.Errorf("Value in field \"issue\" was too long") 2900 2900 + // t.NewSha (string) (string) 2901 2901 + if len("newSha") > 1000000 { 2902 2902 + return xerrors.Errorf("Value in field \"newSha\" was too long") 1165 2903 } 1166 2904 1167 1167 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 2905 2905 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 1168 2906 return err 1169 2907 } 1170 1170 - if _, err := cw.WriteString(string("issue")); err != nil { 2908 2908 + if _, err := cw.WriteString(string("newSha")); err != nil { 1171 2909 return err 1172 2910 } 1173 2911 1174 1174 - if len(t.Issue) > 1000000 { 1175 1175 - return xerrors.Errorf("Value in field t.Issue was too long") 2912 2912 + if len(t.NewSha) > 1000000 { 2913 2913 + return xerrors.Errorf("Value in field t.NewSha was too long") 1176 2914 } 1177 2915 1178 1178 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 2916 2916 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 1179 2917 return err 1180 2918 } 1181 1181 - if _, err := cw.WriteString(string(t.Issue)); err != nil { 2919 2919 + if _, err := cw.WriteString(string(t.NewSha)); err != nil { 1182 2920 return err 1183 2921 } 1184 2922 1185 1185 - // t.State (string) (string) 1186 1186 - if len("state") > 1000000 { 1187 1187 - return xerrors.Errorf("Value in field \"state\" was too long") 2923 2923 + // t.OldSha (string) (string) 2924 2924 + if len("oldSha") > 1000000 { 2925 2925 + return xerrors.Errorf("Value in field \"oldSha\" was too long") 1188 2926 } 1189 2927 1190 1190 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 2928 2928 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 1191 2929 return err 1192 2930 } 1193 1193 - if _, err := cw.WriteString(string("state")); err != nil { 2931 2931 + if _, err := cw.WriteString(string("oldSha")); err != nil { 1194 2932 return err 1195 2933 } 1196 2934 1197 1197 - if len(t.State) > 1000000 { 1198 1198 - return xerrors.Errorf("Value in field t.State was too long") 2935 2935 + if len(t.OldSha) > 1000000 { 2936 2936 + return xerrors.Errorf("Value in field t.OldSha was too long") 1199 2937 } 1200 2938 1201 1201 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 2939 2939 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 1202 2940 return err 1203 2941 } 1204 1204 - if _, err := cw.WriteString(string(t.State)); err != nil { 2942 2942 + if _, err := cw.WriteString(string(t.OldSha)); err != nil { 1205 2943 return err 1206 2944 } 1207 2945 return nil 1208 2946 } 1209 2947 1210 1210 - func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) { 1211 1211 - *t = RepoIssueState{} 2948 2948 + func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) { 2949 2949 + *t = Pipeline_PushTriggerData{} 1212 2950 1213 2951 cr := cbg.NewCborReader(r) 1214 2952 ··· 1227 2965 } 1228 2966 1229 2967 if extra > cbg.MaxLength { 1230 1230 - return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra) 2968 2968 + return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra) 1231 2969 } 1232 2970 1233 2971 n := extra 1234 2972 1235 1235 - nameBuf := make([]byte, 5) 2973 2973 + nameBuf := make([]byte, 6) 1236 2974 for i := uint64(0); i < n; i++ { 1237 2975 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1238 2976 if err != nil { ··· 1248 2986 } 1249 2987 1250 2988 switch string(nameBuf[:nameLen]) { 1251 1251 - // t.LexiconTypeID (string) (string) 1252 1252 - case "$type": 2989 2989 + // t.Ref (string) (string) 2990 2990 + case "ref": 1253 2991 1254 2992 { 1255 2993 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1257 2995 return err 1258 2996 } 1259 2997 1260 1260 - t.LexiconTypeID = string(sval) 2998 2998 + t.Ref = string(sval) 1261 2999 } 1262 1262 - // t.Issue (string) (string) 1263 1263 - case "issue": 3000 3000 + // t.NewSha (string) (string) 3001 3001 + case "newSha": 1264 3002 1265 3003 { 1266 3004 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1268 3006 return err 1269 3007 } 1270 3008 1271 1271 - t.Issue = string(sval) 3009 3009 + t.NewSha = string(sval) 1272 3010 } 1273 1273 - // t.State (string) (string) 1274 1274 - case "state": 3011 3011 + // t.OldSha (string) (string) 3012 3012 + case "oldSha": 1275 3013 1276 3014 { 1277 3015 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1279 3017 return err 1280 3018 } 1281 3019 1282 1282 - t.State = string(sval) 3020 3020 + t.OldSha = string(sval) 1283 3021 } 1284 3022 1285 3023 default: ··· 1292 3030 1293 3031 return nil 1294 3032 } 1295 1295 - func (t *RepoIssue) MarshalCBOR(w io.Writer) error { 3033 3033 + func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error { 1296 3034 if t == nil { 1297 3035 _, err := w.Write(cbg.CborNull) 1298 3036 return err 1299 3037 } 1300 3038 1301 3039 cw := cbg.NewCborWriter(w) 1302 1302 - fieldCount := 7 1303 3040 1304 1304 - if t.Body == nil { 1305 1305 - fieldCount-- 3041 3041 + if _, err := cw.Write([]byte{162}); err != nil { 3042 3042 + return err 1306 3043 } 1307 3044 1308 1308 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 3045 3045 + // t.Name (string) (string) 3046 3046 + if len("name") > 1000000 { 3047 3047 + return xerrors.Errorf("Value in field \"name\" was too long") 3048 3048 + } 3049 3049 + 3050 3050 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 3051 3051 + return err 3052 3052 + } 3053 3053 + if _, err := cw.WriteString(string("name")); err != nil { 1309 3054 return err 1310 3055 } 1311 3056 1312 1312 - // t.Body (string) (string) 1313 1313 - if t.Body != nil { 3057 3057 + if len(t.Name) > 1000000 { 3058 3058 + return xerrors.Errorf("Value in field t.Name was too long") 3059 3059 + } 1314 3060 1315 1315 - if len("body") > 1000000 { 1316 1316 - return xerrors.Errorf("Value in field \"body\" was too long") 3061 3061 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 3062 3062 + return err 3063 3063 + } 3064 3064 + if _, err := cw.WriteString(string(t.Name)); err != nil { 3065 3065 + return err 3066 3066 + } 3067 3067 + 3068 3068 + // t.Command (string) (string) 3069 3069 + if len("command") > 1000000 { 3070 3070 + return xerrors.Errorf("Value in field \"command\" was too long") 3071 3071 + } 3072 3072 + 3073 3073 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil { 3074 3074 + return err 3075 3075 + } 3076 3076 + if _, err := cw.WriteString(string("command")); err != nil { 3077 3077 + return err 3078 3078 + } 3079 3079 + 3080 3080 + if len(t.Command) > 1000000 { 3081 3081 + return xerrors.Errorf("Value in field t.Command was too long") 3082 3082 + } 3083 3083 + 3084 3084 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Command))); err != nil { 3085 3085 + return err 3086 3086 + } 3087 3087 + if _, err := cw.WriteString(string(t.Command)); err != nil { 3088 3088 + return err 3089 3089 + } 3090 3090 + return nil 3091 3091 + } 3092 3092 + 3093 3093 + func (t *Pipeline_Step) UnmarshalCBOR(r io.Reader) (err error) { 3094 3094 + *t = Pipeline_Step{} 3095 3095 + 3096 3096 + cr := cbg.NewCborReader(r) 3097 3097 + 3098 3098 + maj, extra, err := cr.ReadHeader() 3099 3099 + if err != nil { 3100 3100 + return err 3101 3101 + } 3102 3102 + defer func() { 3103 3103 + if err == io.EOF { 3104 3104 + err = io.ErrUnexpectedEOF 1317 3105 } 3106 3106 + }() 1318 3107 1319 1319 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 1320 1320 - return err 1321 1321 - } 1322 1322 - if _, err := cw.WriteString(string("body")); err != nil { 3108 3108 + if maj != cbg.MajMap { 3109 3109 + return fmt.Errorf("cbor input should be of type map") 3110 3110 + } 3111 3111 + 3112 3112 + if extra > cbg.MaxLength { 3113 3113 + return fmt.Errorf("Pipeline_Step: map struct too large (%d)", extra) 3114 3114 + } 3115 3115 + 3116 3116 + n := extra 3117 3117 + 3118 3118 + nameBuf := make([]byte, 7) 3119 3119 + for i := uint64(0); i < n; i++ { 3120 3120 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3121 3121 + if err != nil { 1323 3122 return err 1324 3123 } 1325 3124 1326 1326 - if t.Body == nil { 1327 1327 - if _, err := cw.Write(cbg.CborNull); err != nil { 3125 3125 + if !ok { 3126 3126 + // Field doesn't exist on this type, so ignore it 3127 3127 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1328 3128 return err 1329 3129 } 1330 1330 - } else { 1331 1331 - if len(*t.Body) > 1000000 { 1332 1332 - return xerrors.Errorf("Value in field t.Body was too long") 3130 3130 + continue 3131 3131 + } 3132 3132 + 3133 3133 + switch string(nameBuf[:nameLen]) { 3134 3134 + // t.Name (string) (string) 3135 3135 + case "name": 3136 3136 + 3137 3137 + { 3138 3138 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3139 3139 + if err != nil { 3140 3140 + return err 3141 3141 + } 3142 3142 + 3143 3143 + t.Name = string(sval) 1333 3144 } 3145 3145 + // t.Command (string) (string) 3146 3146 + case "command": 1334 3147 1335 1335 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 1336 1336 - return err 3148 3148 + { 3149 3149 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3150 3150 + if err != nil { 3151 3151 + return err 3152 3152 + } 3153 3153 + 3154 3154 + t.Command = string(sval) 1337 3155 } 1338 1338 - if _, err := cw.WriteString(string(*t.Body)); err != nil { 3156 3156 + 3157 3157 + default: 3158 3158 + // Field doesn't exist on this type, so ignore it 3159 3159 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1339 3160 return err 1340 3161 } 1341 3162 } 1342 3163 } 1343 3164 1344 1344 - // t.Repo (string) (string) 3165 3165 + return nil 3166 3166 + } 3167 3167 + func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error { 3168 3168 + if t == nil { 3169 3169 + _, err := w.Write(cbg.CborNull) 3170 3170 + return err 3171 3171 + } 3172 3172 + 3173 3173 + cw := cbg.NewCborWriter(w) 3174 3174 + fieldCount := 5 3175 3175 + 3176 3176 + if t.Manual == nil { 3177 3177 + fieldCount-- 3178 3178 + } 3179 3179 + 3180 3180 + if t.PullRequest == nil { 3181 3181 + fieldCount-- 3182 3182 + } 3183 3183 + 3184 3184 + if t.Push == nil { 3185 3185 + fieldCount-- 3186 3186 + } 3187 3187 + 3188 3188 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 3189 3189 + return err 3190 3190 + } 3191 3191 + 3192 3192 + // t.Kind (string) (string) 3193 3193 + if len("kind") > 1000000 { 3194 3194 + return xerrors.Errorf("Value in field \"kind\" was too long") 3195 3195 + } 3196 3196 + 3197 3197 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil { 3198 3198 + return err 3199 3199 + } 3200 3200 + if _, err := cw.WriteString(string("kind")); err != nil { 3201 3201 + return err 3202 3202 + } 3203 3203 + 3204 3204 + if len(t.Kind) > 1000000 { 3205 3205 + return xerrors.Errorf("Value in field t.Kind was too long") 3206 3206 + } 3207 3207 + 3208 3208 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil { 3209 3209 + return err 3210 3210 + } 3211 3211 + if _, err := cw.WriteString(string(t.Kind)); err != nil { 3212 3212 + return err 3213 3213 + } 3214 3214 + 3215 3215 + // t.Push (tangled.Pipeline_PushTriggerData) (struct) 3216 3216 + if t.Push != nil { 3217 3217 + 3218 3218 + if len("push") > 1000000 { 3219 3219 + return xerrors.Errorf("Value in field \"push\" was too long") 3220 3220 + } 3221 3221 + 3222 3222 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil { 3223 3223 + return err 3224 3224 + } 3225 3225 + if _, err := cw.WriteString(string("push")); err != nil { 3226 3226 + return err 3227 3227 + } 3228 3228 + 3229 3229 + if err := t.Push.MarshalCBOR(cw); err != nil { 3230 3230 + return err 3231 3231 + } 3232 3232 + } 3233 3233 + 3234 3234 + // t.Repo (tangled.Pipeline_TriggerRepo) (struct) 1345 3235 if len("repo") > 1000000 { 1346 3236 return xerrors.Errorf("Value in field \"repo\" was too long") 1347 3237 } ··· 1353 3243 return err 1354 3244 } 1355 3245 1356 1356 - if len(t.Repo) > 1000000 { 1357 1357 - return xerrors.Errorf("Value in field t.Repo was too long") 3246 3246 + if err := t.Repo.MarshalCBOR(cw); err != nil { 3247 3247 + return err 1358 3248 } 1359 3249 1360 1360 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 1361 1361 - return err 3250 3250 + // t.Manual (tangled.Pipeline_ManualTriggerData) (struct) 3251 3251 + if t.Manual != nil { 3252 3252 + 3253 3253 + if len("manual") > 1000000 { 3254 3254 + return xerrors.Errorf("Value in field \"manual\" was too long") 3255 3255 + } 3256 3256 + 3257 3257 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil { 3258 3258 + return err 3259 3259 + } 3260 3260 + if _, err := cw.WriteString(string("manual")); err != nil { 3261 3261 + return err 3262 3262 + } 3263 3263 + 3264 3264 + if err := t.Manual.MarshalCBOR(cw); err != nil { 3265 3265 + return err 3266 3266 + } 3267 3267 + } 3268 3268 + 3269 3269 + // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct) 3270 3270 + if t.PullRequest != nil { 3271 3271 + 3272 3272 + if len("pullRequest") > 1000000 { 3273 3273 + return xerrors.Errorf("Value in field \"pullRequest\" was too long") 3274 3274 + } 3275 3275 + 3276 3276 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil { 3277 3277 + return err 3278 3278 + } 3279 3279 + if _, err := cw.WriteString(string("pullRequest")); err != nil { 3280 3280 + return err 3281 3281 + } 3282 3282 + 3283 3283 + if err := t.PullRequest.MarshalCBOR(cw); err != nil { 3284 3284 + return err 3285 3285 + } 1362 3286 } 1363 1363 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 3287 3287 + return nil 3288 3288 + } 3289 3289 + 3290 3290 + func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) { 3291 3291 + *t = Pipeline_TriggerMetadata{} 3292 3292 + 3293 3293 + cr := cbg.NewCborReader(r) 3294 3294 + 3295 3295 + maj, extra, err := cr.ReadHeader() 3296 3296 + if err != nil { 1364 3297 return err 1365 3298 } 3299 3299 + defer func() { 3300 3300 + if err == io.EOF { 3301 3301 + err = io.ErrUnexpectedEOF 3302 3302 + } 3303 3303 + }() 1366 3304 1367 1367 - // t.LexiconTypeID (string) (string) 1368 1368 - if len("$type") > 1000000 { 1369 1369 - return xerrors.Errorf("Value in field \"$type\" was too long") 3305 3305 + if maj != cbg.MajMap { 3306 3306 + return fmt.Errorf("cbor input should be of type map") 1370 3307 } 1371 3308 1372 1372 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1373 1373 - return err 3309 3309 + if extra > cbg.MaxLength { 3310 3310 + return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra) 1374 3311 } 1375 1375 - if _, err := cw.WriteString(string("$type")); err != nil { 1376 1376 - return err 3312 3312 + 3313 3313 + n := extra 3314 3314 + 3315 3315 + nameBuf := make([]byte, 11) 3316 3316 + for i := uint64(0); i < n; i++ { 3317 3317 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3318 3318 + if err != nil { 3319 3319 + return err 3320 3320 + } 3321 3321 + 3322 3322 + if !ok { 3323 3323 + // Field doesn't exist on this type, so ignore it 3324 3324 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3325 3325 + return err 3326 3326 + } 3327 3327 + continue 3328 3328 + } 3329 3329 + 3330 3330 + switch string(nameBuf[:nameLen]) { 3331 3331 + // t.Kind (string) (string) 3332 3332 + case "kind": 3333 3333 + 3334 3334 + { 3335 3335 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3336 3336 + if err != nil { 3337 3337 + return err 3338 3338 + } 3339 3339 + 3340 3340 + t.Kind = string(sval) 3341 3341 + } 3342 3342 + // t.Push (tangled.Pipeline_PushTriggerData) (struct) 3343 3343 + case "push": 3344 3344 + 3345 3345 + { 3346 3346 + 3347 3347 + b, err := cr.ReadByte() 3348 3348 + if err != nil { 3349 3349 + return err 3350 3350 + } 3351 3351 + if b != cbg.CborNull[0] { 3352 3352 + if err := cr.UnreadByte(); err != nil { 3353 3353 + return err 3354 3354 + } 3355 3355 + t.Push = new(Pipeline_PushTriggerData) 3356 3356 + if err := t.Push.UnmarshalCBOR(cr); err != nil { 3357 3357 + return xerrors.Errorf("unmarshaling t.Push pointer: %w", err) 3358 3358 + } 3359 3359 + } 3360 3360 + 3361 3361 + } 3362 3362 + // t.Repo (tangled.Pipeline_TriggerRepo) (struct) 3363 3363 + case "repo": 3364 3364 + 3365 3365 + { 3366 3366 + 3367 3367 + b, err := cr.ReadByte() 3368 3368 + if err != nil { 3369 3369 + return err 3370 3370 + } 3371 3371 + if b != cbg.CborNull[0] { 3372 3372 + if err := cr.UnreadByte(); err != nil { 3373 3373 + return err 3374 3374 + } 3375 3375 + t.Repo = new(Pipeline_TriggerRepo) 3376 3376 + if err := t.Repo.UnmarshalCBOR(cr); err != nil { 3377 3377 + return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err) 3378 3378 + } 3379 3379 + } 3380 3380 + 3381 3381 + } 3382 3382 + // t.Manual (tangled.Pipeline_ManualTriggerData) (struct) 3383 3383 + case "manual": 3384 3384 + 3385 3385 + { 3386 3386 + 3387 3387 + b, err := cr.ReadByte() 3388 3388 + if err != nil { 3389 3389 + return err 3390 3390 + } 3391 3391 + if b != cbg.CborNull[0] { 3392 3392 + if err := cr.UnreadByte(); err != nil { 3393 3393 + return err 3394 3394 + } 3395 3395 + t.Manual = new(Pipeline_ManualTriggerData) 3396 3396 + if err := t.Manual.UnmarshalCBOR(cr); err != nil { 3397 3397 + return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err) 3398 3398 + } 3399 3399 + } 3400 3400 + 3401 3401 + } 3402 3402 + // t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct) 3403 3403 + case "pullRequest": 3404 3404 + 3405 3405 + { 3406 3406 + 3407 3407 + b, err := cr.ReadByte() 3408 3408 + if err != nil { 3409 3409 + return err 3410 3410 + } 3411 3411 + if b != cbg.CborNull[0] { 3412 3412 + if err := cr.UnreadByte(); err != nil { 3413 3413 + return err 3414 3414 + } 3415 3415 + t.PullRequest = new(Pipeline_PullRequestTriggerData) 3416 3416 + if err := t.PullRequest.UnmarshalCBOR(cr); err != nil { 3417 3417 + return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err) 3418 3418 + } 3419 3419 + } 3420 3420 + 3421 3421 + } 3422 3422 + 3423 3423 + default: 3424 3424 + // Field doesn't exist on this type, so ignore it 3425 3425 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3426 3426 + return err 3427 3427 + } 3428 3428 + } 1377 3429 } 1378 3430 1379 1379 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil { 3431 3431 + return nil 3432 3432 + } 3433 3433 + func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error { 3434 3434 + if t == nil { 3435 3435 + _, err := w.Write(cbg.CborNull) 1380 3436 return err 1381 3437 } 1382 1382 - if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil { 3438 3438 + 3439 3439 + cw := cbg.NewCborWriter(w) 3440 3440 + 3441 3441 + if _, err := cw.Write([]byte{164}); err != nil { 1383 3442 return err 1384 3443 } 1385 3444 1386 1386 - // t.Owner (string) (string) 1387 1387 - if len("owner") > 1000000 { 1388 1388 - return xerrors.Errorf("Value in field \"owner\" was too long") 3445 3445 + // t.Did (string) (string) 3446 3446 + if len("did") > 1000000 { 3447 3447 + return xerrors.Errorf("Value in field \"did\" was too long") 1389 3448 } 1390 3449 1391 1391 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 3450 3450 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil { 1392 3451 return err 1393 3452 } 1394 1394 - if _, err := cw.WriteString(string("owner")); err != nil { 3453 3453 + if _, err := cw.WriteString(string("did")); err != nil { 1395 3454 return err 1396 3455 } 1397 3456 1398 1398 - if len(t.Owner) > 1000000 { 1399 1399 - return xerrors.Errorf("Value in field t.Owner was too long") 3457 3457 + if len(t.Did) > 1000000 { 3458 3458 + return xerrors.Errorf("Value in field t.Did was too long") 1400 3459 } 1401 3460 1402 1402 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 3461 3461 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil { 1403 3462 return err 1404 3463 } 1405 1405 - if _, err := cw.WriteString(string(t.Owner)); err != nil { 3464 3464 + if _, err := cw.WriteString(string(t.Did)); err != nil { 1406 3465 return err 1407 3466 } 1408 3467 1409 1409 - // t.Title (string) (string) 1410 1410 - if len("title") > 1000000 { 1411 1411 - return xerrors.Errorf("Value in field \"title\" was too long") 3468 3468 + // t.Knot (string) (string) 3469 3469 + if len("knot") > 1000000 { 3470 3470 + return xerrors.Errorf("Value in field \"knot\" was too long") 1412 3471 } 1413 3472 1414 1414 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 3473 3473 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 1415 3474 return err 1416 3475 } 1417 1417 - if _, err := cw.WriteString(string("title")); err != nil { 3476 3476 + if _, err := cw.WriteString(string("knot")); err != nil { 1418 3477 return err 1419 3478 } 1420 3479 1421 1421 - if len(t.Title) > 1000000 { 1422 1422 - return xerrors.Errorf("Value in field t.Title was too long") 3480 3480 + if len(t.Knot) > 1000000 { 3481 3481 + return xerrors.Errorf("Value in field t.Knot was too long") 1423 3482 } 1424 3483 1425 1425 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 3484 3484 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 1426 3485 return err 1427 3486 } 1428 1428 - if _, err := cw.WriteString(string(t.Title)); err != nil { 3487 3487 + if _, err := cw.WriteString(string(t.Knot)); err != nil { 1429 3488 return err 1430 3489 } 1431 3490 1432 1432 - // t.IssueId (int64) (int64) 1433 1433 - if len("issueId") > 1000000 { 1434 1434 - return xerrors.Errorf("Value in field \"issueId\" was too long") 3491 3491 + // t.Repo (string) (string) 3492 3492 + if len("repo") > 1000000 { 3493 3493 + return xerrors.Errorf("Value in field \"repo\" was too long") 1435 3494 } 1436 3495 1437 1437 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil { 3496 3496 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 1438 3497 return err 1439 3498 } 1440 1440 - if _, err := cw.WriteString(string("issueId")); err != nil { 3499 3499 + if _, err := cw.WriteString(string("repo")); err != nil { 1441 3500 return err 1442 3501 } 1443 3502 1444 1444 - if t.IssueId >= 0 { 1445 1445 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil { 1446 1446 - return err 1447 1447 - } 1448 1448 - } else { 1449 1449 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil { 1450 1450 - return err 1451 1451 - } 3503 3503 + if len(t.Repo) > 1000000 { 3504 3504 + return xerrors.Errorf("Value in field t.Repo was too long") 1452 3505 } 1453 3506 1454 1454 - // t.CreatedAt (string) (string) 1455 1455 - if len("createdAt") > 1000000 { 1456 1456 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 3507 3507 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 3508 3508 + return err 3509 3509 + } 3510 3510 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 3511 3511 + return err 1457 3512 } 1458 3513 1459 1459 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 3514 3514 + // t.DefaultBranch (string) (string) 3515 3515 + if len("defaultBranch") > 1000000 { 3516 3516 + return xerrors.Errorf("Value in field \"defaultBranch\" was too long") 3517 3517 + } 3518 3518 + 3519 3519 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil { 1460 3520 return err 1461 3521 } 1462 1462 - if _, err := cw.WriteString(string("createdAt")); err != nil { 3522 3522 + if _, err := cw.WriteString(string("defaultBranch")); err != nil { 1463 3523 return err 1464 3524 } 1465 3525 1466 1466 - if len(t.CreatedAt) > 1000000 { 1467 1467 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 3526 3526 + if len(t.DefaultBranch) > 1000000 { 3527 3527 + return xerrors.Errorf("Value in field t.DefaultBranch was too long") 1468 3528 } 1469 3529 1470 1470 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 3530 3530 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil { 1471 3531 return err 1472 3532 } 1473 1473 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 3533 3533 + if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil { 1474 3534 return err 1475 3535 } 1476 3536 return nil 1477 3537 } 1478 3538 1479 1479 - func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) { 1480 1480 - *t = RepoIssue{} 3539 3539 + func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) { 3540 3540 + *t = Pipeline_TriggerRepo{} 1481 3541 1482 3542 cr := cbg.NewCborReader(r) 1483 3543 ··· 1496 3556 } 1497 3557 1498 3558 if extra > cbg.MaxLength { 1499 1499 - return fmt.Errorf("RepoIssue: map struct too large (%d)", extra) 3559 3559 + return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra) 1500 3560 } 1501 3561 1502 3562 n := extra 1503 3563 1504 1504 - nameBuf := make([]byte, 9) 3564 3564 + nameBuf := make([]byte, 13) 1505 3565 for i := uint64(0); i < n; i++ { 1506 3566 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1507 3567 if err != nil { ··· 1517 3577 } 1518 3578 1519 3579 switch string(nameBuf[:nameLen]) { 1520 1520 - // t.Body (string) (string) 1521 1521 - case "body": 3580 3580 + // t.Did (string) (string) 3581 3581 + case "did": 1522 3582 1523 3583 { 1524 1524 - b, err := cr.ReadByte() 3584 3584 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1525 3585 if err != nil { 1526 3586 return err 1527 3587 } 1528 1528 - if b != cbg.CborNull[0] { 1529 1529 - if err := cr.UnreadByte(); err != nil { 1530 1530 - return err 1531 1531 - } 1532 3588 1533 1533 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1534 1534 - if err != nil { 1535 1535 - return err 1536 1536 - } 3589 3589 + t.Did = string(sval) 3590 3590 + } 3591 3591 + // t.Knot (string) (string) 3592 3592 + case "knot": 1537 3593 1538 1538 - t.Body = (*string)(&sval) 3594 3594 + { 3595 3595 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3596 3596 + if err != nil { 3597 3597 + return err 1539 3598 } 3599 3599 + 3600 3600 + t.Knot = string(sval) 1540 3601 } 1541 3602 // t.Repo (string) (string) 1542 3603 case "repo": ··· 1549 3610 1550 3611 t.Repo = string(sval) 1551 3612 } 1552 1552 - // t.LexiconTypeID (string) (string) 1553 1553 - case "$type": 3613 3613 + // t.DefaultBranch (string) (string) 3614 3614 + case "defaultBranch": 1554 3615 1555 3616 { 1556 3617 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1558 3619 return err 1559 3620 } 1560 3621 1561 1561 - t.LexiconTypeID = string(sval) 3622 3622 + t.DefaultBranch = string(sval) 1562 3623 } 1563 1563 - // t.Owner (string) (string) 1564 1564 - case "owner": 3624 3624 + 3625 3625 + default: 3626 3626 + // Field doesn't exist on this type, so ignore it 3627 3627 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3628 3628 + return err 3629 3629 + } 3630 3630 + } 3631 3631 + } 3632 3632 + 3633 3633 + return nil 3634 3634 + } 3635 3635 + func (t *PublicKey) MarshalCBOR(w io.Writer) error { 3636 3636 + if t == nil { 3637 3637 + _, err := w.Write(cbg.CborNull) 3638 3638 + return err 3639 3639 + } 3640 3640 + 3641 3641 + cw := cbg.NewCborWriter(w) 3642 3642 + 3643 3643 + if _, err := cw.Write([]byte{164}); err != nil { 3644 3644 + return err 3645 3645 + } 3646 3646 + 3647 3647 + // t.Key (string) (string) 3648 3648 + if len("key") > 1000000 { 3649 3649 + return xerrors.Errorf("Value in field \"key\" was too long") 3650 3650 + } 3651 3651 + 3652 3652 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3653 3653 + return err 3654 3654 + } 3655 3655 + if _, err := cw.WriteString(string("key")); err != nil { 3656 3656 + return err 3657 3657 + } 3658 3658 + 3659 3659 + if len(t.Key) > 1000000 { 3660 3660 + return xerrors.Errorf("Value in field t.Key was too long") 3661 3661 + } 3662 3662 + 3663 3663 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3664 3664 + return err 3665 3665 + } 3666 3666 + if _, err := cw.WriteString(string(t.Key)); err != nil { 3667 3667 + return err 3668 3668 + } 3669 3669 + 3670 3670 + // t.Name (string) (string) 3671 3671 + if len("name") > 1000000 { 3672 3672 + return xerrors.Errorf("Value in field \"name\" was too long") 3673 3673 + } 3674 3674 + 3675 3675 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 3676 3676 + return err 3677 3677 + } 3678 3678 + if _, err := cw.WriteString(string("name")); err != nil { 3679 3679 + return err 3680 3680 + } 3681 3681 + 3682 3682 + if len(t.Name) > 1000000 { 3683 3683 + return xerrors.Errorf("Value in field t.Name was too long") 3684 3684 + } 3685 3685 + 3686 3686 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 3687 3687 + return err 3688 3688 + } 3689 3689 + if _, err := cw.WriteString(string(t.Name)); err != nil { 3690 3690 + return err 3691 3691 + } 3692 3692 + 3693 3693 + // t.LexiconTypeID (string) (string) 3694 3694 + if len("$type") > 1000000 { 3695 3695 + return xerrors.Errorf("Value in field \"$type\" was too long") 3696 3696 + } 3697 3697 + 3698 3698 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 3699 3699 + return err 3700 3700 + } 3701 3701 + if _, err := cw.WriteString(string("$type")); err != nil { 3702 3702 + return err 3703 3703 + } 3704 3704 + 3705 3705 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil { 3706 3706 + return err 3707 3707 + } 3708 3708 + if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil { 3709 3709 + return err 3710 3710 + } 3711 3711 + 3712 3712 + // t.CreatedAt (string) (string) 3713 3713 + if len("createdAt") > 1000000 { 3714 3714 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 3715 3715 + } 3716 3716 + 3717 3717 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 3718 3718 + return err 3719 3719 + } 3720 3720 + if _, err := cw.WriteString(string("createdAt")); err != nil { 3721 3721 + return err 3722 3722 + } 3723 3723 + 3724 3724 + if len(t.CreatedAt) > 1000000 { 3725 3725 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 3726 3726 + } 3727 3727 + 3728 3728 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 3729 3729 + return err 3730 3730 + } 3731 3731 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 3732 3732 + return err 3733 3733 + } 3734 3734 + return nil 3735 3735 + } 3736 3736 + 3737 3737 + func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) { 3738 3738 + *t = PublicKey{} 3739 3739 + 3740 3740 + cr := cbg.NewCborReader(r) 3741 3741 + 3742 3742 + maj, extra, err := cr.ReadHeader() 3743 3743 + if err != nil { 3744 3744 + return err 3745 3745 + } 3746 3746 + defer func() { 3747 3747 + if err == io.EOF { 3748 3748 + err = io.ErrUnexpectedEOF 3749 3749 + } 3750 3750 + }() 3751 3751 + 3752 3752 + if maj != cbg.MajMap { 3753 3753 + return fmt.Errorf("cbor input should be of type map") 3754 3754 + } 3755 3755 + 3756 3756 + if extra > cbg.MaxLength { 3757 3757 + return fmt.Errorf("PublicKey: map struct too large (%d)", extra) 3758 3758 + } 3759 3759 + 3760 3760 + n := extra 3761 3761 + 3762 3762 + nameBuf := make([]byte, 9) 3763 3763 + for i := uint64(0); i < n; i++ { 3764 3764 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3765 3765 + if err != nil { 3766 3766 + return err 3767 3767 + } 3768 3768 + 3769 3769 + if !ok { 3770 3770 + // Field doesn't exist on this type, so ignore it 3771 3771 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3772 3772 + return err 3773 3773 + } 3774 3774 + continue 3775 3775 + } 3776 3776 + 3777 3777 + switch string(nameBuf[:nameLen]) { 3778 3778 + // t.Key (string) (string) 3779 3779 + case "key": 1565 3780 1566 3781 { 1567 3782 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1569 3784 return err 1570 3785 } 1571 3786 1572 1572 - t.Owner = string(sval) 3787 3787 + t.Key = string(sval) 1573 3788 } 1574 1574 - // t.Title (string) (string) 1575 1575 - case "title": 3789 3789 + // t.Name (string) (string) 3790 3790 + case "name": 1576 3791 1577 3792 { 1578 3793 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1580 3795 return err 1581 3796 } 1582 3797 1583 1583 - t.Title = string(sval) 3798 3798 + t.Name = string(sval) 1584 3799 } 1585 1585 - // t.IssueId (int64) (int64) 1586 1586 - case "issueId": 3800 3800 + // t.LexiconTypeID (string) (string) 3801 3801 + case "$type": 3802 3802 + 1587 3803 { 1588 1588 - maj, extra, err := cr.ReadHeader() 3804 3804 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1589 3805 if err != nil { 1590 3806 return err 1591 3807 } 1592 1592 - var extraI int64 1593 1593 - switch maj { 1594 1594 - case cbg.MajUnsignedInt: 1595 1595 - extraI = int64(extra) 1596 1596 - if extraI < 0 { 1597 1597 - return fmt.Errorf("int64 positive overflow") 1598 1598 - } 1599 1599 - case cbg.MajNegativeInt: 1600 1600 - extraI = int64(extra) 1601 1601 - if extraI < 0 { 1602 1602 - return fmt.Errorf("int64 negative overflow") 1603 1603 - } 1604 1604 - extraI = -1 - extraI 1605 1605 - default: 1606 1606 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1607 1607 - } 1608 3808 1609 1609 - t.IssueId = int64(extraI) 3809 3809 + t.LexiconTypeID = string(sval) 1610 3810 } 1611 3811 // t.CreatedAt (string) (string) 1612 3812 case "createdAt": ··· 1977 4177 1978 4178 return nil 1979 4179 } 1980 1980 - func (t *RepoPull) MarshalCBOR(w io.Writer) error { 4180 4180 + func (t *RepoArtifact) MarshalCBOR(w io.Writer) error { 1981 4181 if t == nil { 1982 4182 _, err := w.Write(cbg.CborNull) 1983 4183 return err 1984 4184 } 1985 4185 1986 4186 cw := cbg.NewCborWriter(w) 1987 1987 - fieldCount := 9 4187 4187 + fieldCount := 6 1988 4188 1989 1989 - if t.Body == nil { 4189 4189 + if t.Tag == nil { 1990 4190 fieldCount-- 1991 4191 } 1992 4192 1993 1993 - if t.Source == nil { 4193 4193 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 4194 4194 + return err 4195 4195 + } 4196 4196 + 4197 4197 + // t.Tag (util.LexBytes) (slice) 4198 4198 + if t.Tag != nil { 4199 4199 + 4200 4200 + if len("tag") > 1000000 { 4201 4201 + return xerrors.Errorf("Value in field \"tag\" was too long") 4202 4202 + } 4203 4203 + 4204 4204 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil { 4205 4205 + return err 4206 4206 + } 4207 4207 + if _, err := cw.WriteString(string("tag")); err != nil { 4208 4208 + return err 4209 4209 + } 4210 4210 + 4211 4211 + if len(t.Tag) > 2097152 { 4212 4212 + return xerrors.Errorf("Byte array in field t.Tag was too long") 4213 4213 + } 4214 4214 + 4215 4215 + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil { 4216 4216 + return err 4217 4217 + } 4218 4218 + 4219 4219 + if _, err := cw.Write(t.Tag); err != nil { 4220 4220 + return err 4221 4221 + } 4222 4222 + 4223 4223 + } 4224 4224 + 4225 4225 + // t.Name (string) (string) 4226 4226 + if len("name") > 1000000 { 4227 4227 + return xerrors.Errorf("Value in field \"name\" was too long") 4228 4228 + } 4229 4229 + 4230 4230 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 4231 4231 + return err 4232 4232 + } 4233 4233 + if _, err := cw.WriteString(string("name")); err != nil { 4234 4234 + return err 4235 4235 + } 4236 4236 + 4237 4237 + if len(t.Name) > 1000000 { 4238 4238 + return xerrors.Errorf("Value in field t.Name was too long") 4239 4239 + } 4240 4240 + 4241 4241 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 4242 4242 + return err 4243 4243 + } 4244 4244 + if _, err := cw.WriteString(string(t.Name)); err != nil { 4245 4245 + return err 4246 4246 + } 4247 4247 + 4248 4248 + // t.Repo (string) (string) 4249 4249 + if len("repo") > 1000000 { 4250 4250 + return xerrors.Errorf("Value in field \"repo\" was too long") 4251 4251 + } 4252 4252 + 4253 4253 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 4254 4254 + return err 4255 4255 + } 4256 4256 + if _, err := cw.WriteString(string("repo")); err != nil { 4257 4257 + return err 4258 4258 + } 4259 4259 + 4260 4260 + if len(t.Repo) > 1000000 { 4261 4261 + return xerrors.Errorf("Value in field t.Repo was too long") 4262 4262 + } 4263 4263 + 4264 4264 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 4265 4265 + return err 4266 4266 + } 4267 4267 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 4268 4268 + return err 4269 4269 + } 4270 4270 + 4271 4271 + // t.LexiconTypeID (string) (string) 4272 4272 + if len("$type") > 1000000 { 4273 4273 + return xerrors.Errorf("Value in field \"$type\" was too long") 4274 4274 + } 4275 4275 + 4276 4276 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4277 4277 + return err 4278 4278 + } 4279 4279 + if _, err := cw.WriteString(string("$type")); err != nil { 4280 4280 + return err 4281 4281 + } 4282 4282 + 4283 4283 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil { 4284 4284 + return err 4285 4285 + } 4286 4286 + if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 4287 4287 + return err 4288 4288 + } 4289 4289 + 4290 4290 + // t.Artifact (util.LexBlob) (struct) 4291 4291 + if len("artifact") > 1000000 { 4292 4292 + return xerrors.Errorf("Value in field \"artifact\" was too long") 4293 4293 + } 4294 4294 + 4295 4295 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil { 4296 4296 + return err 4297 4297 + } 4298 4298 + if _, err := cw.WriteString(string("artifact")); err != nil { 4299 4299 + return err 4300 4300 + } 4301 4301 + 4302 4302 + if err := t.Artifact.MarshalCBOR(cw); err != nil { 4303 4303 + return err 4304 4304 + } 4305 4305 + 4306 4306 + // t.CreatedAt (string) (string) 4307 4307 + if len("createdAt") > 1000000 { 4308 4308 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 4309 4309 + } 4310 4310 + 4311 4311 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 4312 4312 + return err 4313 4313 + } 4314 4314 + if _, err := cw.WriteString(string("createdAt")); err != nil { 4315 4315 + return err 4316 4316 + } 4317 4317 + 4318 4318 + if len(t.CreatedAt) > 1000000 { 4319 4319 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 4320 4320 + } 4321 4321 + 4322 4322 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 4323 4323 + return err 4324 4324 + } 4325 4325 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 4326 4326 + return err 4327 4327 + } 4328 4328 + return nil 4329 4329 + } 4330 4330 + 4331 4331 + func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) { 4332 4332 + *t = RepoArtifact{} 4333 4333 + 4334 4334 + cr := cbg.NewCborReader(r) 4335 4335 + 4336 4336 + maj, extra, err := cr.ReadHeader() 4337 4337 + if err != nil { 4338 4338 + return err 4339 4339 + } 4340 4340 + defer func() { 4341 4341 + if err == io.EOF { 4342 4342 + err = io.ErrUnexpectedEOF 4343 4343 + } 4344 4344 + }() 4345 4345 + 4346 4346 + if maj != cbg.MajMap { 4347 4347 + return fmt.Errorf("cbor input should be of type map") 4348 4348 + } 4349 4349 + 4350 4350 + if extra > cbg.MaxLength { 4351 4351 + return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra) 4352 4352 + } 4353 4353 + 4354 4354 + n := extra 4355 4355 + 4356 4356 + nameBuf := make([]byte, 9) 4357 4357 + for i := uint64(0); i < n; i++ { 4358 4358 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4359 4359 + if err != nil { 4360 4360 + return err 4361 4361 + } 4362 4362 + 4363 4363 + if !ok { 4364 4364 + // Field doesn't exist on this type, so ignore it 4365 4365 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4366 4366 + return err 4367 4367 + } 4368 4368 + continue 4369 4369 + } 4370 4370 + 4371 4371 + switch string(nameBuf[:nameLen]) { 4372 4372 + // t.Tag (util.LexBytes) (slice) 4373 4373 + case "tag": 4374 4374 + 4375 4375 + maj, extra, err = cr.ReadHeader() 4376 4376 + if err != nil { 4377 4377 + return err 4378 4378 + } 4379 4379 + 4380 4380 + if extra > 2097152 { 4381 4381 + return fmt.Errorf("t.Tag: byte array too large (%d)", extra) 4382 4382 + } 4383 4383 + if maj != cbg.MajByteString { 4384 4384 + return fmt.Errorf("expected byte array") 4385 4385 + } 4386 4386 + 4387 4387 + if extra > 0 { 4388 4388 + t.Tag = make([]uint8, extra) 4389 4389 + } 4390 4390 + 4391 4391 + if _, err := io.ReadFull(cr, t.Tag); err != nil { 4392 4392 + return err 4393 4393 + } 4394 4394 + 4395 4395 + // t.Name (string) (string) 4396 4396 + case "name": 4397 4397 + 4398 4398 + { 4399 4399 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4400 4400 + if err != nil { 4401 4401 + return err 4402 4402 + } 4403 4403 + 4404 4404 + t.Name = string(sval) 4405 4405 + } 4406 4406 + // t.Repo (string) (string) 4407 4407 + case "repo": 4408 4408 + 4409 4409 + { 4410 4410 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4411 4411 + if err != nil { 4412 4412 + return err 4413 4413 + } 4414 4414 + 4415 4415 + t.Repo = string(sval) 4416 4416 + } 4417 4417 + // t.LexiconTypeID (string) (string) 4418 4418 + case "$type": 4419 4419 + 4420 4420 + { 4421 4421 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4422 4422 + if err != nil { 4423 4423 + return err 4424 4424 + } 4425 4425 + 4426 4426 + t.LexiconTypeID = string(sval) 4427 4427 + } 4428 4428 + // t.Artifact (util.LexBlob) (struct) 4429 4429 + case "artifact": 4430 4430 + 4431 4431 + { 4432 4432 + 4433 4433 + b, err := cr.ReadByte() 4434 4434 + if err != nil { 4435 4435 + return err 4436 4436 + } 4437 4437 + if b != cbg.CborNull[0] { 4438 4438 + if err := cr.UnreadByte(); err != nil { 4439 4439 + return err 4440 4440 + } 4441 4441 + t.Artifact = new(util.LexBlob) 4442 4442 + if err := t.Artifact.UnmarshalCBOR(cr); err != nil { 4443 4443 + return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err) 4444 4444 + } 4445 4445 + } 4446 4446 + 4447 4447 + } 4448 4448 + // t.CreatedAt (string) (string) 4449 4449 + case "createdAt": 4450 4450 + 4451 4451 + { 4452 4452 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4453 4453 + if err != nil { 4454 4454 + return err 4455 4455 + } 4456 4456 + 4457 4457 + t.CreatedAt = string(sval) 4458 4458 + } 4459 4459 + 4460 4460 + default: 4461 4461 + // Field doesn't exist on this type, so ignore it 4462 4462 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4463 4463 + return err 4464 4464 + } 4465 4465 + } 4466 4466 + } 4467 4467 + 4468 4468 + return nil 4469 4469 + } 4470 4470 + func (t *RepoIssue) MarshalCBOR(w io.Writer) error { 4471 4471 + if t == nil { 4472 4472 + _, err := w.Write(cbg.CborNull) 4473 4473 + return err 4474 4474 + } 4475 4475 + 4476 4476 + cw := cbg.NewCborWriter(w) 4477 4477 + fieldCount := 7 4478 4478 + 4479 4479 + if t.Body == nil { 1994 4480 fieldCount-- 1995 4481 } 1996 4482 ··· 2030 4516 } 2031 4517 } 2032 4518 4519 4519 + // t.Repo (string) (string) 4520 4520 + if len("repo") > 1000000 { 4521 4521 + return xerrors.Errorf("Value in field \"repo\" was too long") 4522 4522 + } 4523 4523 + 4524 4524 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 4525 4525 + return err 4526 4526 + } 4527 4527 + if _, err := cw.WriteString(string("repo")); err != nil { 4528 4528 + return err 4529 4529 + } 4530 4530 + 4531 4531 + if len(t.Repo) > 1000000 { 4532 4532 + return xerrors.Errorf("Value in field t.Repo was too long") 4533 4533 + } 4534 4534 + 4535 4535 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 4536 4536 + return err 4537 4537 + } 4538 4538 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 4539 4539 + return err 4540 4540 + } 4541 4541 + 2033 4542 // t.LexiconTypeID (string) (string) 2034 4543 if len("$type") > 1000000 { 2035 4544 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 2042 4551 return err 2043 4552 } 2044 4553 2045 2045 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil { 4554 4554 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil { 2046 4555 return err 2047 4556 } 2048 2048 - if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil { 4557 4557 + if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil { 2049 4558 return err 2050 4559 } 2051 4560 2052 2052 - // t.Patch (string) (string) 2053 2053 - if len("patch") > 1000000 { 2054 2054 - return xerrors.Errorf("Value in field \"patch\" was too long") 4561 4561 + // t.Owner (string) (string) 4562 4562 + if len("owner") > 1000000 { 4563 4563 + return xerrors.Errorf("Value in field \"owner\" was too long") 2055 4564 } 2056 4565 2057 2057 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 4566 4566 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 2058 4567 return err 2059 4568 } 2060 2060 - if _, err := cw.WriteString(string("patch")); err != nil { 4569 4569 + if _, err := cw.WriteString(string("owner")); err != nil { 2061 4570 return err 2062 4571 } 2063 4572 2064 2064 - if len(t.Patch) > 1000000 { 2065 2065 - return xerrors.Errorf("Value in field t.Patch was too long") 4573 4573 + if len(t.Owner) > 1000000 { 4574 4574 + return xerrors.Errorf("Value in field t.Owner was too long") 2066 4575 } 2067 4576 2068 2068 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil { 4577 4577 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 2069 4578 return err 2070 4579 } 2071 2071 - if _, err := cw.WriteString(string(t.Patch)); err != nil { 4580 4580 + if _, err := cw.WriteString(string(t.Owner)); err != nil { 2072 4581 return err 2073 4582 } 2074 4583 ··· 2095 4604 return err 2096 4605 } 2097 4606 2098 2098 - // t.PullId (int64) (int64) 2099 2099 - if len("pullId") > 1000000 { 2100 2100 - return xerrors.Errorf("Value in field \"pullId\" was too long") 4607 4607 + // t.IssueId (int64) (int64) 4608 4608 + if len("issueId") > 1000000 { 4609 4609 + return xerrors.Errorf("Value in field \"issueId\" was too long") 2101 4610 } 2102 4611 2103 2103 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil { 4612 4612 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil { 2104 4613 return err 2105 4614 } 2106 2106 - if _, err := cw.WriteString(string("pullId")); err != nil { 4615 4615 + if _, err := cw.WriteString(string("issueId")); err != nil { 2107 4616 return err 2108 4617 } 2109 4618 2110 2110 - if t.PullId >= 0 { 2111 2111 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil { 4619 4619 + if t.IssueId >= 0 { 4620 4620 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil { 2112 4621 return err 2113 4622 } 2114 4623 } else { 2115 2115 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil { 2116 2116 - return err 2117 2117 - } 2118 2118 - } 2119 2119 - 2120 2120 - // t.Source (tangled.RepoPull_Source) (struct) 2121 2121 - if t.Source != nil { 2122 2122 - 2123 2123 - if len("source") > 1000000 { 2124 2124 - return xerrors.Errorf("Value in field \"source\" was too long") 2125 2125 - } 2126 2126 - 2127 2127 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 2128 2128 - return err 2129 2129 - } 2130 2130 - if _, err := cw.WriteString(string("source")); err != nil { 2131 2131 - return err 2132 2132 - } 2133 2133 - 2134 2134 - if err := t.Source.MarshalCBOR(cw); err != nil { 4624 4624 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil { 2135 4625 return err 2136 4626 } 2137 4627 } ··· 2158 4648 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2159 4649 return err 2160 4650 } 2161 2161 - 2162 2162 - // t.TargetRepo (string) (string) 2163 2163 - if len("targetRepo") > 1000000 { 2164 2164 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 2165 2165 - } 2166 2166 - 2167 2167 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 2168 2168 - return err 2169 2169 - } 2170 2170 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 2171 2171 - return err 2172 2172 - } 2173 2173 - 2174 2174 - if len(t.TargetRepo) > 1000000 { 2175 2175 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 2176 2176 - } 2177 2177 - 2178 2178 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 2179 2179 - return err 2180 2180 - } 2181 2181 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 2182 2182 - return err 2183 2183 - } 2184 2184 - 2185 2185 - // t.TargetBranch (string) (string) 2186 2186 - if len("targetBranch") > 1000000 { 2187 2187 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 2188 2188 - } 2189 2189 - 2190 2190 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 2191 2191 - return err 2192 2192 - } 2193 2193 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 2194 2194 - return err 2195 2195 - } 2196 2196 - 2197 2197 - if len(t.TargetBranch) > 1000000 { 2198 2198 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 2199 2199 - } 2200 2200 - 2201 2201 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 2202 2202 - return err 2203 2203 - } 2204 2204 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 2205 2205 - return err 2206 2206 - } 2207 4651 return nil 2208 4652 } 2209 4653 2210 2210 - func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) { 2211 2211 - *t = RepoPull{} 4654 4654 + func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) { 4655 4655 + *t = RepoIssue{} 2212 4656 2213 4657 cr := cbg.NewCborReader(r) 2214 4658 ··· 2227 4671 } 2228 4672 2229 4673 if extra > cbg.MaxLength { 2230 2230 - return fmt.Errorf("RepoPull: map struct too large (%d)", extra) 4674 4674 + return fmt.Errorf("RepoIssue: map struct too large (%d)", extra) 2231 4675 } 2232 4676 2233 4677 n := extra 2234 4678 2235 2235 - nameBuf := make([]byte, 12) 4679 4679 + nameBuf := make([]byte, 9) 2236 4680 for i := uint64(0); i < n; i++ { 2237 4681 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2238 4682 if err != nil { ··· 2269 4713 t.Body = (*string)(&sval) 2270 4714 } 2271 4715 } 4716 4716 + // t.Repo (string) (string) 4717 4717 + case "repo": 4718 4718 + 4719 4719 + { 4720 4720 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4721 4721 + if err != nil { 4722 4722 + return err 4723 4723 + } 4724 4724 + 4725 4725 + t.Repo = string(sval) 4726 4726 + } 2272 4727 // t.LexiconTypeID (string) (string) 2273 4728 case "$type": 2274 4729 ··· 2280 4735 2281 4736 t.LexiconTypeID = string(sval) 2282 4737 } 2283 2283 - // t.Patch (string) (string) 2284 2284 - case "patch": 4738 4738 + // t.Owner (string) (string) 4739 4739 + case "owner": 2285 4740 2286 4741 { 2287 4742 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 2289 4744 return err 2290 4745 } 2291 4746 2292 2292 - t.Patch = string(sval) 4747 4747 + t.Owner = string(sval) 2293 4748 } 2294 4749 // t.Title (string) (string) 2295 4750 case "title": ··· 2302 4757 2303 4758 t.Title = string(sval) 2304 4759 } 2305 2305 - // t.PullId (int64) (int64) 2306 2306 - case "pullId": 4760 4760 + // t.IssueId (int64) (int64) 4761 4761 + case "issueId": 2307 4762 { 2308 4763 maj, extra, err := cr.ReadHeader() 2309 4764 if err != nil { ··· 2326 4781 return fmt.Errorf("wrong type for int64 field: %d", maj) 2327 4782 } 2328 4783 2329 2329 - t.PullId = int64(extraI) 2330 2330 - } 2331 2331 - // t.Source (tangled.RepoPull_Source) (struct) 2332 2332 - case "source": 2333 2333 - 2334 2334 - { 2335 2335 - 2336 2336 - b, err := cr.ReadByte() 2337 2337 - if err != nil { 2338 2338 - return err 2339 2339 - } 2340 2340 - if b != cbg.CborNull[0] { 2341 2341 - if err := cr.UnreadByte(); err != nil { 2342 2342 - return err 2343 2343 - } 2344 2344 - t.Source = new(RepoPull_Source) 2345 2345 - if err := t.Source.UnmarshalCBOR(cr); err != nil { 2346 2346 - return xerrors.Errorf("unmarshaling t.Source pointer: %w", err) 2347 2347 - } 2348 2348 - } 2349 2349 - 4784 4784 + t.IssueId = int64(extraI) 2350 4785 } 2351 4786 // t.CreatedAt (string) (string) 2352 4787 case "createdAt": ··· 2359 4794 2360 4795 t.CreatedAt = string(sval) 2361 4796 } 2362 2362 - // t.TargetRepo (string) (string) 2363 2363 - case "targetRepo": 2364 2364 - 2365 2365 - { 2366 2366 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2367 2367 - if err != nil { 2368 2368 - return err 2369 2369 - } 2370 2370 - 2371 2371 - t.TargetRepo = string(sval) 2372 2372 - } 2373 2373 - // t.TargetBranch (string) (string) 2374 2374 - case "targetBranch": 2375 2375 - 2376 2376 - { 2377 2377 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2378 2378 - if err != nil { 2379 2379 - return err 2380 2380 - } 2381 2381 - 2382 2382 - t.TargetBranch = string(sval) 2383 2383 - } 2384 4797 2385 4798 default: 2386 4799 // Field doesn't exist on this type, so ignore it ··· 2392 4805 2393 4806 return nil 2394 4807 } 2395 2395 - func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 4808 4808 + func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error { 2396 4809 if t == nil { 2397 4810 _, err := w.Write(cbg.CborNull) 2398 4811 return err 2399 4812 } 2400 4813 2401 4814 cw := cbg.NewCborWriter(w) 2402 2402 - fieldCount := 2 4815 4815 + fieldCount := 7 4816 4816 + 4817 4817 + if t.CommentId == nil { 4818 4818 + fieldCount-- 4819 4819 + } 4820 4820 + 4821 4821 + if t.Owner == nil { 4822 4822 + fieldCount-- 4823 4823 + } 2403 4824 2404 4825 if t.Repo == nil { 2405 4826 fieldCount-- ··· 2409 4830 return err 2410 4831 } 2411 4832 4833 4833 + // t.Body (string) (string) 4834 4834 + if len("body") > 1000000 { 4835 4835 + return xerrors.Errorf("Value in field \"body\" was too long") 4836 4836 + } 4837 4837 + 4838 4838 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 4839 4839 + return err 4840 4840 + } 4841 4841 + if _, err := cw.WriteString(string("body")); err != nil { 4842 4842 + return err 4843 4843 + } 4844 4844 + 4845 4845 + if len(t.Body) > 1000000 { 4846 4846 + return xerrors.Errorf("Value in field t.Body was too long") 4847 4847 + } 4848 4848 + 4849 4849 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 4850 4850 + return err 4851 4851 + } 4852 4852 + if _, err := cw.WriteString(string(t.Body)); err != nil { 4853 4853 + return err 4854 4854 + } 4855 4855 + 2412 4856 // t.Repo (string) (string) 2413 4857 if t.Repo != nil { 2414 4858 ··· 2441 4885 } 2442 4886 } 2443 4887 2444 2444 - // t.Branch (string) (string) 2445 2445 - if len("branch") > 1000000 { 2446 2446 - return xerrors.Errorf("Value in field \"branch\" was too long") 4888 4888 + // t.LexiconTypeID (string) (string) 4889 4889 + if len("$type") > 1000000 { 4890 4890 + return xerrors.Errorf("Value in field \"$type\" was too long") 4891 4891 + } 4892 4892 + 4893 4893 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4894 4894 + return err 4895 4895 + } 4896 4896 + if _, err := cw.WriteString(string("$type")); err != nil { 4897 4897 + return err 4898 4898 + } 4899 4899 + 4900 4900 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil { 4901 4901 + return err 4902 4902 + } 4903 4903 + if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil { 4904 4904 + return err 4905 4905 + } 4906 4906 + 4907 4907 + // t.Issue (string) (string) 4908 4908 + if len("issue") > 1000000 { 4909 4909 + return xerrors.Errorf("Value in field \"issue\" was too long") 4910 4910 + } 4911 4911 + 4912 4912 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 4913 4913 + return err 4914 4914 + } 4915 4915 + if _, err := cw.WriteString(string("issue")); err != nil { 4916 4916 + return err 4917 4917 + } 4918 4918 + 4919 4919 + if len(t.Issue) > 1000000 { 4920 4920 + return xerrors.Errorf("Value in field t.Issue was too long") 4921 4921 + } 4922 4922 + 4923 4923 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 4924 4924 + return err 4925 4925 + } 4926 4926 + if _, err := cw.WriteString(string(t.Issue)); err != nil { 4927 4927 + return err 4928 4928 + } 4929 4929 + 4930 4930 + // t.Owner (string) (string) 4931 4931 + if t.Owner != nil { 4932 4932 + 4933 4933 + if len("owner") > 1000000 { 4934 4934 + return xerrors.Errorf("Value in field \"owner\" was too long") 4935 4935 + } 4936 4936 + 4937 4937 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 4938 4938 + return err 4939 4939 + } 4940 4940 + if _, err := cw.WriteString(string("owner")); err != nil { 4941 4941 + return err 4942 4942 + } 4943 4943 + 4944 4944 + if t.Owner == nil { 4945 4945 + if _, err := cw.Write(cbg.CborNull); err != nil { 4946 4946 + return err 4947 4947 + } 4948 4948 + } else { 4949 4949 + if len(*t.Owner) > 1000000 { 4950 4950 + return xerrors.Errorf("Value in field t.Owner was too long") 4951 4951 + } 4952 4952 + 4953 4953 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil { 4954 4954 + return err 4955 4955 + } 4956 4956 + if _, err := cw.WriteString(string(*t.Owner)); err != nil { 4957 4957 + return err 4958 4958 + } 4959 4959 + } 4960 4960 + } 4961 4961 + 4962 4962 + // t.CommentId (int64) (int64) 4963 4963 + if t.CommentId != nil { 4964 4964 + 4965 4965 + if len("commentId") > 1000000 { 4966 4966 + return xerrors.Errorf("Value in field \"commentId\" was too long") 4967 4967 + } 4968 4968 + 4969 4969 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil { 4970 4970 + return err 4971 4971 + } 4972 4972 + if _, err := cw.WriteString(string("commentId")); err != nil { 4973 4973 + return err 4974 4974 + } 4975 4975 + 4976 4976 + if t.CommentId == nil { 4977 4977 + if _, err := cw.Write(cbg.CborNull); err != nil { 4978 4978 + return err 4979 4979 + } 4980 4980 + } else { 4981 4981 + if *t.CommentId >= 0 { 4982 4982 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil { 4983 4983 + return err 4984 4984 + } 4985 4985 + } else { 4986 4986 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil { 4987 4987 + return err 4988 4988 + } 4989 4989 + } 4990 4990 + } 4991 4991 + 4992 4992 + } 4993 4993 + 4994 4994 + // t.CreatedAt (string) (string) 4995 4995 + if len("createdAt") > 1000000 { 4996 4996 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2447 4997 } 2448 4998 2449 2449 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 4999 4999 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2450 5000 return err 2451 5001 } 2452 2452 - if _, err := cw.WriteString(string("branch")); err != nil { 5002 5002 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2453 5003 return err 2454 5004 } 2455 5005 2456 2456 - if len(t.Branch) > 1000000 { 2457 2457 - return xerrors.Errorf("Value in field t.Branch was too long") 5006 5006 + if len(t.CreatedAt) > 1000000 { 5007 5007 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2458 5008 } 2459 5009 2460 2460 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 5010 5010 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2461 5011 return err 2462 5012 } 2463 2463 - if _, err := cw.WriteString(string(t.Branch)); err != nil { 5013 5013 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2464 5014 return err 2465 5015 } 2466 5016 return nil 2467 5017 } 2468 5018 2469 2469 - func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) { 2470 2470 - *t = RepoPull_Source{} 5019 5019 + func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) { 5020 5020 + *t = RepoIssueComment{} 2471 5021 2472 5022 cr := cbg.NewCborReader(r) 2473 5023 ··· 2486 5036 } 2487 5037 2488 5038 if extra > cbg.MaxLength { 2489 2489 - return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra) 5039 5039 + return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra) 2490 5040 } 2491 5041 2492 5042 n := extra 2493 5043 2494 2494 - nameBuf := make([]byte, 6) 5044 5044 + nameBuf := make([]byte, 9) 2495 5045 for i := uint64(0); i < n; i++ { 2496 5046 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2497 5047 if err != nil { ··· 2507 5057 } 2508 5058 2509 5059 switch string(nameBuf[:nameLen]) { 2510 2510 - // t.Repo (string) (string) 5060 5060 + // t.Body (string) (string) 5061 5061 + case "body": 5062 5062 + 5063 5063 + { 5064 5064 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5065 5065 + if err != nil { 5066 5066 + return err 5067 5067 + } 5068 5068 + 5069 5069 + t.Body = string(sval) 5070 5070 + } 5071 5071 + // t.Repo (string) (string) 2511 5072 case "repo": 2512 5073 2513 5074 { ··· 2528 5089 t.Repo = (*string)(&sval) 2529 5090 } 2530 5091 } 2531 2531 - // t.Branch (string) (string) 2532 2532 - case "branch": 5092 5092 + // t.LexiconTypeID (string) (string) 5093 5093 + case "$type": 5094 5094 + 5095 5095 + { 5096 5096 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5097 5097 + if err != nil { 5098 5098 + return err 5099 5099 + } 5100 5100 + 5101 5101 + t.LexiconTypeID = string(sval) 5102 5102 + } 5103 5103 + // t.Issue (string) (string) 5104 5104 + case "issue": 5105 5105 + 5106 5106 + { 5107 5107 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5108 5108 + if err != nil { 5109 5109 + return err 5110 5110 + } 5111 5111 + 5112 5112 + t.Issue = string(sval) 5113 5113 + } 5114 5114 + // t.Owner (string) (string) 5115 5115 + case "owner": 5116 5116 + 5117 5117 + { 5118 5118 + b, err := cr.ReadByte() 5119 5119 + if err != nil { 5120 5120 + return err 5121 5121 + } 5122 5122 + if b != cbg.CborNull[0] { 5123 5123 + if err := cr.UnreadByte(); err != nil { 5124 5124 + return err 5125 5125 + } 5126 5126 + 5127 5127 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5128 5128 + if err != nil { 5129 5129 + return err 5130 5130 + } 5131 5131 + 5132 5132 + t.Owner = (*string)(&sval) 5133 5133 + } 5134 5134 + } 5135 5135 + // t.CommentId (int64) (int64) 5136 5136 + case "commentId": 5137 5137 + { 5138 5138 + 5139 5139 + b, err := cr.ReadByte() 5140 5140 + if err != nil { 5141 5141 + return err 5142 5142 + } 5143 5143 + if b != cbg.CborNull[0] { 5144 5144 + if err := cr.UnreadByte(); err != nil { 5145 5145 + return err 5146 5146 + } 5147 5147 + maj, extra, err := cr.ReadHeader() 5148 5148 + if err != nil { 5149 5149 + return err 5150 5150 + } 5151 5151 + var extraI int64 5152 5152 + switch maj { 5153 5153 + case cbg.MajUnsignedInt: 5154 5154 + extraI = int64(extra) 5155 5155 + if extraI < 0 { 5156 5156 + return fmt.Errorf("int64 positive overflow") 5157 5157 + } 5158 5158 + case cbg.MajNegativeInt: 5159 5159 + extraI = int64(extra) 5160 5160 + if extraI < 0 { 5161 5161 + return fmt.Errorf("int64 negative overflow") 5162 5162 + } 5163 5163 + extraI = -1 - extraI 5164 5164 + default: 5165 5165 + return fmt.Errorf("wrong type for int64 field: %d", maj) 5166 5166 + } 5167 5167 + 5168 5168 + t.CommentId = (*int64)(&extraI) 5169 5169 + } 5170 5170 + } 5171 5171 + // t.CreatedAt (string) (string) 5172 5172 + case "createdAt": 2533 5173 2534 5174 { 2535 5175 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 2537 5177 return err 2538 5178 } 2539 5179 2540 2540 - t.Branch = string(sval) 5180 5180 + t.CreatedAt = string(sval) 2541 5181 } 2542 5182 2543 5183 default: ··· 2550 5190 2551 5191 return nil 2552 5192 } 2553 2553 - func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 5193 5193 + func (t *RepoIssueState) MarshalCBOR(w io.Writer) error { 2554 5194 if t == nil { 2555 5195 _, err := w.Write(cbg.CborNull) 2556 5196 return err ··· 2562 5202 return err 2563 5203 } 2564 5204 2565 2565 - // t.Pull (string) (string) 2566 2566 - if len("pull") > 1000000 { 2567 2567 - return xerrors.Errorf("Value in field \"pull\" was too long") 5205 5205 + // t.LexiconTypeID (string) (string) 5206 5206 + if len("$type") > 1000000 { 5207 5207 + return xerrors.Errorf("Value in field \"$type\" was too long") 5208 5208 + } 5209 5209 + 5210 5210 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 5211 5211 + return err 5212 5212 + } 5213 5213 + if _, err := cw.WriteString(string("$type")); err != nil { 5214 5214 + return err 5215 5215 + } 5216 5216 + 5217 5217 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil { 5218 5218 + return err 5219 5219 + } 5220 5220 + if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil { 5221 5221 + return err 5222 5222 + } 5223 5223 + 5224 5224 + // t.Issue (string) (string) 5225 5225 + if len("issue") > 1000000 { 5226 5226 + return xerrors.Errorf("Value in field \"issue\" was too long") 5227 5227 + } 5228 5228 + 5229 5229 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 5230 5230 + return err 5231 5231 + } 5232 5232 + if _, err := cw.WriteString(string("issue")); err != nil { 5233 5233 + return err 5234 5234 + } 5235 5235 + 5236 5236 + if len(t.Issue) > 1000000 { 5237 5237 + return xerrors.Errorf("Value in field t.Issue was too long") 2568 5238 } 2569 5239 2570 2570 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 5240 5240 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 2571 5241 return err 2572 5242 } 2573 2573 - if _, err := cw.WriteString(string("pull")); err != nil { 5243 5243 + if _, err := cw.WriteString(string(t.Issue)); err != nil { 2574 5244 return err 2575 5245 } 2576 5246 2577 2577 - if len(t.Pull) > 1000000 { 2578 2578 - return xerrors.Errorf("Value in field t.Pull was too long") 5247 5247 + // t.State (string) (string) 5248 5248 + if len("state") > 1000000 { 5249 5249 + return xerrors.Errorf("Value in field \"state\" was too long") 2579 5250 } 2580 5251 2581 2581 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 5252 5252 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 2582 5253 return err 2583 5254 } 2584 2584 - if _, err := cw.WriteString(string(t.Pull)); err != nil { 5255 5255 + if _, err := cw.WriteString(string("state")); err != nil { 2585 5256 return err 2586 5257 } 2587 5258 5259 5259 + if len(t.State) > 1000000 { 5260 5260 + return xerrors.Errorf("Value in field t.State was too long") 5261 5261 + } 5262 5262 + 5263 5263 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 5264 5264 + return err 5265 5265 + } 5266 5266 + if _, err := cw.WriteString(string(t.State)); err != nil { 5267 5267 + return err 5268 5268 + } 5269 5269 + return nil 5270 5270 + } 5271 5271 + 5272 5272 + func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) { 5273 5273 + *t = RepoIssueState{} 5274 5274 + 5275 5275 + cr := cbg.NewCborReader(r) 5276 5276 + 5277 5277 + maj, extra, err := cr.ReadHeader() 5278 5278 + if err != nil { 5279 5279 + return err 5280 5280 + } 5281 5281 + defer func() { 5282 5282 + if err == io.EOF { 5283 5283 + err = io.ErrUnexpectedEOF 5284 5284 + } 5285 5285 + }() 5286 5286 + 5287 5287 + if maj != cbg.MajMap { 5288 5288 + return fmt.Errorf("cbor input should be of type map") 5289 5289 + } 5290 5290 + 5291 5291 + if extra > cbg.MaxLength { 5292 5292 + return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra) 5293 5293 + } 5294 5294 + 5295 5295 + n := extra 5296 5296 + 5297 5297 + nameBuf := make([]byte, 5) 5298 5298 + for i := uint64(0); i < n; i++ { 5299 5299 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5300 5300 + if err != nil { 5301 5301 + return err 5302 5302 + } 5303 5303 + 5304 5304 + if !ok { 5305 5305 + // Field doesn't exist on this type, so ignore it 5306 5306 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5307 5307 + return err 5308 5308 + } 5309 5309 + continue 5310 5310 + } 5311 5311 + 5312 5312 + switch string(nameBuf[:nameLen]) { 5313 5313 + // t.LexiconTypeID (string) (string) 5314 5314 + case "$type": 5315 5315 + 5316 5316 + { 5317 5317 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5318 5318 + if err != nil { 5319 5319 + return err 5320 5320 + } 5321 5321 + 5322 5322 + t.LexiconTypeID = string(sval) 5323 5323 + } 5324 5324 + // t.Issue (string) (string) 5325 5325 + case "issue": 5326 5326 + 5327 5327 + { 5328 5328 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5329 5329 + if err != nil { 5330 5330 + return err 5331 5331 + } 5332 5332 + 5333 5333 + t.Issue = string(sval) 5334 5334 + } 5335 5335 + // t.State (string) (string) 5336 5336 + case "state": 5337 5337 + 5338 5338 + { 5339 5339 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5340 5340 + if err != nil { 5341 5341 + return err 5342 5342 + } 5343 5343 + 5344 5344 + t.State = string(sval) 5345 5345 + } 5346 5346 + 5347 5347 + default: 5348 5348 + // Field doesn't exist on this type, so ignore it 5349 5349 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5350 5350 + return err 5351 5351 + } 5352 5352 + } 5353 5353 + } 5354 5354 + 5355 5355 + return nil 5356 5356 + } 5357 5357 + func (t *RepoPull) MarshalCBOR(w io.Writer) error { 5358 5358 + if t == nil { 5359 5359 + _, err := w.Write(cbg.CborNull) 5360 5360 + return err 5361 5361 + } 5362 5362 + 5363 5363 + cw := cbg.NewCborWriter(w) 5364 5364 + fieldCount := 9 5365 5365 + 5366 5366 + if t.Body == nil { 5367 5367 + fieldCount-- 5368 5368 + } 5369 5369 + 5370 5370 + if t.Source == nil { 5371 5371 + fieldCount-- 5372 5372 + } 5373 5373 + 5374 5374 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 5375 5375 + return err 5376 5376 + } 5377 5377 + 5378 5378 + // t.Body (string) (string) 5379 5379 + if t.Body != nil { 5380 5380 + 5381 5381 + if len("body") > 1000000 { 5382 5382 + return xerrors.Errorf("Value in field \"body\" was too long") 5383 5383 + } 5384 5384 + 5385 5385 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 5386 5386 + return err 5387 5387 + } 5388 5388 + if _, err := cw.WriteString(string("body")); err != nil { 5389 5389 + return err 5390 5390 + } 5391 5391 + 5392 5392 + if t.Body == nil { 5393 5393 + if _, err := cw.Write(cbg.CborNull); err != nil { 5394 5394 + return err 5395 5395 + } 5396 5396 + } else { 5397 5397 + if len(*t.Body) > 1000000 { 5398 5398 + return xerrors.Errorf("Value in field t.Body was too long") 5399 5399 + } 5400 5400 + 5401 5401 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 5402 5402 + return err 5403 5403 + } 5404 5404 + if _, err := cw.WriteString(string(*t.Body)); err != nil { 5405 5405 + return err 5406 5406 + } 5407 5407 + } 5408 5408 + } 5409 5409 + 2588 5410 // t.LexiconTypeID (string) (string) 2589 5411 if len("$type") > 1000000 { 2590 5412 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 2597 5419 return err 2598 5420 } 2599 5421 2600 2600 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 5422 5422 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil { 2601 5423 return err 2602 5424 } 2603 2603 - if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 5425 5425 + if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil { 2604 5426 return err 2605 5427 } 2606 5428 2607 2607 - // t.Status (string) (string) 2608 2608 - if len("status") > 1000000 { 2609 2609 - return xerrors.Errorf("Value in field \"status\" was too long") 5429 5429 + // t.Patch (string) (string) 5430 5430 + if len("patch") > 1000000 { 5431 5431 + return xerrors.Errorf("Value in field \"patch\" was too long") 5432 5432 + } 5433 5433 + 5434 5434 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 5435 5435 + return err 5436 5436 + } 5437 5437 + if _, err := cw.WriteString(string("patch")); err != nil { 5438 5438 + return err 5439 5439 + } 5440 5440 + 5441 5441 + if len(t.Patch) > 1000000 { 5442 5442 + return xerrors.Errorf("Value in field t.Patch was too long") 5443 5443 + } 5444 5444 + 5445 5445 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil { 5446 5446 + return err 5447 5447 + } 5448 5448 + if _, err := cw.WriteString(string(t.Patch)); err != nil { 5449 5449 + return err 5450 5450 + } 5451 5451 + 5452 5452 + // t.Title (string) (string) 5453 5453 + if len("title") > 1000000 { 5454 5454 + return xerrors.Errorf("Value in field \"title\" was too long") 5455 5455 + } 5456 5456 + 5457 5457 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 5458 5458 + return err 5459 5459 + } 5460 5460 + if _, err := cw.WriteString(string("title")); err != nil { 5461 5461 + return err 5462 5462 + } 5463 5463 + 5464 5464 + if len(t.Title) > 1000000 { 5465 5465 + return xerrors.Errorf("Value in field t.Title was too long") 5466 5466 + } 5467 5467 + 5468 5468 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 5469 5469 + return err 5470 5470 + } 5471 5471 + if _, err := cw.WriteString(string(t.Title)); err != nil { 5472 5472 + return err 5473 5473 + } 5474 5474 + 5475 5475 + // t.PullId (int64) (int64) 5476 5476 + if len("pullId") > 1000000 { 5477 5477 + return xerrors.Errorf("Value in field \"pullId\" was too long") 5478 5478 + } 5479 5479 + 5480 5480 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil { 5481 5481 + return err 5482 5482 + } 5483 5483 + if _, err := cw.WriteString(string("pullId")); err != nil { 5484 5484 + return err 5485 5485 + } 5486 5486 + 5487 5487 + if t.PullId >= 0 { 5488 5488 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil { 5489 5489 + return err 5490 5490 + } 5491 5491 + } else { 5492 5492 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil { 5493 5493 + return err 5494 5494 + } 5495 5495 + } 5496 5496 + 5497 5497 + // t.Source (tangled.RepoPull_Source) (struct) 5498 5498 + if t.Source != nil { 5499 5499 + 5500 5500 + if len("source") > 1000000 { 5501 5501 + return xerrors.Errorf("Value in field \"source\" was too long") 5502 5502 + } 5503 5503 + 5504 5504 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 5505 5505 + return err 5506 5506 + } 5507 5507 + if _, err := cw.WriteString(string("source")); err != nil { 5508 5508 + return err 5509 5509 + } 5510 5510 + 5511 5511 + if err := t.Source.MarshalCBOR(cw); err != nil { 5512 5512 + return err 5513 5513 + } 5514 5514 + } 5515 5515 + 5516 5516 + // t.CreatedAt (string) (string) 5517 5517 + if len("createdAt") > 1000000 { 5518 5518 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 5519 5519 + } 5520 5520 + 5521 5521 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 5522 5522 + return err 5523 5523 + } 5524 5524 + if _, err := cw.WriteString(string("createdAt")); err != nil { 5525 5525 + return err 5526 5526 + } 5527 5527 + 5528 5528 + if len(t.CreatedAt) > 1000000 { 5529 5529 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 5530 5530 + } 5531 5531 + 5532 5532 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 5533 5533 + return err 5534 5534 + } 5535 5535 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 5536 5536 + return err 5537 5537 + } 5538 5538 + 5539 5539 + // t.TargetRepo (string) (string) 5540 5540 + if len("targetRepo") > 1000000 { 5541 5541 + return xerrors.Errorf("Value in field \"targetRepo\" was too long") 5542 5542 + } 5543 5543 + 5544 5544 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 5545 5545 + return err 5546 5546 + } 5547 5547 + if _, err := cw.WriteString(string("targetRepo")); err != nil { 5548 5548 + return err 5549 5549 + } 5550 5550 + 5551 5551 + if len(t.TargetRepo) > 1000000 { 5552 5552 + return xerrors.Errorf("Value in field t.TargetRepo was too long") 5553 5553 + } 5554 5554 + 5555 5555 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 5556 5556 + return err 5557 5557 + } 5558 5558 + if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 5559 5559 + return err 5560 5560 + } 5561 5561 + 5562 5562 + // t.TargetBranch (string) (string) 5563 5563 + if len("targetBranch") > 1000000 { 5564 5564 + return xerrors.Errorf("Value in field \"targetBranch\" was too long") 2610 5565 } 2611 5566 2612 2612 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 5567 5567 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 2613 5568 return err 2614 5569 } 2615 2615 - if _, err := cw.WriteString(string("status")); err != nil { 5570 5570 + if _, err := cw.WriteString(string("targetBranch")); err != nil { 2616 5571 return err 2617 5572 } 2618 5573 2619 2619 - if len(t.Status) > 1000000 { 2620 2620 - return xerrors.Errorf("Value in field t.Status was too long") 5574 5574 + if len(t.TargetBranch) > 1000000 { 5575 5575 + return xerrors.Errorf("Value in field t.TargetBranch was too long") 2621 5576 } 2622 5577 2623 2623 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 5578 5578 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 2624 5579 return err 2625 5580 } 2626 2626 - if _, err := cw.WriteString(string(t.Status)); err != nil { 5581 5581 + if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 2627 5582 return err 2628 5583 } 2629 5584 return nil 2630 5585 } 2631 5586 2632 2632 - func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 2633 2633 - *t = RepoPullStatus{} 5587 5587 + func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) { 5588 5588 + *t = RepoPull{} 2634 5589 2635 5590 cr := cbg.NewCborReader(r) 2636 5591 ··· 2649 5604 } 2650 5605 2651 5606 if extra > cbg.MaxLength { 2652 2652 - return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 5607 5607 + return fmt.Errorf("RepoPull: map struct too large (%d)", extra) 2653 5608 } 2654 5609 2655 5610 n := extra 2656 5611 2657 2657 - nameBuf := make([]byte, 6) 5612 5612 + nameBuf := make([]byte, 12) 2658 5613 for i := uint64(0); i < n; i++ { 2659 5614 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2660 5615 if err != nil { ··· 2670 5625 } 2671 5626 2672 5627 switch string(nameBuf[:nameLen]) { 2673 2673 - // t.Pull (string) (string) 2674 2674 - case "pull": 5628 5628 + // t.Body (string) (string) 5629 5629 + case "body": 2675 5630 2676 5631 { 2677 2677 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5632 5632 + b, err := cr.ReadByte() 2678 5633 if err != nil { 2679 5634 return err 2680 5635 } 5636 5636 + if b != cbg.CborNull[0] { 5637 5637 + if err := cr.UnreadByte(); err != nil { 5638 5638 + return err 5639 5639 + } 2681 5640 2682 2682 - t.Pull = string(sval) 5641 5641 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5642 5642 + if err != nil { 5643 5643 + return err 5644 5644 + } 5645 5645 + 5646 5646 + t.Body = (*string)(&sval) 5647 5647 + } 2683 5648 } 2684 5649 // t.LexiconTypeID (string) (string) 2685 5650 case "$type": ··· 2692 5657 2693 5658 t.LexiconTypeID = string(sval) 2694 5659 } 2695 2695 - // t.Status (string) (string) 2696 2696 - case "status": 5660 5660 + // t.Patch (string) (string) 5661 5661 + case "patch": 2697 5662 2698 5663 { 2699 5664 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 2701 5666 return err 2702 5667 } 2703 5668 2704 2704 - t.Status = string(sval) 5669 5669 + t.Patch = string(sval) 5670 5670 + } 5671 5671 + // t.Title (string) (string) 5672 5672 + case "title": 5673 5673 + 5674 5674 + { 5675 5675 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5676 5676 + if err != nil { 5677 5677 + return err 5678 5678 + } 5679 5679 + 5680 5680 + t.Title = string(sval) 5681 5681 + } 5682 5682 + // t.PullId (int64) (int64) 5683 5683 + case "pullId": 5684 5684 + { 5685 5685 + maj, extra, err := cr.ReadHeader() 5686 5686 + if err != nil { 5687 5687 + return err 5688 5688 + } 5689 5689 + var extraI int64 5690 5690 + switch maj { 5691 5691 + case cbg.MajUnsignedInt: 5692 5692 + extraI = int64(extra) 5693 5693 + if extraI < 0 { 5694 5694 + return fmt.Errorf("int64 positive overflow") 5695 5695 + } 5696 5696 + case cbg.MajNegativeInt: 5697 5697 + extraI = int64(extra) 5698 5698 + if extraI < 0 { 5699 5699 + return fmt.Errorf("int64 negative overflow") 5700 5700 + } 5701 5701 + extraI = -1 - extraI 5702 5702 + default: 5703 5703 + return fmt.Errorf("wrong type for int64 field: %d", maj) 5704 5704 + } 5705 5705 + 5706 5706 + t.PullId = int64(extraI) 5707 5707 + } 5708 5708 + // t.Source (tangled.RepoPull_Source) (struct) 5709 5709 + case "source": 5710 5710 + 5711 5711 + { 5712 5712 + 5713 5713 + b, err := cr.ReadByte() 5714 5714 + if err != nil { 5715 5715 + return err 5716 5716 + } 5717 5717 + if b != cbg.CborNull[0] { 5718 5718 + if err := cr.UnreadByte(); err != nil { 5719 5719 + return err 5720 5720 + } 5721 5721 + t.Source = new(RepoPull_Source) 5722 5722 + if err := t.Source.UnmarshalCBOR(cr); err != nil { 5723 5723 + return xerrors.Errorf("unmarshaling t.Source pointer: %w", err) 5724 5724 + } 5725 5725 + } 5726 5726 + 5727 5727 + } 5728 5728 + // t.CreatedAt (string) (string) 5729 5729 + case "createdAt": 5730 5730 + 5731 5731 + { 5732 5732 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5733 5733 + if err != nil { 5734 5734 + return err 5735 5735 + } 5736 5736 + 5737 5737 + t.CreatedAt = string(sval) 5738 5738 + } 5739 5739 + // t.TargetRepo (string) (string) 5740 5740 + case "targetRepo": 5741 5741 + 5742 5742 + { 5743 5743 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5744 5744 + if err != nil { 5745 5745 + return err 5746 5746 + } 5747 5747 + 5748 5748 + t.TargetRepo = string(sval) 5749 5749 + } 5750 5750 + // t.TargetBranch (string) (string) 5751 5751 + case "targetBranch": 5752 5752 + 5753 5753 + { 5754 5754 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5755 5755 + if err != nil { 5756 5756 + return err 5757 5757 + } 5758 5758 + 5759 5759 + t.TargetBranch = string(sval) 2705 5760 } 2706 5761 2707 5762 default: ··· 3099 6154 3100 6155 return nil 3101 6156 } 3102 3102 - func (t *RepoArtifact) MarshalCBOR(w io.Writer) error { 6157 6157 + func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 3103 6158 if t == nil { 3104 6159 _, err := w.Write(cbg.CborNull) 3105 6160 return err 3106 6161 } 3107 6162 3108 6163 cw := cbg.NewCborWriter(w) 3109 3109 - fieldCount := 6 6164 6164 + fieldCount := 2 3110 6165 3111 3111 - if t.Tag == nil { 6166 6166 + if t.Repo == nil { 3112 6167 fieldCount-- 3113 6168 } 3114 6169 ··· 3116 6171 return err 3117 6172 } 3118 6173 3119 3119 - // t.Tag (util.LexBytes) (slice) 3120 3120 - if t.Tag != nil { 6174 6174 + // t.Repo (string) (string) 6175 6175 + if t.Repo != nil { 3121 6176 3122 3122 - if len("tag") > 1000000 { 3123 3123 - return xerrors.Errorf("Value in field \"tag\" was too long") 6177 6177 + if len("repo") > 1000000 { 6178 6178 + return xerrors.Errorf("Value in field \"repo\" was too long") 3124 6179 } 3125 6180 3126 3126 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil { 6181 6181 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 3127 6182 return err 3128 6183 } 3129 3129 - if _, err := cw.WriteString(string("tag")); err != nil { 6184 6184 + if _, err := cw.WriteString(string("repo")); err != nil { 3130 6185 return err 3131 6186 } 3132 6187 3133 3133 - if len(t.Tag) > 2097152 { 3134 3134 - return xerrors.Errorf("Byte array in field t.Tag was too long") 3135 3135 - } 3136 3136 - 3137 3137 - if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil { 3138 3138 - return err 3139 3139 - } 6188 6188 + if t.Repo == nil { 6189 6189 + if _, err := cw.Write(cbg.CborNull); err != nil { 6190 6190 + return err 6191 6191 + } 6192 6192 + } else { 6193 6193 + if len(*t.Repo) > 1000000 { 6194 6194 + return xerrors.Errorf("Value in field t.Repo was too long") 6195 6195 + } 3140 6196 3141 3141 - if _, err := cw.Write(t.Tag); err != nil { 3142 3142 - return err 6197 6197 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 6198 6198 + return err 6199 6199 + } 6200 6200 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 6201 6201 + return err 6202 6202 + } 3143 6203 } 3144 3144 - 3145 6204 } 3146 6205 3147 3147 - // t.Name (string) (string) 3148 3148 - if len("name") > 1000000 { 3149 3149 - return xerrors.Errorf("Value in field \"name\" was too long") 3150 3150 - } 3151 3151 - 3152 3152 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 3153 3153 - return err 3154 3154 - } 3155 3155 - if _, err := cw.WriteString(string("name")); err != nil { 3156 3156 - return err 3157 3157 - } 3158 3158 - 3159 3159 - if len(t.Name) > 1000000 { 3160 3160 - return xerrors.Errorf("Value in field t.Name was too long") 3161 3161 - } 3162 3162 - 3163 3163 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 3164 3164 - return err 3165 3165 - } 3166 3166 - if _, err := cw.WriteString(string(t.Name)); err != nil { 3167 3167 - return err 3168 3168 - } 3169 3169 - 3170 3170 - // t.Repo (string) (string) 3171 3171 - if len("repo") > 1000000 { 3172 3172 - return xerrors.Errorf("Value in field \"repo\" was too long") 6206 6206 + // t.Branch (string) (string) 6207 6207 + if len("branch") > 1000000 { 6208 6208 + return xerrors.Errorf("Value in field \"branch\" was too long") 3173 6209 } 3174 6210 3175 3175 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6211 6211 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 3176 6212 return err 3177 6213 } 3178 3178 - if _, err := cw.WriteString(string("repo")); err != nil { 3179 3179 - return err 3180 3180 - } 3181 3181 - 3182 3182 - if len(t.Repo) > 1000000 { 3183 3183 - return xerrors.Errorf("Value in field t.Repo was too long") 3184 3184 - } 3185 3185 - 3186 3186 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 3187 3187 - return err 3188 3188 - } 3189 3189 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 6214 6214 + if _, err := cw.WriteString(string("branch")); err != nil { 3190 6215 return err 3191 6216 } 3192 6217 3193 3193 - // t.LexiconTypeID (string) (string) 3194 3194 - if len("$type") > 1000000 { 3195 3195 - return xerrors.Errorf("Value in field \"$type\" was too long") 6218 6218 + if len(t.Branch) > 1000000 { 6219 6219 + return xerrors.Errorf("Value in field t.Branch was too long") 3196 6220 } 3197 6221 3198 3198 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 6222 6222 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 3199 6223 return err 3200 6224 } 3201 3201 - if _, err := cw.WriteString(string("$type")); err != nil { 3202 3202 - return err 3203 3203 - } 3204 3204 - 3205 3205 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil { 3206 3206 - return err 3207 3207 - } 3208 3208 - if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 3209 3209 - return err 3210 3210 - } 3211 3211 - 3212 3212 - // t.Artifact (util.LexBlob) (struct) 3213 3213 - if len("artifact") > 1000000 { 3214 3214 - return xerrors.Errorf("Value in field \"artifact\" was too long") 3215 3215 - } 3216 3216 - 3217 3217 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil { 3218 3218 - return err 3219 3219 - } 3220 3220 - if _, err := cw.WriteString(string("artifact")); err != nil { 3221 3221 - return err 3222 3222 - } 3223 3223 - 3224 3224 - if err := t.Artifact.MarshalCBOR(cw); err != nil { 3225 3225 - return err 3226 3226 - } 3227 3227 - 3228 3228 - // t.CreatedAt (string) (string) 3229 3229 - if len("createdAt") > 1000000 { 3230 3230 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 3231 3231 - } 3232 3232 - 3233 3233 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 3234 3234 - return err 3235 3235 - } 3236 3236 - if _, err := cw.WriteString(string("createdAt")); err != nil { 3237 3237 - return err 3238 3238 - } 3239 3239 - 3240 3240 - if len(t.CreatedAt) > 1000000 { 3241 3241 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 3242 3242 - } 3243 3243 - 3244 3244 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 3245 3245 - return err 3246 3246 - } 3247 3247 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6225 6225 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 3248 6226 return err 3249 6227 } 3250 6228 return nil 3251 6229 } 3252 6230 3253 3253 - func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) { 3254 3254 - *t = RepoArtifact{} 6231 6231 + func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) { 6232 6232 + *t = RepoPull_Source{} 3255 6233 3256 6234 cr := cbg.NewCborReader(r) 3257 6235 ··· 3270 6248 } 3271 6249 3272 6250 if extra > cbg.MaxLength { 3273 3273 - return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra) 6251 6251 + return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra) 3274 6252 } 3275 6253 3276 6254 n := extra 3277 6255 3278 3278 - nameBuf := make([]byte, 9) 6256 6256 + nameBuf := make([]byte, 6) 3279 6257 for i := uint64(0); i < n; i++ { 3280 6258 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3281 6259 if err != nil { ··· 3291 6269 } 3292 6270 3293 6271 switch string(nameBuf[:nameLen]) { 3294 3294 - // t.Tag (util.LexBytes) (slice) 3295 3295 - case "tag": 3296 3296 - 3297 3297 - maj, extra, err = cr.ReadHeader() 3298 3298 - if err != nil { 3299 3299 - return err 3300 3300 - } 3301 3301 - 3302 3302 - if extra > 2097152 { 3303 3303 - return fmt.Errorf("t.Tag: byte array too large (%d)", extra) 3304 3304 - } 3305 3305 - if maj != cbg.MajByteString { 3306 3306 - return fmt.Errorf("expected byte array") 3307 3307 - } 3308 3308 - 3309 3309 - if extra > 0 { 3310 3310 - t.Tag = make([]uint8, extra) 3311 3311 - } 3312 3312 - 3313 3313 - if _, err := io.ReadFull(cr, t.Tag); err != nil { 3314 3314 - return err 3315 3315 - } 3316 3316 - 3317 3317 - // t.Name (string) (string) 3318 3318 - case "name": 3319 3319 - 3320 3320 - { 3321 3321 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3322 3322 - if err != nil { 3323 3323 - return err 3324 3324 - } 3325 3325 - 3326 3326 - t.Name = string(sval) 3327 3327 - } 3328 3328 - // t.Repo (string) (string) 6272 6272 + // t.Repo (string) (string) 3329 6273 case "repo": 3330 6274 3331 6275 { 3332 3332 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3333 3333 - if err != nil { 3334 3334 - return err 3335 3335 - } 3336 3336 - 3337 3337 - t.Repo = string(sval) 3338 3338 - } 3339 3339 - // t.LexiconTypeID (string) (string) 3340 3340 - case "$type": 3341 3341 - 3342 3342 - { 3343 3343 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3344 3344 - if err != nil { 3345 3345 - return err 3346 3346 - } 3347 3347 - 3348 3348 - t.LexiconTypeID = string(sval) 3349 3349 - } 3350 3350 - // t.Artifact (util.LexBlob) (struct) 3351 3351 - case "artifact": 3352 3352 - 3353 3353 - { 3354 3354 - 3355 6276 b, err := cr.ReadByte() 3356 6277 if err != nil { 3357 6278 return err ··· 3360 6281 if err := cr.UnreadByte(); err != nil { 3361 6282 return err 3362 6283 } 3363 3363 - t.Artifact = new(util.LexBlob) 3364 3364 - if err := t.Artifact.UnmarshalCBOR(cr); err != nil { 3365 3365 - return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err) 6284 6284 + 6285 6285 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6286 6286 + if err != nil { 6287 6287 + return err 3366 6288 } 3367 3367 - } 3368 6289 6290 6290 + t.Repo = (*string)(&sval) 6291 6291 + } 3369 6292 } 3370 3370 - // t.CreatedAt (string) (string) 3371 3371 - case "createdAt": 6293 6293 + // t.Branch (string) (string) 6294 6294 + case "branch": 3372 6295 3373 6296 { 3374 6297 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 3376 6299 return err 3377 6300 } 3378 6301 3379 3379 - t.CreatedAt = string(sval) 6302 6302 + t.Branch = string(sval) 3380 6303 } 3381 6304 3382 6305 default: ··· 3389 6312 3390 6313 return nil 3391 6314 } 3392 3392 - func (t *ActorProfile) MarshalCBOR(w io.Writer) error { 6315 6315 + func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 3393 6316 if t == nil { 3394 6317 _, err := w.Write(cbg.CborNull) 3395 6318 return err 3396 6319 } 3397 6320 3398 6321 cw := cbg.NewCborWriter(w) 3399 3399 - fieldCount := 7 3400 6322 3401 3401 - if t.Description == nil { 3402 3402 - fieldCount-- 6323 6323 + if _, err := cw.Write([]byte{163}); err != nil { 6324 6324 + return err 3403 6325 } 3404 6326 3405 3405 - if t.Links == nil { 3406 3406 - fieldCount-- 6327 6327 + // t.Pull (string) (string) 6328 6328 + if len("pull") > 1000000 { 6329 6329 + return xerrors.Errorf("Value in field \"pull\" was too long") 3407 6330 } 3408 6331 3409 3409 - if t.Location == nil { 3410 3410 - fieldCount-- 6332 6332 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 6333 6333 + return err 6334 6334 + } 6335 6335 + if _, err := cw.WriteString(string("pull")); err != nil { 6336 6336 + return err 3411 6337 } 3412 6338 3413 3413 - if t.PinnedRepositories == nil { 3414 3414 - fieldCount-- 6339 6339 + if len(t.Pull) > 1000000 { 6340 6340 + return xerrors.Errorf("Value in field t.Pull was too long") 3415 6341 } 3416 6342 3417 3417 - if t.Stats == nil { 3418 3418 - fieldCount-- 6343 6343 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 6344 6344 + return err 3419 6345 } 3420 3420 - 3421 3421 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6346 6346 + if _, err := cw.WriteString(string(t.Pull)); err != nil { 3422 6347 return err 3423 6348 } 3424 6349 ··· 3434 6359 return err 3435 6360 } 3436 6361 3437 3437 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil { 6362 6362 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 3438 6363 return err 3439 6364 } 3440 3440 - if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil { 6365 6365 + if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 3441 6366 return err 3442 6367 } 3443 6368 3444 3444 - // t.Links ([]string) (slice) 3445 3445 - if t.Links != nil { 3446 3446 - 3447 3447 - if len("links") > 1000000 { 3448 3448 - return xerrors.Errorf("Value in field \"links\" was too long") 3449 3449 - } 3450 3450 - 3451 3451 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil { 3452 3452 - return err 3453 3453 - } 3454 3454 - if _, err := cw.WriteString(string("links")); err != nil { 3455 3455 - return err 3456 3456 - } 3457 3457 - 3458 3458 - if len(t.Links) > 8192 { 3459 3459 - return xerrors.Errorf("Slice value in field t.Links was too long") 3460 3460 - } 3461 3461 - 3462 3462 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil { 3463 3463 - return err 3464 3464 - } 3465 3465 - for _, v := range t.Links { 3466 3466 - if len(v) > 1000000 { 3467 3467 - return xerrors.Errorf("Value in field v was too long") 3468 3468 - } 3469 3469 - 3470 3470 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 3471 3471 - return err 3472 3472 - } 3473 3473 - if _, err := cw.WriteString(string(v)); err != nil { 3474 3474 - return err 3475 3475 - } 3476 3476 - 3477 3477 - } 3478 3478 - } 3479 3479 - 3480 3480 - // t.Stats ([]string) (slice) 3481 3481 - if t.Stats != nil { 3482 3482 - 3483 3483 - if len("stats") > 1000000 { 3484 3484 - return xerrors.Errorf("Value in field \"stats\" was too long") 3485 3485 - } 3486 3486 - 3487 3487 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil { 3488 3488 - return err 3489 3489 - } 3490 3490 - if _, err := cw.WriteString(string("stats")); err != nil { 3491 3491 - return err 3492 3492 - } 3493 3493 - 3494 3494 - if len(t.Stats) > 8192 { 3495 3495 - return xerrors.Errorf("Slice value in field t.Stats was too long") 3496 3496 - } 3497 3497 - 3498 3498 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil { 3499 3499 - return err 3500 3500 - } 3501 3501 - for _, v := range t.Stats { 3502 3502 - if len(v) > 1000000 { 3503 3503 - return xerrors.Errorf("Value in field v was too long") 3504 3504 - } 3505 3505 - 3506 3506 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 3507 3507 - return err 3508 3508 - } 3509 3509 - if _, err := cw.WriteString(string(v)); err != nil { 3510 3510 - return err 3511 3511 - } 3512 3512 - 3513 3513 - } 3514 3514 - } 3515 3515 - 3516 3516 - // t.Bluesky (bool) (bool) 3517 3517 - if len("bluesky") > 1000000 { 3518 3518 - return xerrors.Errorf("Value in field \"bluesky\" was too long") 6369 6369 + // t.Status (string) (string) 6370 6370 + if len("status") > 1000000 { 6371 6371 + return xerrors.Errorf("Value in field \"status\" was too long") 3519 6372 } 3520 6373 3521 3521 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil { 6374 6374 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 3522 6375 return err 3523 6376 } 3524 3524 - if _, err := cw.WriteString(string("bluesky")); err != nil { 6377 6377 + if _, err := cw.WriteString(string("status")); err != nil { 3525 6378 return err 3526 6379 } 3527 6380 3528 3528 - if err := cbg.WriteBool(w, t.Bluesky); err != nil { 3529 3529 - return err 6381 6381 + if len(t.Status) > 1000000 { 6382 6382 + return xerrors.Errorf("Value in field t.Status was too long") 3530 6383 } 3531 6384 3532 3532 - // t.Location (string) (string) 3533 3533 - if t.Location != nil { 3534 3534 - 3535 3535 - if len("location") > 1000000 { 3536 3536 - return xerrors.Errorf("Value in field \"location\" was too long") 3537 3537 - } 3538 3538 - 3539 3539 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil { 3540 3540 - return err 3541 3541 - } 3542 3542 - if _, err := cw.WriteString(string("location")); err != nil { 3543 3543 - return err 3544 3544 - } 3545 3545 - 3546 3546 - if t.Location == nil { 3547 3547 - if _, err := cw.Write(cbg.CborNull); err != nil { 3548 3548 - return err 3549 3549 - } 3550 3550 - } else { 3551 3551 - if len(*t.Location) > 1000000 { 3552 3552 - return xerrors.Errorf("Value in field t.Location was too long") 3553 3553 - } 3554 3554 - 3555 3555 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil { 3556 3556 - return err 3557 3557 - } 3558 3558 - if _, err := cw.WriteString(string(*t.Location)); err != nil { 3559 3559 - return err 3560 3560 - } 3561 3561 - } 6385 6385 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 6386 6386 + return err 3562 6387 } 3563 3563 - 3564 3564 - // t.Description (string) (string) 3565 3565 - if t.Description != nil { 3566 3566 - 3567 3567 - if len("description") > 1000000 { 3568 3568 - return xerrors.Errorf("Value in field \"description\" was too long") 3569 3569 - } 3570 3570 - 3571 3571 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 3572 3572 - return err 3573 3573 - } 3574 3574 - if _, err := cw.WriteString(string("description")); err != nil { 3575 3575 - return err 3576 3576 - } 3577 3577 - 3578 3578 - if t.Description == nil { 3579 3579 - if _, err := cw.Write(cbg.CborNull); err != nil { 3580 3580 - return err 3581 3581 - } 3582 3582 - } else { 3583 3583 - if len(*t.Description) > 1000000 { 3584 3584 - return xerrors.Errorf("Value in field t.Description was too long") 3585 3585 - } 3586 3586 - 3587 3587 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 3588 3588 - return err 3589 3589 - } 3590 3590 - if _, err := cw.WriteString(string(*t.Description)); err != nil { 3591 3591 - return err 3592 3592 - } 3593 3593 - } 3594 3594 - } 3595 3595 - 3596 3596 - // t.PinnedRepositories ([]string) (slice) 3597 3597 - if t.PinnedRepositories != nil { 3598 3598 - 3599 3599 - if len("pinnedRepositories") > 1000000 { 3600 3600 - return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long") 3601 3601 - } 3602 3602 - 3603 3603 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil { 3604 3604 - return err 3605 3605 - } 3606 3606 - if _, err := cw.WriteString(string("pinnedRepositories")); err != nil { 3607 3607 - return err 3608 3608 - } 3609 3609 - 3610 3610 - if len(t.PinnedRepositories) > 8192 { 3611 3611 - return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long") 3612 3612 - } 3613 3613 - 3614 3614 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil { 3615 3615 - return err 3616 3616 - } 3617 3617 - for _, v := range t.PinnedRepositories { 3618 3618 - if len(v) > 1000000 { 3619 3619 - return xerrors.Errorf("Value in field v was too long") 3620 3620 - } 3621 3621 - 3622 3622 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 3623 3623 - return err 3624 3624 - } 3625 3625 - if _, err := cw.WriteString(string(v)); err != nil { 3626 3626 - return err 3627 3627 - } 3628 3628 - 3629 3629 - } 6388 6388 + if _, err := cw.WriteString(string(t.Status)); err != nil { 6389 6389 + return err 3630 6390 } 3631 6391 return nil 3632 6392 } 3633 6393 3634 3634 - func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) { 3635 3635 - *t = ActorProfile{} 6394 6394 + func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 6395 6395 + *t = RepoPullStatus{} 3636 6396 3637 6397 cr := cbg.NewCborReader(r) 3638 6398 ··· 3651 6411 } 3652 6412 3653 6413 if extra > cbg.MaxLength { 3654 3654 - return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 6414 6414 + return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 3655 6415 } 3656 6416 3657 6417 n := extra 3658 6418 3659 3659 - nameBuf := make([]byte, 18) 6419 6419 + nameBuf := make([]byte, 6) 3660 6420 for i := uint64(0); i < n; i++ { 3661 6421 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3662 6422 if err != nil { ··· 3672 6432 } 3673 6433 3674 6434 switch string(nameBuf[:nameLen]) { 3675 3675 - // t.LexiconTypeID (string) (string) 3676 3676 - case "$type": 6435 6435 + // t.Pull (string) (string) 6436 6436 + case "pull": 3677 6437 3678 6438 { 3679 6439 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 3681 6441 return err 3682 6442 } 3683 6443 3684 3684 - t.LexiconTypeID = string(sval) 3685 3685 - } 3686 3686 - // t.Links ([]string) (slice) 3687 3687 - case "links": 3688 3688 - 3689 3689 - maj, extra, err = cr.ReadHeader() 3690 3690 - if err != nil { 3691 3691 - return err 3692 3692 - } 3693 3693 - 3694 3694 - if extra > 8192 { 3695 3695 - return fmt.Errorf("t.Links: array too large (%d)", extra) 3696 3696 - } 3697 3697 - 3698 3698 - if maj != cbg.MajArray { 3699 3699 - return fmt.Errorf("expected cbor array") 3700 3700 - } 3701 3701 - 3702 3702 - if extra > 0 { 3703 3703 - t.Links = make([]string, extra) 3704 3704 - } 3705 3705 - 3706 3706 - for i := 0; i < int(extra); i++ { 3707 3707 - { 3708 3708 - var maj byte 3709 3709 - var extra uint64 3710 3710 - var err error 3711 3711 - _ = maj 3712 3712 - _ = extra 3713 3713 - _ = err 3714 3714 - 3715 3715 - { 3716 3716 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3717 3717 - if err != nil { 3718 3718 - return err 3719 3719 - } 3720 3720 - 3721 3721 - t.Links[i] = string(sval) 3722 3722 - } 3723 3723 - 3724 3724 - } 3725 3725 - } 3726 3726 - // t.Stats ([]string) (slice) 3727 3727 - case "stats": 3728 3728 - 3729 3729 - maj, extra, err = cr.ReadHeader() 3730 3730 - if err != nil { 3731 3731 - return err 3732 3732 - } 3733 3733 - 3734 3734 - if extra > 8192 { 3735 3735 - return fmt.Errorf("t.Stats: array too large (%d)", extra) 3736 3736 - } 3737 3737 - 3738 3738 - if maj != cbg.MajArray { 3739 3739 - return fmt.Errorf("expected cbor array") 3740 3740 - } 3741 3741 - 3742 3742 - if extra > 0 { 3743 3743 - t.Stats = make([]string, extra) 3744 3744 - } 3745 3745 - 3746 3746 - for i := 0; i < int(extra); i++ { 3747 3747 - { 3748 3748 - var maj byte 3749 3749 - var extra uint64 3750 3750 - var err error 3751 3751 - _ = maj 3752 3752 - _ = extra 3753 3753 - _ = err 3754 3754 - 3755 3755 - { 3756 3756 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3757 3757 - if err != nil { 3758 3758 - return err 3759 3759 - } 3760 3760 - 3761 3761 - t.Stats[i] = string(sval) 3762 3762 - } 3763 3763 - 3764 3764 - } 6444 6444 + t.Pull = string(sval) 3765 6445 } 3766 3766 - // t.Bluesky (bool) (bool) 3767 3767 - case "bluesky": 3768 3768 - 3769 3769 - maj, extra, err = cr.ReadHeader() 3770 3770 - if err != nil { 3771 3771 - return err 3772 3772 - } 3773 3773 - if maj != cbg.MajOther { 3774 3774 - return fmt.Errorf("booleans must be major type 7") 3775 3775 - } 3776 3776 - switch extra { 3777 3777 - case 20: 3778 3778 - t.Bluesky = false 3779 3779 - case 21: 3780 3780 - t.Bluesky = true 3781 3781 - default: 3782 3782 - return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 3783 3783 - } 3784 3784 - // t.Location (string) (string) 3785 3785 - case "location": 6446 6446 + // t.LexiconTypeID (string) (string) 6447 6447 + case "$type": 3786 6448 3787 6449 { 3788 3788 - b, err := cr.ReadByte() 6450 6450 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3789 6451 if err != nil { 3790 6452 return err 3791 6453 } 3792 3792 - if b != cbg.CborNull[0] { 3793 3793 - if err := cr.UnreadByte(); err != nil { 3794 3794 - return err 3795 3795 - } 3796 6454 3797 3797 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3798 3798 - if err != nil { 3799 3799 - return err 3800 3800 - } 3801 3801 - 3802 3802 - t.Location = (*string)(&sval) 3803 3803 - } 6455 6455 + t.LexiconTypeID = string(sval) 3804 6456 } 3805 3805 - // t.Description (string) (string) 3806 3806 - case "description": 6457 6457 + // t.Status (string) (string) 6458 6458 + case "status": 3807 6459 3808 6460 { 3809 3809 - b, err := cr.ReadByte() 6461 6461 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3810 6462 if err != nil { 3811 6463 return err 3812 6464 } 3813 3813 - if b != cbg.CborNull[0] { 3814 3814 - if err := cr.UnreadByte(); err != nil { 3815 3815 - return err 3816 3816 - } 3817 6465 3818 3818 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3819 3819 - if err != nil { 3820 3820 - return err 3821 3821 - } 3822 3822 - 3823 3823 - t.Description = (*string)(&sval) 3824 3824 - } 3825 3825 - } 3826 3826 - // t.PinnedRepositories ([]string) (slice) 3827 3827 - case "pinnedRepositories": 3828 3828 - 3829 3829 - maj, extra, err = cr.ReadHeader() 3830 3830 - if err != nil { 3831 3831 - return err 3832 3832 - } 3833 3833 - 3834 3834 - if extra > 8192 { 3835 3835 - return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra) 3836 3836 - } 3837 3837 - 3838 3838 - if maj != cbg.MajArray { 3839 3839 - return fmt.Errorf("expected cbor array") 3840 3840 - } 3841 3841 - 3842 3842 - if extra > 0 { 3843 3843 - t.PinnedRepositories = make([]string, extra) 3844 3844 - } 3845 3845 - 3846 3846 - for i := 0; i < int(extra); i++ { 3847 3847 - { 3848 3848 - var maj byte 3849 3849 - var extra uint64 3850 3850 - var err error 3851 3851 - _ = maj 3852 3852 - _ = extra 3853 3853 - _ = err 3854 3854 - 3855 3855 - { 3856 3856 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3857 3857 - if err != nil { 3858 3858 - return err 3859 3859 - } 3860 3860 - 3861 3861 - t.PinnedRepositories[i] = string(sval) 3862 3862 - } 3863 3863 - 3864 3864 - } 6466 6466 + t.Status = string(sval) 3865 6467 } 3866 6468 3867 6469 default:

+97

api/tangled/tangledpipeline.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.pipeline 6 6 + 7 7 + //import ( 8 8 + // "github.com/bluesky-social/indigo/lex/util" 9 9 + //) 10 10 + 11 11 + const ( 12 12 + PipelineNSID = "sh.tangled.pipeline" 13 13 + ) 14 14 + 15 15 + //func init() { 16 16 + // util.RegisterType("sh.tangled.pipeline", &Pipeline{}) 17 17 + //} // 18 18 + // RECORDTYPE: Pipeline 19 19 + type Pipeline struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.pipeline" cborgen:"$type,const=sh.tangled.pipeline"` 21 21 + TriggerMetadata *Pipeline_TriggerMetadata `json:"triggerMetadata" cborgen:"triggerMetadata"` 22 22 + Workflows []*Pipeline_Workflow `json:"workflows" cborgen:"workflows"` 23 23 + } 24 24 + 25 25 + // Pipeline_CloneOpts is a "cloneOpts" in the sh.tangled.pipeline schema. 26 26 + type Pipeline_CloneOpts struct { 27 27 + Depth int64 `json:"depth" cborgen:"depth"` 28 28 + Skip bool `json:"skip" cborgen:"skip"` 29 29 + Submodules bool `json:"submodules" cborgen:"submodules"` 30 30 + } 31 31 + 32 32 + type Pipeline_Dependencies_Elem struct { 33 33 + Packages []string `json:"packages" cborgen:"packages"` 34 34 + Registry string `json:"registry" cborgen:"registry"` 35 35 + } 36 36 + 37 37 + // Pipeline_ManualTriggerData is a "manualTriggerData" in the sh.tangled.pipeline schema. 38 38 + type Pipeline_ManualTriggerData struct { 39 39 + Inputs []*Pipeline_ManualTriggerData_Inputs_Elem `json:"inputs,omitempty" cborgen:"inputs,omitempty"` 40 40 + } 41 41 + 42 42 + type Pipeline_ManualTriggerData_Inputs_Elem struct { 43 43 + Key string `json:"key" cborgen:"key"` 44 44 + Value string `json:"value" cborgen:"value"` 45 45 + } 46 46 + 47 47 + // Pipeline_PullRequestTriggerData is a "pullRequestTriggerData" in the sh.tangled.pipeline schema. 48 48 + type Pipeline_PullRequestTriggerData struct { 49 49 + Action string `json:"action" cborgen:"action"` 50 50 + SourceBranch string `json:"sourceBranch" cborgen:"sourceBranch"` 51 51 + SourceSha string `json:"sourceSha" cborgen:"sourceSha"` 52 52 + TargetBranch string `json:"targetBranch" cborgen:"targetBranch"` 53 53 + } 54 54 + 55 55 + // Pipeline_PushTriggerData is a "pushTriggerData" in the sh.tangled.pipeline schema. 56 56 + type Pipeline_PushTriggerData struct { 57 57 + NewSha string `json:"newSha" cborgen:"newSha"` 58 58 + OldSha string `json:"oldSha" cborgen:"oldSha"` 59 59 + Ref string `json:"ref" cborgen:"ref"` 60 60 + } 61 61 + 62 62 + // Pipeline_Step is a "step" in the sh.tangled.pipeline schema. 63 63 + type Pipeline_Step struct { 64 64 + Command string `json:"command" cborgen:"command"` 65 65 + Name string `json:"name" cborgen:"name"` 66 66 + } 67 67 + 68 68 + // Pipeline_TriggerMetadata is a "triggerMetadata" in the sh.tangled.pipeline schema. 69 69 + type Pipeline_TriggerMetadata struct { 70 70 + Kind string `json:"kind" cborgen:"kind"` 71 71 + Manual *Pipeline_ManualTriggerData `json:"manual,omitempty" cborgen:"manual,omitempty"` 72 72 + PullRequest *Pipeline_PullRequestTriggerData `json:"pullRequest,omitempty" cborgen:"pullRequest,omitempty"` 73 73 + Push *Pipeline_PushTriggerData `json:"push,omitempty" cborgen:"push,omitempty"` 74 74 + Repo *Pipeline_TriggerRepo `json:"repo" cborgen:"repo"` 75 75 + } 76 76 + 77 77 + // Pipeline_TriggerRepo is a "triggerRepo" in the sh.tangled.pipeline schema. 78 78 + type Pipeline_TriggerRepo struct { 79 79 + DefaultBranch string `json:"defaultBranch" cborgen:"defaultBranch"` 80 80 + Did string `json:"did" cborgen:"did"` 81 81 + Knot string `json:"knot" cborgen:"knot"` 82 82 + Repo string `json:"repo" cborgen:"repo"` 83 83 + } 84 84 + 85 85 + // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema. 86 86 + type Pipeline_Workflow struct { 87 87 + Clone *Pipeline_CloneOpts `json:"clone" cborgen:"clone"` 88 88 + Dependencies []Pipeline_Dependencies_Elem `json:"dependencies" cborgen:"dependencies"` 89 89 + Environment []*Pipeline_Workflow_Environment_Elem `json:"environment" cborgen:"environment"` 90 90 + Name string `json:"name" cborgen:"name"` 91 91 + Steps []*Pipeline_Step `json:"steps" cborgen:"steps"` 92 92 + } 93 93 + 94 94 + type Pipeline_Workflow_Environment_Elem struct { 95 95 + Key string `json:"key" cborgen:"key"` 96 96 + Value string `json:"value" cborgen:"value"` 97 97 + }

+17 -5

cmd/gen.go

··· 14 14 if err := genCfg.WriteMapEncodersToFile( 15 15 "api/tangled/cbor_gen.go", 16 16 "tangled", 17 17 + tangled.ActorProfile{}, 17 18 tangled.FeedStar{}, 18 19 tangled.GitRefUpdate{}, 19 20 tangled.GraphFollow{}, 20 21 tangled.KnotMember{}, 22 22 + tangled.Pipeline{}, 23 23 + tangled.Pipeline_CloneOpts{}, 24 24 + tangled.Pipeline_Workflow{}, 25 25 + tangled.Pipeline_Workflow_Environment_Elem{}, 26 26 + tangled.Pipeline_Dependencies_Elem{}, 27 27 + tangled.Pipeline_ManualTriggerData{}, 28 28 + tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, 29 29 + tangled.Pipeline_PullRequestTriggerData{}, 30 30 + tangled.Pipeline_PushTriggerData{}, 31 31 + tangled.Pipeline_Step{}, 32 32 + tangled.Pipeline_TriggerMetadata{}, 33 33 + tangled.Pipeline_TriggerRepo{}, 21 34 tangled.PublicKey{}, 35 35 + tangled.Repo{}, 36 36 + tangled.RepoArtifact{}, 37 37 + tangled.RepoIssue{}, 22 38 tangled.RepoIssueComment{}, 23 39 tangled.RepoIssueState{}, 24 24 - tangled.RepoIssue{}, 25 25 - tangled.Repo{}, 26 40 tangled.RepoPull{}, 41 41 + tangled.RepoPullComment{}, 27 42 tangled.RepoPull_Source{}, 28 43 tangled.RepoPullStatus{}, 29 29 - tangled.RepoPullComment{}, 30 30 - tangled.RepoArtifact{}, 31 31 - tangled.ActorProfile{}, 32 44 ); err != nil { 33 45 panic(err) 34 46 }

+263

lexicons/pipeline.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.pipeline", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "record": { 11 11 + "type": "object", 12 12 + "required": [ 13 13 + "triggerMetadata", 14 14 + "workflows" 15 15 + ], 16 16 + "properties": { 17 17 + "triggerMetadata": { 18 18 + "type": "ref", 19 19 + "ref": "#triggerMetadata" 20 20 + }, 21 21 + "workflows": { 22 22 + "type": "array", 23 23 + "items": { 24 24 + "type": "ref", 25 25 + "ref": "#workflow" 26 26 + } 27 27 + } 28 28 + } 29 29 + } 30 30 + }, 31 31 + "triggerMetadata": { 32 32 + "type": "object", 33 33 + "required": [ 34 34 + "kind", 35 35 + "repo" 36 36 + ], 37 37 + "properties": { 38 38 + "kind": { 39 39 + "type": "string", 40 40 + "enum": [ 41 41 + "push", 42 42 + "pull_request", 43 43 + "manual" 44 44 + ] 45 45 + }, 46 46 + "repo": { 47 47 + "type": "ref", 48 48 + "ref": "#triggerRepo" 49 49 + }, 50 50 + "push": { 51 51 + "type": "ref", 52 52 + "ref": "#pushTriggerData" 53 53 + }, 54 54 + "pullRequest": { 55 55 + "type": "ref", 56 56 + "ref": "#pullRequestTriggerData" 57 57 + }, 58 58 + "manual": { 59 59 + "type": "ref", 60 60 + "ref": "#manualTriggerData" 61 61 + } 62 62 + } 63 63 + }, 64 64 + "triggerRepo": { 65 65 + "type": "object", 66 66 + "required": [ 67 67 + "knot", 68 68 + "did", 69 69 + "repo", 70 70 + "defaultBranch" 71 71 + ], 72 72 + "properties": { 73 73 + "knot": { 74 74 + "type": "string" 75 75 + }, 76 76 + "did": { 77 77 + "type": "string", 78 78 + "format": "did" 79 79 + }, 80 80 + "repo": { 81 81 + "type": "string" 82 82 + }, 83 83 + "defaultBranch": { 84 84 + "type": "string" 85 85 + } 86 86 + } 87 87 + }, 88 88 + "pushTriggerData": { 89 89 + "type": "object", 90 90 + "required": [ 91 91 + "ref", 92 92 + "newSha", 93 93 + "oldSha" 94 94 + ], 95 95 + "properties": { 96 96 + "ref": { 97 97 + "type": "string" 98 98 + }, 99 99 + "newSha": { 100 100 + "type": "string", 101 101 + "minLength": 40, 102 102 + "maxLength": 40 103 103 + }, 104 104 + "oldSha": { 105 105 + "type": "string", 106 106 + "minLength": 40, 107 107 + "maxLength": 40 108 108 + } 109 109 + } 110 110 + }, 111 111 + "pullRequestTriggerData": { 112 112 + "type": "object", 113 113 + "required": [ 114 114 + "sourceBranch", 115 115 + "targetBranch", 116 116 + "sourceSha", 117 117 + "action" 118 118 + ], 119 119 + "properties": { 120 120 + "sourceBranch": { 121 121 + "type": "string" 122 122 + }, 123 123 + "targetBranch": { 124 124 + "type": "string" 125 125 + }, 126 126 + "sourceSha": { 127 127 + "type": "string", 128 128 + "minLength": 40, 129 129 + "maxLength": 40 130 130 + }, 131 131 + "action": { 132 132 + "type": "string" 133 133 + } 134 134 + } 135 135 + }, 136 136 + "manualTriggerData": { 137 137 + "type": "object", 138 138 + "properties": { 139 139 + "inputs": { 140 140 + "type": "array", 141 141 + "items": { 142 142 + "type": "object", 143 143 + "required": [ 144 144 + "key", 145 145 + "value" 146 146 + ], 147 147 + "properties": { 148 148 + "key": { 149 149 + "type": "string" 150 150 + }, 151 151 + "value": { 152 152 + "type": "string" 153 153 + } 154 154 + } 155 155 + } 156 156 + } 157 157 + } 158 158 + }, 159 159 + "workflow": { 160 160 + "type": "object", 161 161 + "required": [ 162 162 + "name", 163 163 + "dependencies", 164 164 + "steps", 165 165 + "environment", 166 166 + "clone" 167 167 + ], 168 168 + "properties": { 169 169 + "name": { 170 170 + "type": "string" 171 171 + }, 172 172 + "dependencies": { 173 173 + "type": "ref", 174 174 + "ref": "#dependencies" 175 175 + }, 176 176 + "steps": { 177 177 + "type": "array", 178 178 + "items": { 179 179 + "type": "ref", 180 180 + "ref": "#step" 181 181 + } 182 182 + }, 183 183 + "environment": { 184 184 + "type": "array", 185 185 + "items": { 186 186 + "type": "object", 187 187 + "required": [ 188 188 + "key", 189 189 + "value" 190 190 + ], 191 191 + "properties": { 192 192 + "key": { 193 193 + "type": "string" 194 194 + }, 195 195 + "value": { 196 196 + "type": "string" 197 197 + } 198 198 + } 199 199 + } 200 200 + }, 201 201 + "clone": { 202 202 + "type": "ref", 203 203 + "ref": "#cloneOpts" 204 204 + } 205 205 + } 206 206 + }, 207 207 + "dependencies": { 208 208 + "type": "array", 209 209 + "items": { 210 210 + "type": "object", 211 211 + "required": [ 212 212 + "registry", 213 213 + "packages" 214 214 + ], 215 215 + "properties": { 216 216 + "registry": { 217 217 + "type": "string" 218 218 + }, 219 219 + "packages": { 220 220 + "type": "array", 221 221 + "items": { 222 222 + "type": "string" 223 223 + } 224 224 + } 225 225 + } 226 226 + } 227 227 + }, 228 228 + "cloneOpts": { 229 229 + "type": "object", 230 230 + "required": [ 231 231 + "skip", 232 232 + "depth", 233 233 + "submodules" 234 234 + ], 235 235 + "properties": { 236 236 + "skip": { 237 237 + "type": "boolean" 238 238 + }, 239 239 + "depth": { 240 240 + "type": "integer" 241 241 + }, 242 242 + "submodules": { 243 243 + "type": "boolean" 244 244 + } 245 245 + } 246 246 + }, 247 247 + "step": { 248 248 + "type": "object", 249 249 + "required": [ 250 250 + "name", 251 251 + "command" 252 252 + ], 253 253 + "properties": { 254 254 + "name": { 255 255 + "type": "string" 256 256 + }, 257 257 + "command": { 258 258 + "type": "string" 259 259 + } 260 260 + } 261 261 + } 262 262 + } 263 263 + }