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