From 33388343948ada4779a815b09e21ec5f4c2ffc5e Mon Sep 17 00:00:00 2001 From: oppiliappan Date: Wed, 10 Sep 2025 10:56:58 +0000 Subject: [PATCH] lexicons: add lexicon for label definition Signed-off-by: oppiliappan --- api/tangled/cbor_gen.go | 896 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------------------------------------------ api/tangled/labeldefinition.go | 42 ++++++++++++++++++++++++++++++++++++++++++ cmd/gen.go | 4 +++- lexicons/label/definition.json | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 file(s) changed, 886 insertion(s)(+), 145 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 @@ -1499,56 +1499,68 @@ } return nil } -func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error { +func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err } cw := cbg.NewCborWriter(w) - fieldCount := 1 - if t.Inputs == nil { - fieldCount-- + if _, err := cw.Write([]byte{162}); err != nil { + return err } - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { + // t.Lang (string) (string) + if len("lang") > 1000000 { + return xerrors.Errorf("Value in field \"lang\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { + return err + } + if _, err := cw.WriteString(string("lang")); err != nil { return err } - // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) - if t.Inputs != nil { + if len(t.Lang) > 1000000 { + return xerrors.Errorf("Value in field t.Lang was too long") + } - if len("inputs") > 1000000 { - return xerrors.Errorf("Value in field \"inputs\" was too long") - } + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Lang)); err != nil { + return err + } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { - return err - } - if _, err := cw.WriteString(string("inputs")); err != nil { - return err - } + // t.Size (int64) (int64) + if len("size") > 1000000 { + return xerrors.Errorf("Value in field \"size\" was too long") + } - if len(t.Inputs) > 8192 { - return xerrors.Errorf("Slice value in field t.Inputs was too long") - } + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { + return err + } + if _, err := cw.WriteString(string("size")); err != nil { + return err + } - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { + if t.Size >= 0 { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { return err } - for _, v := range t.Inputs { - if err := v.MarshalCBOR(cw); err != nil { - return err - } - + } else { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { + return err } } + return nil } -func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { - *t = GitRefUpdate_LangBreakdown{} +func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) { + *t = GitRefUpdate_IndividualLanguageSize{} cr := cbg.NewCborReader(r) @@ -1567,12 +1579,12 @@ return fmt.Errorf("cbor input should be of type map") } if extra > cbg.MaxLength { - return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra) + return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 6) + nameBuf := make([]byte, 4) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1588,54 +1600,42 @@ continue } switch string(nameBuf[:nameLen]) { - // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) - case "inputs": - - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } - - if extra > 8192 { - return fmt.Errorf("t.Inputs: array too large (%d)", extra) - } + // t.Lang (string) (string) + case "lang": - if maj != cbg.MajArray { - return fmt.Errorf("expected cbor array") - } + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } - if extra > 0 { - t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra) + t.Lang = string(sval) } - - for i := 0; i < int(extra); i++ { - { - var maj byte - var extra uint64 - var err error - _ = maj - _ = extra - _ = err - - { - - b, err := cr.ReadByte() - if err != nil { - return err - } - if b != cbg.CborNull[0] { - if err := cr.UnreadByte(); err != nil { - return err - } - t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize) - if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) - } - } - + // t.Size (int64) (int64) + case "size": + { + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + var extraI int64 + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") } - + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative overflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) } + + t.Size = int64(extraI) } default: @@ -1648,68 +1648,56 @@ } return nil } -func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error { +func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err } cw := cbg.NewCborWriter(w) + fieldCount := 1 - if _, err := cw.Write([]byte{162}); err != nil { - return err - } - - // t.Lang (string) (string) - if len("lang") > 1000000 { - return xerrors.Errorf("Value in field \"lang\" was too long") + if t.Inputs == nil { + fieldCount-- } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { - return err - } - if _, err := cw.WriteString(string("lang")); err != nil { + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { return err } - if len(t.Lang) > 1000000 { - return xerrors.Errorf("Value in field t.Lang was too long") - } + // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) + if t.Inputs != nil { - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.Lang)); err != nil { - return err - } + if len("inputs") > 1000000 { + return xerrors.Errorf("Value in field \"inputs\" was too long") + } - // t.Size (int64) (int64) - if len("size") > 1000000 { - return xerrors.Errorf("Value in field \"size\" was too long") - } + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { + return err + } + if _, err := cw.WriteString(string("inputs")); err != nil { + return err + } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { - return err - } - if _, err := cw.WriteString(string("size")); err != nil { - return err - } + if len(t.Inputs) > 8192 { + return xerrors.Errorf("Slice value in field t.Inputs was too long") + } - if t.Size >= 0 { - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { return err } - } else { - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { - return err + for _, v := range t.Inputs { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + } } - return nil } -func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) { - *t = GitRefUpdate_IndividualLanguageSize{} +func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { + *t = GitRefUpdate_LangBreakdown{} cr := cbg.NewCborReader(r) @@ -1728,12 +1716,12 @@ return fmt.Errorf("cbor input should be of type map") } if extra > cbg.MaxLength { - return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra) + return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 4) + nameBuf := make([]byte, 6) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1749,42 +1737,54 @@ continue } switch string(nameBuf[:nameLen]) { - // t.Lang (string) (string) - case "lang": + // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) + case "inputs": - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } - t.Lang = string(sval) + if extra > 8192 { + return fmt.Errorf("t.Inputs: array too large (%d)", extra) } - // t.Size (int64) (int64) - case "size": - { - maj, extra, err := cr.ReadHeader() - if err != nil { - return err - } - var extraI int64 - switch maj { - case cbg.MajUnsignedInt: - extraI = int64(extra) - if extraI < 0 { - return fmt.Errorf("int64 positive overflow") - } - case cbg.MajNegativeInt: - extraI = int64(extra) - if extraI < 0 { - return fmt.Errorf("int64 negative overflow") + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize) + if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) + } + } + } - extraI = -1 - extraI - default: - return fmt.Errorf("wrong type for int64 field: %d", maj) + } - - t.Size = int64(extraI) } default: @@ -2457,6 +2457,614 @@ return err } t.CreatedAt = 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 *LabelDefinition) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + fieldCount := 7 + + if t.Color == nil { + fieldCount-- + } + + if t.Multiple == nil { + fieldCount-- + } + + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); 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.label.definition"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil { + return err + } + + // t.Color (string) (string) + if t.Color != nil { + + if len("color") > 1000000 { + return xerrors.Errorf("Value in field \"color\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil { + return err + } + if _, err := cw.WriteString(string("color")); err != nil { + return err + } + + if t.Color == nil { + if _, err := cw.Write(cbg.CborNull); err != nil { + return err + } + } else { + if len(*t.Color) > 1000000 { + return xerrors.Errorf("Value in field t.Color was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil { + return err + } + if _, err := cw.WriteString(string(*t.Color)); err != nil { + return err + } + } + } + + // t.Scope ([]string) (slice) + if len("scope") > 1000000 { + return xerrors.Errorf("Value in field \"scope\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil { + return err + } + if _, err := cw.WriteString(string("scope")); err != nil { + return err + } + + if len(t.Scope) > 8192 { + return xerrors.Errorf("Slice value in field t.Scope was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil { + return err + } + for _, v := range t.Scope { + 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 + } + + } + + // t.Multiple (bool) (bool) + if t.Multiple != nil { + + if len("multiple") > 1000000 { + return xerrors.Errorf("Value in field \"multiple\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil { + return err + } + if _, err := cw.WriteString(string("multiple")); err != nil { + return err + } + + if t.Multiple == nil { + if _, err := cw.Write(cbg.CborNull); err != nil { + return err + } + } else { + if err := cbg.WriteBool(w, *t.Multiple); err != nil { + return err + } + } + } + + // t.CreatedAt (string) (string) + if len("createdAt") > 1000000 { + return xerrors.Errorf("Value in field \"createdAt\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { + return err + } + if _, err := cw.WriteString(string("createdAt")); err != nil { + return err + } + + if len(t.CreatedAt) > 1000000 { + return xerrors.Errorf("Value in field t.CreatedAt was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { + return err + } + + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) + if len("valueType") > 1000000 { + return xerrors.Errorf("Value in field \"valueType\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil { + return err + } + if _, err := cw.WriteString(string("valueType")); err != nil { + return err + } + + if err := t.ValueType.MarshalCBOR(cw); err != nil { + return err + } + return nil +} + +func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) { + *t = LabelDefinition{} + + 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("LabelDefinition: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 9) + 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.Color (string) (string) + case "color": + + { + 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.Color = (*string)(&sval) + } + } + // t.Scope ([]string) (slice) + case "scope": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.Scope: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Scope = 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.Scope[i] = string(sval) + } + + } + } + // t.Multiple (bool) (bool) + case "multiple": + + { + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + + var val bool + switch extra { + case 20: + val = false + case 21: + val = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + t.Multiple = &val + } + } + // t.CreatedAt (string) (string) + case "createdAt": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.CreatedAt = string(sval) + } + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) + case "valueType": + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.ValueType = new(LabelDefinition_ValueType) + if err := t.ValueType.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.ValueType 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 *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + fieldCount := 3 + + if t.Enum == nil { + fieldCount-- + } + + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { + return err + } + + // t.Enum ([]string) (slice) + if t.Enum != nil { + + if len("enum") > 1000000 { + return xerrors.Errorf("Value in field \"enum\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil { + return err + } + if _, err := cw.WriteString(string("enum")); err != nil { + return err + } + + if len(t.Enum) > 8192 { + return xerrors.Errorf("Slice value in field t.Enum was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil { + return err + } + for _, v := range t.Enum { + 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 + } + + } + } + + // t.Type (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 len(t.Type) > 1000000 { + return xerrors.Errorf("Value in field t.Type was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Type)); err != nil { + return err + } + + // t.Format (string) (string) + if len("format") > 1000000 { + return xerrors.Errorf("Value in field \"format\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil { + return err + } + if _, err := cw.WriteString(string("format")); err != nil { + return err + } + + if len(t.Format) > 1000000 { + return xerrors.Errorf("Value in field t.Format was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Format)); err != nil { + return err + } + return nil +} + +func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) { + *t = LabelDefinition_ValueType{} + + 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("LabelDefinition_ValueType: 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.Enum ([]string) (slice) + case "enum": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.Enum: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Enum = 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.Enum[i] = string(sval) + } + + } + } + // t.Type (string) (string) + case "type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Type = string(sval) + } + // t.Format (string) (string) + case "format": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Format = string(sval) } default: diff --git a/api/tangled/labeldefinition.go b/api/tangled/labeldefinition.go new file mode 100644 --- /dev/null +++ b/api/tangled/labeldefinition.go @@ -0,0 +1,42 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.definition + +import ( + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelDefinitionNSID = "sh.tangled.label.definition" +) + +func init() { + util.RegisterType("sh.tangled.label.definition", &LabelDefinition{}) +} // +// RECORDTYPE: LabelDefinition +type LabelDefinition struct { + LexiconTypeID string `json:"$type,const=sh.tangled.label.definition" cborgen:"$type,const=sh.tangled.label.definition"` + // color: The hex value for the background color for the label. Appviews may choose to respect this. + Color *string `json:"color,omitempty" cborgen:"color,omitempty"` + CreatedAt string `json:"createdAt" cborgen:"createdAt"` + // multiple: Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar] + Multiple *bool `json:"multiple,omitempty" cborgen:"multiple,omitempty"` + // name: The display name of this label. + Name string `json:"name" cborgen:"name"` + // scope: The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. + Scope []string `json:"scope" cborgen:"scope"` + // valueType: The type definition of this label. Appviews may allow sorting for certain types. + ValueType *LabelDefinition_ValueType `json:"valueType" cborgen:"valueType"` +} + +// LabelDefinition_ValueType is a "valueType" in the sh.tangled.label.definition schema. +type LabelDefinition_ValueType struct { + // enum: Closed set of values that this label can take. + Enum []string `json:"enum,omitempty" cborgen:"enum,omitempty"` + // format: An optional constraint that can be applied on string concrete types. + Format string `json:"format" cborgen:"format"` + // type: The concrete type of this label's value. + Type string `json:"type" cborgen:"type"` +} diff --git a/cmd/gen.go b/cmd/gen.go --- a/cmd/gen.go +++ b/cmd/gen.go @@ -20,12 +20,14 @@ tangled.FeedStar{}, tangled.GitRefUpdate{}, tangled.GitRefUpdate_CommitCountBreakdown{}, tangled.GitRefUpdate_IndividualEmailCommitCount{}, - tangled.GitRefUpdate_LangBreakdown{}, tangled.GitRefUpdate_IndividualLanguageSize{}, + tangled.GitRefUpdate_LangBreakdown{}, tangled.GitRefUpdate_Meta{}, tangled.GraphFollow{}, tangled.Knot{}, tangled.KnotMember{}, + tangled.LabelDefinition{}, + tangled.LabelDefinition_ValueType{}, tangled.Pipeline{}, tangled.Pipeline_CloneOpts{}, tangled.Pipeline_ManualTriggerData{}, diff --git a/lexicons/label/definition.json b/lexicons/label/definition.json new file mode 100644 --- /dev/null +++ b/lexicons/label/definition.json @@ -0,0 +1,89 @@ +{ + "lexicon": 1, + "id": "sh.tangled.label.definition", + "needsCbor": true, + "needsType": true, + "defs": { + "main": { + "type": "record", + "key": "any", + "record": { + "type": "object", + "required": [ + "name", + "valueType", + "scope", + "createdAt" + ], + "properties": { + "name": { + "type": "string", + "description": "The display name of this label.", + "minGraphemes": 1, + "maxGraphemes": 40 + }, + "valueType": { + "type": "ref", + "ref": "#valueType", + "description": "The type definition of this label. Appviews may allow sorting for certain types." + }, + "scope": { + "type": "array", + "description": "The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this.", + "items": { + "type": "string", + "format": "nsid" + } + }, + "color": { + "type": "string", + "description": "The hex value for the background color for the label. Appviews may choose to respect this." + }, + "createdAt": { + "type": "string", + "format": "datetime" + }, + "multiple": { + "type": "boolean", + "description": "Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]" + } + } + } + }, + "valueType": { + "type": "object", + "required": [ + "type", + "format" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "null", + "boolean", + "integer", + "string" + ], + "description": "The concrete type of this label's value." + }, + "format": { + "type": "string", + "enum": [ + "any", + "did", + "nsid" + ], + "description": "An optional constraint that can be applied on string concrete types." + }, + "enum": { + "type": "array", + "description": "Closed set of values that this label can take.", + "items": { + "type": "string" + } + } + } + } + } +} -- tangled.sh