patch of lexicons: introduce sh.tangled.repo.collaborator · round #0 · pull #396 · tangled.org/core

+198

api/tangled/cbor_gen.go

···

       5854
       5854
        
       

     

       5855
       5855
        
       	return nil

     

       5856
       5856
        
       }

     

       5857
       5857
       +
       func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {

     

       5858
       5858
       +
       	if t == nil {

     

       5859
       5859
       +
       		_, err := w.Write(cbg.CborNull)

     

       5860
       5860
       +
       		return err

     

       5861
       5861
       +
       	}

     

       5862
       5862
       +
       

     

       5863
       5863
       +
       	cw := cbg.NewCborWriter(w)

     

       5864
       5864
       +
       

     

       5865
       5865
       +
       	if _, err := cw.Write([]byte{164}); err != nil {

     

       5866
       5866
       +
       		return err

     

       5867
       5867
       +
       	}

     

       5868
       5868
       +
       

     

       5869
       5869
       +
       	// t.Repo (string) (string)

     

       5870
       5870
       +
       	if len("repo") > 1000000 {

     

       5871
       5871
       +
       		return xerrors.Errorf("Value in field \"repo\" was too long")

     

       5872
       5872
       +
       	}

     

       5873
       5873
       +
       

     

       5874
       5874
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {

     

       5875
       5875
       +
       		return err

     

       5876
       5876
       +
       	}

     

       5877
       5877
       +
       	if _, err := cw.WriteString(string("repo")); err != nil {

     

       5878
       5878
       +
       		return err

     

       5879
       5879
       +
       	}

     

       5880
       5880
       +
       

     

       5881
       5881
       +
       	if len(t.Repo) > 1000000 {

     

       5882
       5882
       +
       		return xerrors.Errorf("Value in field t.Repo was too long")

     

       5883
       5883
       +
       	}

     

       5884
       5884
       +
       

     

       5885
       5885
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {

     

       5886
       5886
       +
       		return err

     

       5887
       5887
       +
       	}

     

       5888
       5888
       +
       	if _, err := cw.WriteString(string(t.Repo)); err != nil {

     

       5889
       5889
       +
       		return err

     

       5890
       5890
       +
       	}

     

       5891
       5891
       +
       

     

       5892
       5892
       +
       	// t.LexiconTypeID (string) (string)

     

       5893
       5893
       +
       	if len("$type") > 1000000 {

     

       5894
       5894
       +
       		return xerrors.Errorf("Value in field \"$type\" was too long")

     

       5895
       5895
       +
       	}

     

       5896
       5896
       +
       

     

       5897
       5897
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {

     

       5898
       5898
       +
       		return err

     

       5899
       5899
       +
       	}

     

       5900
       5900
       +
       	if _, err := cw.WriteString(string("$type")); err != nil {

     

       5901
       5901
       +
       		return err

     

       5902
       5902
       +
       	}

     

       5903
       5903
       +
       

     

       5904
       5904
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {

     

       5905
       5905
       +
       		return err

     

       5906
       5906
       +
       	}

     

       5907
       5907
       +
       	if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {

     

       5908
       5908
       +
       		return err

     

       5909
       5909
       +
       	}

     

       5910
       5910
       +
       

     

       5911
       5911
       +
       	// t.Subject (string) (string)

     

       5912
       5912
       +
       	if len("subject") > 1000000 {

     

       5913
       5913
       +
       		return xerrors.Errorf("Value in field \"subject\" was too long")

     

       5914
       5914
       +
       	}

     

       5915
       5915
       +
       

     

       5916
       5916
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {

     

       5917
       5917
       +
       		return err

     

       5918
       5918
       +
       	}

     

       5919
       5919
       +
       	if _, err := cw.WriteString(string("subject")); err != nil {

     

       5920
       5920
       +
       		return err

     

       5921
       5921
       +
       	}

     

       5922
       5922
       +
       

     

       5923
       5923
       +
       	if len(t.Subject) > 1000000 {

     

       5924
       5924
       +
       		return xerrors.Errorf("Value in field t.Subject was too long")

     

       5925
       5925
       +
       	}

     

       5926
       5926
       +
       

     

       5927
       5927
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {

     

       5928
       5928
       +
       		return err

     

       5929
       5929
       +
       	}

     

       5930
       5930
       +
       	if _, err := cw.WriteString(string(t.Subject)); err != nil {

     

       5931
       5931
       +
       		return err

     

       5932
       5932
       +
       	}

     

       5933
       5933
       +
       

     

       5934
       5934
       +
       	// t.CreatedAt (string) (string)

     

       5935
       5935
       +
       	if len("createdAt") > 1000000 {

     

       5936
       5936
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       5937
       5937
       +
       	}

     

       5938
       5938
       +
       

     

       5939
       5939
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       5940
       5940
       +
       		return err

     

       5941
       5941
       +
       	}

     

       5942
       5942
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       5943
       5943
       +
       		return err

     

       5944
       5944
       +
       	}

     

       5945
       5945
       +
       

     

       5946
       5946
       +
       	if len(t.CreatedAt) > 1000000 {

     

       5947
       5947
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       5948
       5948
       +
       	}

     

       5949
       5949
       +
       

     

       5950
       5950
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       5951
       5951
       +
       		return err

     

       5952
       5952
       +
       	}

     

       5953
       5953
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       5954
       5954
       +
       		return err

     

       5955
       5955
       +
       	}

     

       5956
       5956
       +
       	return nil

     

       5957
       5957
       +
       }

     

       5958
       5958
       +
       

     

       5959
       5959
       +
       func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {

     

       5960
       5960
       +
       	*t = RepoCollaborator{}

     

       5961
       5961
       +
       

     

       5962
       5962
       +
       	cr := cbg.NewCborReader(r)

     

       5963
       5963
       +
       

     

       5964
       5964
       +
       	maj, extra, err := cr.ReadHeader()

     

       5965
       5965
       +
       	if err != nil {

     

       5966
       5966
       +
       		return err

     

       5967
       5967
       +
       	}

     

       5968
       5968
       +
       	defer func() {

     

       5969
       5969
       +
       		if err == io.EOF {

     

       5970
       5970
       +
       			err = io.ErrUnexpectedEOF

     

       5971
       5971
       +
       		}

     

       5972
       5972
       +
       	}()

     

       5973
       5973
       +
       

     

       5974
       5974
       +
       	if maj != cbg.MajMap {

     

       5975
       5975
       +
       		return fmt.Errorf("cbor input should be of type map")

     

       5976
       5976
       +
       	}

     

       5977
       5977
       +
       

     

       5978
       5978
       +
       	if extra > cbg.MaxLength {

     

       5979
       5979
       +
       		return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)

     

       5980
       5980
       +
       	}

     

       5981
       5981
       +
       

     

       5982
       5982
       +
       	n := extra

     

       5983
       5983
       +
       

     

       5984
       5984
       +
       	nameBuf := make([]byte, 9)

     

       5985
       5985
       +
       	for i := uint64(0); i < n; i++ {

     

       5986
       5986
       +
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       5987
       5987
       +
       		if err != nil {

     

       5988
       5988
       +
       			return err

     

       5989
       5989
       +
       		}

     

       5990
       5990
       +
       

     

       5991
       5991
       +
       		if !ok {

     

       5992
       5992
       +
       			// Field doesn't exist on this type, so ignore it

     

       5993
       5993
       +
       			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {

     

       5994
       5994
       +
       				return err

     

       5995
       5995
       +
       			}

     

       5996
       5996
       +
       			continue

     

       5997
       5997
       +
       		}

     

       5998
       5998
       +
       

     

       5999
       5999
       +
       		switch string(nameBuf[:nameLen]) {

     

       6000
       6000
       +
       		// t.Repo (string) (string)

     

       6001
       6001
       +
       		case "repo":

     

       6002
       6002
       +
       

     

       6003
       6003
       +
       			{

     

       6004
       6004
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6005
       6005
       +
       				if err != nil {

     

       6006
       6006
       +
       					return err

     

       6007
       6007
       +
       				}

     

       6008
       6008
       +
       

     

       6009
       6009
       +
       				t.Repo = string(sval)

     

       6010
       6010
       +
       			}

     

       6011
       6011
       +
       			// t.LexiconTypeID (string) (string)

     

       6012
       6012
       +
       		case "$type":

     

       6013
       6013
       +
       

     

       6014
       6014
       +
       			{

     

       6015
       6015
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6016
       6016
       +
       				if err != nil {

     

       6017
       6017
       +
       					return err

     

       6018
       6018
       +
       				}

     

       6019
       6019
       +
       

     

       6020
       6020
       +
       				t.LexiconTypeID = string(sval)

     

       6021
       6021
       +
       			}

     

       6022
       6022
       +
       			// t.Subject (string) (string)

     

       6023
       6023
       +
       		case "subject":

     

       6024
       6024
       +
       

     

       6025
       6025
       +
       			{

     

       6026
       6026
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6027
       6027
       +
       				if err != nil {

     

       6028
       6028
       +
       					return err

     

       6029
       6029
       +
       				}

     

       6030
       6030
       +
       

     

       6031
       6031
       +
       				t.Subject = string(sval)

     

       6032
       6032
       +
       			}

     

       6033
       6033
       +
       			// t.CreatedAt (string) (string)

     

       6034
       6034
       +
       		case "createdAt":

     

       6035
       6035
       +
       

     

       6036
       6036
       +
       			{

     

       6037
       6037
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6038
       6038
       +
       				if err != nil {

     

       6039
       6039
       +
       					return err

     

       6040
       6040
       +
       				}

     

       6041
       6041
       +
       

     

       6042
       6042
       +
       				t.CreatedAt = string(sval)

     

       6043
       6043
       +
       			}

     

       6044
       6044
       +
       

     

       6045
       6045
       +
       		default:

     

       6046
       6046
       +
       			// Field doesn't exist on this type, so ignore it

     

       6047
       6047
       +
       			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {

     

       6048
       6048
       +
       				return err

     

       6049
       6049
       +
       			}

     

       6050
       6050
       +
       		}

     

       6051
       6051
       +
       	}

     

       6052
       6052
       +
       

     

       6053
       6053
       +
       	return nil

     

       6054
       6054
       +
       }

     

       5857
       6055
        
       func (t *RepoIssue) MarshalCBOR(w io.Writer) error {

     

       5858
       6056
        
       	if t == nil {

     

       5859
       6057
        
       		_, err := w.Write(cbg.CborNull)

+25

api/tangled/repocollaborator.go

···

       1
       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       2
       +
       

     

       3
       3
       +
       package tangled

     

       4
       4
       +
       

     

       5
       5
       +
       // schema: sh.tangled.repo.collaborator

     

       6
       6
       +
       

     

       7
       7
       +
       import (

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	RepoCollaboratorNSID = "sh.tangled.repo.collaborator"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	util.RegisterType("sh.tangled.repo.collaborator", &RepoCollaborator{})

     

       17
       17
       +
       } //

     

       18
       18
       +
       // RECORDTYPE: RepoCollaborator

     

       19
       19
       +
       type RepoCollaborator struct {

     

       20
       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"`

     

       21
       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
       22
       +
       	// repo: repo to add this user to

     

       23
       23
       +
       	Repo    string `json:"repo" cborgen:"repo"`

     

       24
       24
       +
       	Subject string `json:"subject" cborgen:"subject"`

     

       25
       25
       +
       }

cmd/gen.go

···

       40
       40
        
       		tangled.PublicKey{},

     

       41
       41
        
       		tangled.Repo{},

     

       42
       42
        
       		tangled.RepoArtifact{},

     

       43
       43
       +
       		tangled.RepoCollaborator{},

     

       43
       44
        
       		tangled.RepoIssue{},

     

       44
       45
        
       		tangled.RepoIssueComment{},

     

       45
       46
        
       		tangled.RepoIssueState{},

+36

lexicons/repo/collaborator.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.collaborator",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "record",

     

       9
       9
       +
             "key": "tid",

     

       10
       10
       +
             "record": {

     

       11
       11
       +
               "type": "object",

     

       12
       12
       +
               "required": [

     

       13
       13
       +
                 "subject",

     

       14
       14
       +
                 "repo",

     

       15
       15
       +
                 "createdAt"

     

       16
       16
       +
               ],

     

       17
       17
       +
               "properties": {

     

       18
       18
       +
                 "subject": {

     

       19
       19
       +
                   "type": "string",

     

       20
       20
       +
                   "format": "did"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "repo": {

     

       23
       23
       +
                   "type": "string",

     

       24
       24
       +
                   "description": "repo to add this user to",

     

       25
       25
       +
                   "format": "at-uri"

     

       26
       26
       +
                 },

     

       27
       27
       +
                 "createdAt": {

     

       28
       28
       +
                   "type": "string",

     

       29
       29
       +
                   "format": "datetime"

     

       30
       30
       +
                 }

     

       31
       31
       +
               }

     

       32
       32
       +
             }

     

       33
       33
       +
           }

     

       34
       34
       +
         }

     

       35
       35
       +
       }

     

       36
       36
       +