workflow,spindle: regenerate api with new lexicon #284

+35 -295

api/tangled/cbor_gen.go

··· 2188 2188 2189 2189 return nil 2190 2190 } 2191 2191 - func (t *Pipeline_Dependencies_Elem) MarshalCBOR(w io.Writer) error { 2191 2191 + func (t *Pipeline_Dependency) MarshalCBOR(w io.Writer) error { 2192 2192 if t == nil { 2193 2193 _, err := w.Write(cbg.CborNull) 2194 2194 return err ··· 2258 2258 return nil 2259 2259 } 2260 2260 2261 2261 - func (t *Pipeline_Dependencies_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2262 2262 - *t = Pipeline_Dependencies_Elem{} 2261 2261 + func (t *Pipeline_Dependency) UnmarshalCBOR(r io.Reader) (err error) { 2262 2262 + *t = Pipeline_Dependency{} 2263 2263 2264 2264 cr := cbg.NewCborReader(r) 2265 2265 ··· 2278 2278 } 2279 2279 2280 2280 if extra > cbg.MaxLength { 2281 2281 - return fmt.Errorf("Pipeline_Dependencies_Elem: map struct too large (%d)", extra) 2281 2281 + return fmt.Errorf("Pipeline_Dependency: map struct too large (%d)", extra) 2282 2282 } 2283 2283 2284 2284 n := extra ··· 2378 2378 return err 2379 2379 } 2380 2380 2381 2381 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2381 2381 + // t.Inputs ([]*tangled.Pipeline_Pair) (slice) 2382 2382 if t.Inputs != nil { 2383 2383 2384 2384 if len("inputs") > 1000000 { ··· 2450 2450 } 2451 2451 2452 2452 switch string(nameBuf[:nameLen]) { 2453 2453 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2453 2453 + // t.Inputs ([]*tangled.Pipeline_Pair) (slice) 2454 2454 case "inputs": 2455 2455 2456 2456 maj, extra, err = cr.ReadHeader() ··· 2467 2467 } 2468 2468 2469 2469 if extra > 0 { 2470 2470 - t.Inputs = make([]*Pipeline_ManualTriggerData_Inputs_Elem, extra) 2470 2470 + t.Inputs = make([]*Pipeline_Pair, extra) 2471 2471 } 2472 2472 2473 2473 for i := 0; i < int(extra); i++ { ··· 2489 2489 if err := cr.UnreadByte(); err != nil { 2490 2490 return err 2491 2491 } 2492 2492 - t.Inputs[i] = new(Pipeline_ManualTriggerData_Inputs_Elem) 2492 2492 + t.Inputs[i] = new(Pipeline_Pair) 2493 2493 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 2494 2494 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 2495 2495 } ··· 2510 2510 2511 2511 return nil 2512 2512 } 2513 2513 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) MarshalCBOR(w io.Writer) error { 2513 2513 + func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error { 2514 2514 if t == nil { 2515 2515 _, err := w.Write(cbg.CborNull) 2516 2516 return err ··· 2570 2570 return nil 2571 2571 } 2572 2572 2573 2573 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2574 2574 - *t = Pipeline_ManualTriggerData_Inputs_Elem{} 2573 2573 + func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) { 2574 2574 + *t = Pipeline_Pair{} 2575 2575 2576 2576 cr := cbg.NewCborReader(r) 2577 2577 ··· 2590 2590 } 2591 2591 2592 2592 if extra > cbg.MaxLength { 2593 2593 - return fmt.Errorf("Pipeline_ManualTriggerData_Inputs_Elem: map struct too large (%d)", extra) 2593 2593 + return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra) 2594 2594 } 2595 2595 2596 2596 n := extra ··· 3014 3014 3015 3015 return nil 3016 3016 } 3017 3017 - 3018 3018 - func (t *Pipeline_Step_Environment_Elem) MarshalCBOR(w io.Writer) error { 3019 3019 - if t == nil { 3020 3020 - _, err := w.Write(cbg.CborNull) 3021 3021 - return err 3022 3022 - } 3023 3023 - 3024 3024 - cw := cbg.NewCborWriter(w) 3025 3025 - 3026 3026 - if _, err := cw.Write([]byte{162}); err != nil { 3027 3027 - return err 3028 3028 - } 3029 3029 - 3030 3030 - // t.Key (string) (string) 3031 3031 - if len("key") > 1000000 { 3032 3032 - return xerrors.Errorf("Value in field \"key\" was too long") 3033 3033 - } 3034 3034 - 3035 3035 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3036 3036 - return err 3037 3037 - } 3038 3038 - if _, err := cw.WriteString(string("key")); err != nil { 3039 3039 - return err 3040 3040 - } 3041 3041 - 3042 3042 - if len(t.Key) > 1000000 { 3043 3043 - return xerrors.Errorf("Value in field t.Key was too long") 3044 3044 - } 3045 3045 - 3046 3046 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3047 3047 - return err 3048 3048 - } 3049 3049 - if _, err := cw.WriteString(string(t.Key)); err != nil { 3050 3050 - return err 3051 3051 - } 3052 3052 - 3053 3053 - // t.Value (string) (string) 3054 3054 - if len("value") > 1000000 { 3055 3055 - return xerrors.Errorf("Value in field \"value\" was too long") 3056 3056 - } 3057 3057 - 3058 3058 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 3059 3059 - return err 3060 3060 - } 3061 3061 - if _, err := cw.WriteString(string("value")); err != nil { 3062 3062 - return err 3063 3063 - } 3064 3064 - 3065 3065 - if len(t.Value) > 1000000 { 3066 3066 - return xerrors.Errorf("Value in field t.Value was too long") 3067 3067 - } 3068 3068 - 3069 3069 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 3070 3070 - return err 3071 3071 - } 3072 3072 - if _, err := cw.WriteString(string(t.Value)); err != nil { 3073 3073 - return err 3074 3074 - } 3075 3075 - return nil 3076 3076 - } 3077 3077 - 3078 3078 - func (t *Pipeline_Step_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 3079 3079 - *t = Pipeline_Step_Environment_Elem{} 3080 3080 - 3081 3081 - cr := cbg.NewCborReader(r) 3082 3082 - 3083 3083 - maj, extra, err := cr.ReadHeader() 3084 3084 - if err != nil { 3085 3085 - return err 3086 3086 - } 3087 3087 - defer func() { 3088 3088 - if err == io.EOF { 3089 3089 - err = io.ErrUnexpectedEOF 3090 3090 - } 3091 3091 - }() 3092 3092 - 3093 3093 - if maj != cbg.MajMap { 3094 3094 - return fmt.Errorf("cbor input should be of type map") 3095 3095 - } 3096 3096 - 3097 3097 - if extra > cbg.MaxLength { 3098 3098 - return fmt.Errorf("Pipeline_Step_Environment_Elem: map struct too large (%d)", extra) 3099 3099 - } 3100 3100 - 3101 3101 - n := extra 3102 3102 - 3103 3103 - nameBuf := make([]byte, 5) 3104 3104 - for i := uint64(0); i < n; i++ { 3105 3105 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3106 3106 - if err != nil { 3107 3107 - return err 3108 3108 - } 3109 3109 - 3110 3110 - if !ok { 3111 3111 - // Field doesn't exist on this type, so ignore it 3112 3112 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3113 3113 - return err 3114 3114 - } 3115 3115 - continue 3116 3116 - } 3117 3117 - 3118 3118 - switch string(nameBuf[:nameLen]) { 3119 3119 - // t.Key (string) (string) 3120 3120 - case "key": 3121 3121 - 3122 3122 - { 3123 3123 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3124 3124 - if err != nil { 3125 3125 - return err 3126 3126 - } 3127 3127 - 3128 3128 - t.Key = string(sval) 3129 3129 - } 3130 3130 - // t.Value (string) (string) 3131 3131 - case "value": 3132 3132 - 3133 3133 - { 3134 3134 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3135 3135 - if err != nil { 3136 3136 - return err 3137 3137 - } 3138 3138 - 3139 3139 - t.Value = string(sval) 3140 3140 - } 3141 3141 - 3142 3142 - default: 3143 3143 - // Field doesn't exist on this type, so ignore it 3144 3144 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3145 3145 - return err 3146 3146 - } 3147 3147 - } 3148 3148 - } 3149 3149 - 3150 3150 - return nil 3151 3151 - } 3152 3017 func (t *PipelineStatus) MarshalCBOR(w io.Writer) error { 3153 3018 if t == nil { 3154 3019 _, err := w.Write(cbg.CborNull) ··· 3511 3376 3512 3377 return nil 3513 3378 } 3514 3514 - 3515 3379 func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error { 3516 3380 if t == nil { 3517 3381 _, err := w.Write(cbg.CborNull) ··· 3575 3439 return err 3576 3440 } 3577 3441 3578 3578 - // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice) 3442 3442 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 3579 3443 if t.Environment != nil { 3580 3444 3581 3445 if len("environment") > 1000000 { ··· 3669 3533 3670 3534 t.Command = string(sval) 3671 3535 } 3672 3672 - // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice) 3536 3536 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 3673 3537 case "environment": 3674 3538 3675 3539 maj, extra, err = cr.ReadHeader() ··· 3686 3550 } 3687 3551 3688 3552 if extra > 0 { 3689 3689 - t.Environment = make([]*Pipeline_Step_Environment_Elem, extra) 3553 3553 + t.Environment = make([]*Pipeline_Pair, extra) 3690 3554 } 3691 3555 3692 3556 for i := 0; i < int(extra); i++ { ··· 3708 3572 if err := cr.UnreadByte(); err != nil { 3709 3573 return err 3710 3574 } 3711 3711 - t.Environment[i] = new(Pipeline_Step_Environment_Elem) 3575 3575 + t.Environment[i] = new(Pipeline_Pair) 3712 3576 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 3713 3577 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 3714 3578 } ··· 4274 4138 4275 4139 } 4276 4140 4277 4277 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 4141 4141 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 4278 4142 if len("environment") > 1000000 { 4279 4143 return xerrors.Errorf("Value in field \"environment\" was too long") 4280 4144 } ··· 4300 4164 4301 4165 } 4302 4166 4303 4303 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 4167 4167 + // t.Dependencies ([]*tangled.Pipeline_Dependency) (slice) 4304 4168 if len("dependencies") > 1000000 { 4305 4169 return xerrors.Errorf("Value in field \"dependencies\" was too long") 4306 4170 } ··· 4449 4313 4450 4314 } 4451 4315 } 4452 4452 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 4316 4316 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 4453 4317 case "environment": 4454 4318 4455 4319 maj, extra, err = cr.ReadHeader() ··· 4466 4330 } 4467 4331 4468 4332 if extra > 0 { 4469 4469 - t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) 4333 4333 + t.Environment = make([]*Pipeline_Pair, extra) 4470 4334 } 4471 4335 4472 4336 for i := 0; i < int(extra); i++ { ··· 4488 4352 if err := cr.UnreadByte(); err != nil { 4489 4353 return err 4490 4354 } 4491 4491 - t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) 4355 4355 + t.Environment[i] = new(Pipeline_Pair) 4492 4356 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 4493 4357 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 4494 4358 } ··· 4498 4362 4499 4363 } 4500 4364 } 4501 4501 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 4365 4365 + // t.Dependencies ([]*tangled.Pipeline_Dependency) (slice) 4502 4366 case "dependencies": 4503 4367 4504 4368 maj, extra, err = cr.ReadHeader() ··· 4515 4379 } 4516 4380 4517 4381 if extra > 0 { 4518 4518 - t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) 4382 4382 + t.Dependencies = make([]*Pipeline_Dependency, extra) 4519 4383 } 4520 4384 4521 4385 for i := 0; i < int(extra); i++ { ··· 4529 4393 4530 4394 { 4531 4395 4532 4532 - if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 4533 4533 - return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) 4396 4396 + b, err := cr.ReadByte() 4397 4397 + if err != nil { 4398 4398 + return err 4399 4399 + } 4400 4400 + if b != cbg.CborNull[0] { 4401 4401 + if err := cr.UnreadByte(); err != nil { 4402 4402 + return err 4403 4403 + } 4404 4404 + t.Dependencies[i] = new(Pipeline_Dependency) 4405 4405 + if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 4406 4406 + return xerrors.Errorf("unmarshaling t.Dependencies[i] pointer: %w", err) 4407 4407 + } 4534 4408 } 4535 4409 4536 4410 } ··· 4548 4422 4549 4423 return nil 4550 4424 } 4551 4551 - func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 4552 4552 - if t == nil { 4553 4553 - _, err := w.Write(cbg.CborNull) 4554 4554 - return err 4555 4555 - } 4556 4556 - 4557 4557 - cw := cbg.NewCborWriter(w) 4558 4558 - 4559 4559 - if _, err := cw.Write([]byte{162}); err != nil { 4560 4560 - return err 4561 4561 - } 4562 4562 - 4563 4563 - // t.Key (string) (string) 4564 4564 - if len("key") > 1000000 { 4565 4565 - return xerrors.Errorf("Value in field \"key\" was too long") 4566 4566 - } 4567 4567 - 4568 4568 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 4569 4569 - return err 4570 4570 - } 4571 4571 - if _, err := cw.WriteString(string("key")); err != nil { 4572 4572 - return err 4573 4573 - } 4574 4574 - 4575 4575 - if len(t.Key) > 1000000 { 4576 4576 - return xerrors.Errorf("Value in field t.Key was too long") 4577 4577 - } 4578 4578 - 4579 4579 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 4580 4580 - return err 4581 4581 - } 4582 4582 - if _, err := cw.WriteString(string(t.Key)); err != nil { 4583 4583 - return err 4584 4584 - } 4585 4585 - 4586 4586 - // t.Value (string) (string) 4587 4587 - if len("value") > 1000000 { 4588 4588 - return xerrors.Errorf("Value in field \"value\" was too long") 4589 4589 - } 4590 4590 - 4591 4591 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 4592 4592 - return err 4593 4593 - } 4594 4594 - if _, err := cw.WriteString(string("value")); err != nil { 4595 4595 - return err 4596 4596 - } 4597 4597 - 4598 4598 - if len(t.Value) > 1000000 { 4599 4599 - return xerrors.Errorf("Value in field t.Value was too long") 4600 4600 - } 4601 4601 - 4602 4602 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 4603 4603 - return err 4604 4604 - } 4605 4605 - if _, err := cw.WriteString(string(t.Value)); err != nil { 4606 4606 - return err 4607 4607 - } 4608 4608 - return nil 4609 4609 - } 4610 4610 - 4611 4611 - func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 4612 4612 - *t = Pipeline_Workflow_Environment_Elem{} 4613 4613 - 4614 4614 - cr := cbg.NewCborReader(r) 4615 4615 - 4616 4616 - maj, extra, err := cr.ReadHeader() 4617 4617 - if err != nil { 4618 4618 - return err 4619 4619 - } 4620 4620 - defer func() { 4621 4621 - if err == io.EOF { 4622 4622 - err = io.ErrUnexpectedEOF 4623 4623 - } 4624 4624 - }() 4625 4625 - 4626 4626 - if maj != cbg.MajMap { 4627 4627 - return fmt.Errorf("cbor input should be of type map") 4628 4628 - } 4629 4629 - 4630 4630 - if extra > cbg.MaxLength { 4631 4631 - return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 4632 4632 - } 4633 4633 - 4634 4634 - n := extra 4635 4635 - 4636 4636 - nameBuf := make([]byte, 5) 4637 4637 - for i := uint64(0); i < n; i++ { 4638 4638 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4639 4639 - if err != nil { 4640 4640 - return err 4641 4641 - } 4642 4642 - 4643 4643 - if !ok { 4644 4644 - // Field doesn't exist on this type, so ignore it 4645 4645 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4646 4646 - return err 4647 4647 - } 4648 4648 - continue 4649 4649 - } 4650 4650 - 4651 4651 - switch string(nameBuf[:nameLen]) { 4652 4652 - // t.Key (string) (string) 4653 4653 - case "key": 4654 4654 - 4655 4655 - { 4656 4656 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4657 4657 - if err != nil { 4658 4658 - return err 4659 4659 - } 4660 4660 - 4661 4661 - t.Key = string(sval) 4662 4662 - } 4663 4663 - // t.Value (string) (string) 4664 4664 - case "value": 4665 4665 - 4666 4666 - { 4667 4667 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4668 4668 - if err != nil { 4669 4669 - return err 4670 4670 - } 4671 4671 - 4672 4672 - t.Value = string(sval) 4673 4673 - } 4674 4674 - 4675 4675 - default: 4676 4676 - // Field doesn't exist on this type, so ignore it 4677 4677 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4678 4678 - return err 4679 4679 - } 4680 4680 - } 4681 4681 - } 4682 4682 - 4683 4683 - return nil 4684 4684 - } 4685 4425 func (t *PublicKey) MarshalCBOR(w io.Writer) error { 4686 4426 if t == nil { 4687 4427 _, err := w.Write(cbg.CborNull)

+13 -21

api/tangled/tangledpipeline.go

··· 29 29 Submodules bool `json:"submodules" cborgen:"submodules"` 30 30 } 31 31 32 32 - type Pipeline_Dependencies_Elem struct { 32 32 + // Pipeline_Dependency is a "dependency" in the sh.tangled.pipeline schema. 33 33 + type Pipeline_Dependency struct { 33 34 Packages []string `json:"packages" cborgen:"packages"` 34 35 Registry string `json:"registry" cborgen:"registry"` 35 36 } 36 37 37 38 // Pipeline_ManualTriggerData is a "manualTriggerData" in the sh.tangled.pipeline schema. 38 39 type Pipeline_ManualTriggerData struct { 39 39 - Inputs []*Pipeline_ManualTriggerData_Inputs_Elem `json:"inputs,omitempty" cborgen:"inputs,omitempty"` 40 40 + Inputs []*Pipeline_Pair `json:"inputs,omitempty" cborgen:"inputs,omitempty"` 40 41 } 41 42 42 42 - type Pipeline_ManualTriggerData_Inputs_Elem struct { 43 43 + // Pipeline_Pair is a "pair" in the sh.tangled.pipeline schema. 44 44 + type Pipeline_Pair struct { 43 45 Key string `json:"key" cborgen:"key"` 44 46 Value string `json:"value" cborgen:"value"` 45 47 } ··· 61 63 62 64 // Pipeline_Step is a "step" in the sh.tangled.pipeline schema. 63 65 type Pipeline_Step struct { 64 64 - Command string `json:"command" cborgen:"command"` 65 65 - Environment []*Pipeline_Step_Environment_Elem `json:"environment,omitempty" cborgen:"environment,omitempty"` 66 66 - Name string `json:"name" cborgen:"name"` 67 67 - } 68 68 - 69 69 - type Pipeline_Step_Environment_Elem struct { 70 70 - Key string `json:"key" cborgen:"key"` 71 71 - Value string `json:"value" cborgen:"value"` 66 66 + Command string `json:"command" cborgen:"command"` 67 67 + Environment []*Pipeline_Pair `json:"environment,omitempty" cborgen:"environment,omitempty"` 68 68 + Name string `json:"name" cborgen:"name"` 72 69 } 73 70 74 71 // Pipeline_TriggerMetadata is a "triggerMetadata" in the sh.tangled.pipeline schema. ··· 90 87 91 88 // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema. 92 89 type Pipeline_Workflow struct { 93 93 - Clone *Pipeline_CloneOpts `json:"clone" cborgen:"clone"` 94 94 - Dependencies []Pipeline_Dependencies_Elem `json:"dependencies" cborgen:"dependencies"` 95 95 - Environment []*Pipeline_Workflow_Environment_Elem `json:"environment" cborgen:"environment"` 96 96 - Name string `json:"name" cborgen:"name"` 97 97 - Steps []*Pipeline_Step `json:"steps" cborgen:"steps"` 98 98 - } 99 99 - 100 100 - type Pipeline_Workflow_Environment_Elem struct { 101 101 - Key string `json:"key" cborgen:"key"` 102 102 - Value string `json:"value" cborgen:"value"` 90 90 + Clone *Pipeline_CloneOpts `json:"clone" cborgen:"clone"` 91 91 + Dependencies []*Pipeline_Dependency `json:"dependencies" cborgen:"dependencies"` 92 92 + Environment []*Pipeline_Pair `json:"environment" cborgen:"environment"` 93 93 + Name string `json:"name" cborgen:"name"` 94 94 + Steps []*Pipeline_Step `json:"steps" cborgen:"steps"` 103 95 }

+2 -4

cmd/gen.go

··· 24 24 tangled.KnotMember{}, 25 25 tangled.Pipeline{}, 26 26 tangled.Pipeline_CloneOpts{}, 27 27 - tangled.Pipeline_Dependencies_Elem{}, 27 27 + tangled.Pipeline_Dependency{}, 28 28 tangled.Pipeline_ManualTriggerData{}, 29 29 - tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, 29 29 + tangled.Pipeline_Pair{}, 30 30 tangled.Pipeline_PullRequestTriggerData{}, 31 31 tangled.Pipeline_PushTriggerData{}, 32 32 - tangled.Pipeline_Step_Environment_Elem{}, 33 32 tangled.PipelineStatus{}, 34 33 tangled.Pipeline_Step{}, 35 34 tangled.Pipeline_TriggerMetadata{}, 36 35 tangled.Pipeline_TriggerRepo{}, 37 36 tangled.Pipeline_Workflow{}, 38 38 - tangled.Pipeline_Workflow_Environment_Elem{}, 39 37 tangled.PublicKey{}, 40 38 tangled.Repo{}, 41 39 tangled.RepoArtifact{},

+9 -5

spindle/models/pipeline.go

··· 83 83 return &Pipeline{Workflows: workflows} 84 84 } 85 85 86 86 - func workflowEnvToMap(envs []*tangled.Pipeline_Workflow_Environment_Elem) map[string]string { 86 86 + func workflowEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string { 87 87 envMap := map[string]string{} 88 88 for _, env := range envs { 89 89 - envMap[env.Key] = env.Value 89 89 + if env != nil { 90 90 + envMap[env.Key] = env.Value 91 91 + } 90 92 } 91 93 return envMap 92 94 } 93 95 94 94 - func stepEnvToMap(envs []*tangled.Pipeline_Step_Environment_Elem) map[string]string { 96 96 + func stepEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string { 95 97 envMap := map[string]string{} 96 98 for _, env := range envs { 97 97 - envMap[env.Key] = env.Value 99 99 + if env != nil { 100 100 + envMap[env.Key] = env.Value 101 101 + } 98 102 } 99 103 return envMap 100 104 } 101 105 102 102 - func workflowImage(deps []tangled.Pipeline_Dependencies_Elem, nixery string) string { 106 106 + func workflowImage(deps []*tangled.Pipeline_Dependency, nixery string) string { 103 107 var dependencies string 104 108 for _, d := range deps { 105 109 if d.Registry == "nixpkgs" {

+2 -2

workflow/compile.go

··· 98 98 Name: s.Name, 99 99 } 100 100 for k, v := range s.Environment { 101 101 - e := &tangled.Pipeline_Step_Environment_Elem{ 101 101 + e := &tangled.Pipeline_Pair{ 102 102 Key: k, 103 103 Value: v, 104 104 } ··· 107 107 cw.Steps = append(cw.Steps, &step) 108 108 } 109 109 for k, v := range w.Environment { 110 110 - e := &tangled.Pipeline_Workflow_Environment_Elem{ 110 110 + e := &tangled.Pipeline_Pair{ 111 111 Key: k, 112 112 Value: v, 113 113 }

+3 -3

workflow/def.go

··· 167 167 } 168 168 169 169 // conversion utilities to atproto records 170 170 - func (d Dependencies) AsRecord() []tangled.Pipeline_Dependencies_Elem { 171 171 - var deps []tangled.Pipeline_Dependencies_Elem 170 170 + func (d Dependencies) AsRecord() []*tangled.Pipeline_Dependency { 171 171 + var deps []*tangled.Pipeline_Dependency 172 172 for registry, packages := range d { 173 173 - deps = append(deps, tangled.Pipeline_Dependencies_Elem{ 173 173 + deps = append(deps, &tangled.Pipeline_Dependency{ 174 174 Registry: registry, 175 175 Packages: packages, 176 176 })