From 4b13df4d9265d96951b3e4f975ef03eaf5f64a43 Mon Sep 17 00:00:00 2001 From: Seongmin Lee Date: Tue, 30 Dec 2025 03:35:02 +0000 Subject: [PATCH] lexicons: add new CI lexicons Signed-off-by: Seongmin Lee --- api/tangled/cbor_gen.go | 911 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ api/tangled/cievent.go | 124 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ api/tangled/cipipeline.go | 23 +++++++++++++++++++++++ api/tangled/workflowrun.go | 24 ++++++++++++++++++++++++ api/tangled/workflowstatus.go | 9 +++++++++ cmd/cborgen/cborgen.go | 6 ++++++ lexicons/ci/event.json | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ lexicons/ci/pipeline.json | 30 ++++++++++++++++++++++++++++++ lexicons/ci/workflow/run.json | 30 ++++++++++++++++++++++++++++++ lexicons/ci/workflow/status.json | 18 ++++++++++++++++++ 10 file(s) changed, 1232 insertion(s)(+), 0 deletion(s)(-) diff --git a/api/tangled/cbor_gen.go b/api/tangled/cbor_gen.go --- a/api/tangled/cbor_gen.go +++ b/api/tangled/cbor_gen.go @@ -9933,3 +9933,914 @@ return nil } +func (t *CiEvent) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); err != nil { + return err + } + + // t.Meta (tangled.CiEvent_Meta) (struct) + if len("meta") > 1000000 { + return xerrors.Errorf("Value in field \"meta\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { + return err + } + if _, err := cw.WriteString(string("meta")); err != nil { + return err + } + + if err := t.Meta.MarshalCBOR(cw); err != nil { + return err + } + return nil +} + +func (t *CiEvent) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiEvent{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiEvent: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 4) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.Meta (tangled.CiEvent_Meta) (struct) + case "meta": + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Meta = new(CiEvent_Meta) + if err := t.Meta.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) + } + } + + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *CiEvent_PullRequest) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); err != nil { + return err + } + + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#pullRequest"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.ci.event#pullRequest")); err != nil { + return err + } + return nil +} + +func (t *CiEvent_PullRequest) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiEvent_PullRequest{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiEvent_PullRequest: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 5) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *CiEvent_Push) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{164}); err != nil { + return err + } + + // t.Ref (string) (string) + if len("ref") > 1000000 { + return xerrors.Errorf("Value in field \"ref\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { + return err + } + if _, err := cw.WriteString(string("ref")); err != nil { + return err + } + + if len(t.Ref) > 1000000 { + return xerrors.Errorf("Value in field t.Ref was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Ref)); err != nil { + return err + } + + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#push"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.ci.event#push")); err != nil { + return err + } + + // t.NewSha (string) (string) + if len("newSha") > 1000000 { + return xerrors.Errorf("Value in field \"newSha\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { + return err + } + if _, err := cw.WriteString(string("newSha")); err != nil { + return err + } + + if len(t.NewSha) > 1000000 { + return xerrors.Errorf("Value in field t.NewSha was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.NewSha)); err != nil { + return err + } + + // t.OldSha (string) (string) + if len("oldSha") > 1000000 { + return xerrors.Errorf("Value in field \"oldSha\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { + return err + } + if _, err := cw.WriteString(string("oldSha")); err != nil { + return err + } + + if len(t.OldSha) > 1000000 { + return xerrors.Errorf("Value in field t.OldSha was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.OldSha)); err != nil { + return err + } + return nil +} + +func (t *CiEvent_Push) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiEvent_Push{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiEvent_Push: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 6) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.Ref (string) (string) + case "ref": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Ref = string(sval) + } + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + // t.NewSha (string) (string) + case "newSha": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.NewSha = string(sval) + } + // t.OldSha (string) (string) + case "oldSha": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.OldSha = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *CiEvent_Manual) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); err != nil { + return err + } + + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#manual"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.ci.event#manual")); err != nil { + return err + } + return nil +} + +func (t *CiEvent_Manual) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiEvent_Manual{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiEvent_Manual: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 5) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *CiPipeline) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{163}); err != nil { + return err + } + + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.pipeline"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.ci.pipeline")); err != nil { + return err + } + + // t.Event (tangled.CiEvent) (struct) + if len("event") > 1000000 { + return xerrors.Errorf("Value in field \"event\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("event"))); err != nil { + return err + } + if _, err := cw.WriteString(string("event")); err != nil { + return err + } + + if err := t.Event.MarshalCBOR(cw); err != nil { + return err + } + + // t.WorkflowRuns ([]string) (slice) + if len("workflowRuns") > 1000000 { + return xerrors.Errorf("Value in field \"workflowRuns\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflowRuns"))); err != nil { + return err + } + if _, err := cw.WriteString(string("workflowRuns")); err != nil { + return err + } + + if len(t.WorkflowRuns) > 8192 { + return xerrors.Errorf("Slice value in field t.WorkflowRuns was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.WorkflowRuns))); err != nil { + return err + } + for _, v := range t.WorkflowRuns { + if len(v) > 1000000 { + return xerrors.Errorf("Value in field v was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { + return err + } + if _, err := cw.WriteString(string(v)); err != nil { + return err + } + + } + return nil +} + +func (t *CiPipeline) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiPipeline{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiPipeline: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 12) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + // t.Event (tangled.CiEvent) (struct) + case "event": + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Event = new(CiEvent) + if err := t.Event.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Event pointer: %w", err) + } + } + + } + // t.WorkflowRuns ([]string) (slice) + case "workflowRuns": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.WorkflowRuns: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.WorkflowRuns = make([]string, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.WorkflowRuns[i] = string(sval) + } + + } + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *CiWorkflowRun) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{164}); err != nil { + return err + } + + // t.Name (string) (string) + if len("name") > 1000000 { + return xerrors.Errorf("Value in field \"name\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { + return err + } + if _, err := cw.WriteString(string("name")); err != nil { + return err + } + + if len(t.Name) > 1000000 { + return xerrors.Errorf("Value in field t.Name was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Name)); err != nil { + return err + } + + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.workflow.run"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.ci.workflow.run")); err != nil { + return err + } + + // t.Status (string) (string) + if len("status") > 1000000 { + return xerrors.Errorf("Value in field \"status\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { + return err + } + if _, err := cw.WriteString(string("status")); err != nil { + return err + } + + if t.Status == nil { + if _, err := cw.Write(cbg.CborNull); err != nil { + return err + } + } else { + if len(*t.Status) > 1000000 { + return xerrors.Errorf("Value in field t.Status was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil { + return err + } + if _, err := cw.WriteString(string(*t.Status)); err != nil { + return err + } + } + + // t.Adapter (string) (string) + if len("adapter") > 1000000 { + return xerrors.Errorf("Value in field \"adapter\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("adapter"))); err != nil { + return err + } + if _, err := cw.WriteString(string("adapter")); err != nil { + return err + } + + if len(t.Adapter) > 1000000 { + return xerrors.Errorf("Value in field t.Adapter was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Adapter))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Adapter)); err != nil { + return err + } + return nil +} + +func (t *CiWorkflowRun) UnmarshalCBOR(r io.Reader) (err error) { + *t = CiWorkflowRun{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("CiWorkflowRun: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 7) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.Name (string) (string) + case "name": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Name = string(sval) + } + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + // t.Status (string) (string) + case "status": + + { + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Status = (*string)(&sval) + } + } + // t.Adapter (string) (string) + case "adapter": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Adapter = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} diff --git a/api/tangled/cievent.go b/api/tangled/cievent.go new file mode 100644 --- /dev/null +++ b/api/tangled/cievent.go @@ -0,0 +1,124 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +// Lexicon schema: sh.tangled.ci.event + +package tangled + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + + lexutil "github.com/bluesky-social/indigo/lex/util" + cbg "github.com/whyrusleeping/cbor-gen" +) + +const ( + CiEventNSID = "sh.tangled.ci.event" +) + +// CiEvent is a "main" in the sh.tangled.ci.event schema. +type CiEvent struct { + Meta *CiEvent_Meta `json:"meta" cborgen:"meta"` +} + +// CiEvent_Manual is a "manual" in the sh.tangled.ci.event schema. +type CiEvent_Manual struct { + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#manual"` +} + +type CiEvent_Meta struct { + CiEvent_PullRequest *CiEvent_PullRequest + CiEvent_Push *CiEvent_Push + CiEvent_Manual *CiEvent_Manual +} + +func (t *CiEvent_Meta) MarshalJSON() ([]byte, error) { + if t.CiEvent_PullRequest != nil { + t.CiEvent_PullRequest.LexiconTypeID = "sh.tangled.ci.event#pullRequest" + return json.Marshal(t.CiEvent_PullRequest) + } + if t.CiEvent_Push != nil { + t.CiEvent_Push.LexiconTypeID = "sh.tangled.ci.event#push" + return json.Marshal(t.CiEvent_Push) + } + if t.CiEvent_Manual != nil { + t.CiEvent_Manual.LexiconTypeID = "sh.tangled.ci.event#manual" + return json.Marshal(t.CiEvent_Manual) + } + return nil, fmt.Errorf("can not marshal empty union as JSON") +} + +func (t *CiEvent_Meta) UnmarshalJSON(b []byte) error { + typ, err := lexutil.TypeExtract(b) + if err != nil { + return err + } + + switch typ { + case "sh.tangled.ci.event#pullRequest": + t.CiEvent_PullRequest = new(CiEvent_PullRequest) + return json.Unmarshal(b, t.CiEvent_PullRequest) + case "sh.tangled.ci.event#push": + t.CiEvent_Push = new(CiEvent_Push) + return json.Unmarshal(b, t.CiEvent_Push) + case "sh.tangled.ci.event#manual": + t.CiEvent_Manual = new(CiEvent_Manual) + return json.Unmarshal(b, t.CiEvent_Manual) + default: + return nil + } +} + +func (t *CiEvent_Meta) MarshalCBOR(w io.Writer) error { + + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if t.CiEvent_PullRequest != nil { + return t.CiEvent_PullRequest.MarshalCBOR(w) + } + if t.CiEvent_Push != nil { + return t.CiEvent_Push.MarshalCBOR(w) + } + if t.CiEvent_Manual != nil { + return t.CiEvent_Manual.MarshalCBOR(w) + } + return fmt.Errorf("can not marshal empty union as CBOR") +} + +func (t *CiEvent_Meta) UnmarshalCBOR(r io.Reader) error { + typ, b, err := lexutil.CborTypeExtractReader(r) + if err != nil { + return err + } + + switch typ { + case "sh.tangled.ci.event#pullRequest": + t.CiEvent_PullRequest = new(CiEvent_PullRequest) + return t.CiEvent_PullRequest.UnmarshalCBOR(bytes.NewReader(b)) + case "sh.tangled.ci.event#push": + t.CiEvent_Push = new(CiEvent_Push) + return t.CiEvent_Push.UnmarshalCBOR(bytes.NewReader(b)) + case "sh.tangled.ci.event#manual": + t.CiEvent_Manual = new(CiEvent_Manual) + return t.CiEvent_Manual.UnmarshalCBOR(bytes.NewReader(b)) + default: + return nil + } +} + +// CiEvent_PullRequest is a "pullRequest" in the sh.tangled.ci.event schema. +type CiEvent_PullRequest struct { + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#pullRequest"` +} + +// CiEvent_Push is a "push" in the sh.tangled.ci.event schema. +type CiEvent_Push struct { + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#push"` + NewSha string `json:"newSha" cborgen:"newSha"` + OldSha string `json:"oldSha" cborgen:"oldSha"` + Ref string `json:"ref" cborgen:"ref"` +} diff --git a/api/tangled/cipipeline.go b/api/tangled/cipipeline.go new file mode 100644 --- /dev/null +++ b/api/tangled/cipipeline.go @@ -0,0 +1,23 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +// Lexicon schema: sh.tangled.ci.pipeline + +package tangled + +import ( + lexutil "github.com/bluesky-social/indigo/lex/util" +) + +const ( + CiPipelineNSID = "sh.tangled.ci.pipeline" +) + +func init() { + lexutil.RegisterType("sh.tangled.ci.pipeline", &CiPipeline{}) +} + +type CiPipeline struct { + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.pipeline"` + Event *CiEvent `json:"event" cborgen:"event"` + WorkflowRuns []string `json:"workflowRuns" cborgen:"workflowRuns"` +} diff --git a/api/tangled/workflowrun.go b/api/tangled/workflowrun.go new file mode 100644 --- /dev/null +++ b/api/tangled/workflowrun.go @@ -0,0 +1,24 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +// Lexicon schema: sh.tangled.ci.workflow.run + +package tangled + +import ( + lexutil "github.com/bluesky-social/indigo/lex/util" +) + +const ( + CiWorkflowRunNSID = "sh.tangled.ci.workflow.run" +) + +func init() { + lexutil.RegisterType("sh.tangled.ci.workflow.run", &CiWorkflowRun{}) +} + +type CiWorkflowRun struct { + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.workflow.run"` + Adapter string `json:"adapter" cborgen:"adapter"` + Name string `json:"name" cborgen:"name"` + Status *string `json:"status" cborgen:"status"` +} diff --git a/api/tangled/workflowstatus.go b/api/tangled/workflowstatus.go new file mode 100644 --- /dev/null +++ b/api/tangled/workflowstatus.go @@ -0,0 +1,9 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +// Lexicon schema: sh.tangled.ci.workflow.status + +package tangled + +const ( + CiWorkflowStatusNSID = "sh.tangled.ci.workflow.status" +) diff --git a/cmd/cborgen/cborgen.go b/cmd/cborgen/cborgen.go --- a/cmd/cborgen/cborgen.go +++ b/cmd/cborgen/cborgen.go @@ -55,6 +55,12 @@ tangled.Spindle{}, tangled.SpindleMember{}, tangled.String{}, + tangled.CiEvent{}, + tangled.CiEvent_PullRequest{}, + tangled.CiEvent_Push{}, + tangled.CiEvent_Manual{}, + tangled.CiPipeline{}, + tangled.CiWorkflowRun{}, ); err != nil { panic(err) } diff --git a/lexicons/ci/event.json b/lexicons/ci/event.json new file mode 100644 --- /dev/null +++ b/lexicons/ci/event.json @@ -0,0 +1,57 @@ +{ + "lexicon": 1, + "id": "sh.tangled.ci.event", + "needsCbor": true, + "needsType": true, + "defs": { + "main": { + "type": "object", + "required": [ + "meta" + ], + "properties": { + "meta": { + "type": "union", + "refs": [ + "#pullRequest", + "#push", + "#manual" + ] + } + } + }, + "pullRequest": { + "type": "object", + "required": [], + "properties": {} + }, + "push": { + "type": "object", + "required": [ + "ref", + "oldSha", + "newSha" + ], + "properties": { + "ref": { + "type": "string" + }, + "oldSha": { + "type": "string", + "minLength": 40, + "maxLength": 40 + }, + "newSha": { + "type": "string", + "minLength": 40, + "maxLength": 40 + } + } + }, + "manual": { + "type": "object", + "required": [], + "properties": {} + } + } +} diff --git a/lexicons/ci/pipeline.json b/lexicons/ci/pipeline.json new file mode 100644 --- /dev/null +++ b/lexicons/ci/pipeline.json @@ -0,0 +1,30 @@ +{ + "lexicon": 1, + "id": "sh.tangled.ci.pipeline", + "defs": { + "main": { + "type": "record", + "key": "tid", + "record": { + "type": "object", + "required": [ + "event", + "workflowRuns" + ], + "properties": { + "event": { + "type": "ref", + "ref": "sh.tangled.ci.event" + }, + "workflowRuns": { + "type": "array", + "items": { + "type": "string", + "format": "at-uri" + } + } + } + } + } + } +} diff --git a/lexicons/ci/workflow/run.json b/lexicons/ci/workflow/run.json new file mode 100644 --- /dev/null +++ b/lexicons/ci/workflow/run.json @@ -0,0 +1,30 @@ +{ + "lexicon": 1, + "id": "sh.tangled.ci.workflow.run", + "defs": { + "main": { + "type": "record", + "key": "tid", + "record": { + "type": "object", + "required": [ + "name", + "adapter", + "status" + ], + "properties": { + "name": { + "type": "string" + }, + "adapter": { + "type": "string" + }, + "status": { + "type": "ref", + "ref": "sh.tangled.ci.workflow.status" + } + } + } + } + } +} diff --git a/lexicons/ci/workflow/status.json b/lexicons/ci/workflow/status.json new file mode 100644 --- /dev/null +++ b/lexicons/ci/workflow/status.json @@ -0,0 +1,18 @@ +{ + "lexicon": 1, + "id": "sh.tangled.ci.workflow.status", + "defs": { + "main": { + "type": "string", + "description": "status of the workflow run", + "enum": [ + "pending", + "running", + "failed", + "timeout", + "cancelled", + "success" + ] + } + } +} -- tangled.sh