commit e3d40eb6bf78ce16ffead3b0c88fe2c685bc3c46 · julien.rbrt.fr/tangled-core

+164

api/tangled/cbor_gen.go

···

       3874
       3874
        
       

     

       3875
       3875
        
       	return nil

     

       3876
       3876
        
       }

     

       3877
       3877
       +
       func (t *Knot) MarshalCBOR(w io.Writer) error {

     

       3878
       3878
       +
       	if t == nil {

     

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

     

       3880
       3880
       +
       		return err

     

       3881
       3881
       +
       	}

     

       3882
       3882
       +
       

     

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

     

       3884
       3884
       +
       

     

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

     

       3886
       3886
       +
       		return err

     

       3887
       3887
       +
       	}

     

       3888
       3888
       +
       

     

       3889
       3889
       +
       	// t.Host (string) (string)

     

       3890
       3890
       +
       	if len("host") > 1000000 {

     

       3891
       3891
       +
       		return xerrors.Errorf("Value in field \"host\" was too long")

     

       3892
       3892
       +
       	}

     

       3893
       3893
       +
       

     

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

     

       3895
       3895
       +
       		return err

     

       3896
       3896
       +
       	}

     

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

     

       3898
       3898
       +
       		return err

     

       3899
       3899
       +
       	}

     

       3900
       3900
       +
       

     

       3901
       3901
       +
       	if len(t.Host) > 1000000 {

     

       3902
       3902
       +
       		return xerrors.Errorf("Value in field t.Host was too long")

     

       3903
       3903
       +
       	}

     

       3904
       3904
       +
       

     

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

     

       3906
       3906
       +
       		return err

     

       3907
       3907
       +
       	}

     

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

     

       3909
       3909
       +
       		return err

     

       3910
       3910
       +
       	}

     

       3911
       3911
       +
       

     

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

     

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

     

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

     

       3915
       3915
       +
       	}

     

       3916
       3916
       +
       

     

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

     

       3918
       3918
       +
       		return err

     

       3919
       3919
       +
       	}

     

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

     

       3921
       3921
       +
       		return err

     

       3922
       3922
       +
       	}

     

       3923
       3923
       +
       

     

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

     

       3925
       3925
       +
       		return err

     

       3926
       3926
       +
       	}

     

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

     

       3928
       3928
       +
       		return err

     

       3929
       3929
       +
       	}

     

       3930
       3930
       +
       

     

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

     

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

     

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

     

       3934
       3934
       +
       	}

     

       3935
       3935
       +
       

     

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

     

       3937
       3937
       +
       		return err

     

       3938
       3938
       +
       	}

     

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

     

       3940
       3940
       +
       		return err

     

       3941
       3941
       +
       	}

     

       3942
       3942
       +
       

     

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

     

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

     

       3945
       3945
       +
       	}

     

       3946
       3946
       +
       

     

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

     

       3948
       3948
       +
       		return err

     

       3949
       3949
       +
       	}

     

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

     

       3951
       3951
       +
       		return err

     

       3952
       3952
       +
       	}

     

       3953
       3953
       +
       	return nil

     

       3954
       3954
       +
       }

     

       3955
       3955
       +
       

     

       3956
       3956
       +
       func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {

     

       3957
       3957
       +
       	*t = Knot{}

     

       3958
       3958
       +
       

     

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

     

       3960
       3960
       +
       

     

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

     

       3962
       3962
       +
       	if err != nil {

     

       3963
       3963
       +
       		return err

     

       3964
       3964
       +
       	}

     

       3965
       3965
       +
       	defer func() {

     

       3966
       3966
       +
       		if err == io.EOF {

     

       3967
       3967
       +
       			err = io.ErrUnexpectedEOF

     

       3968
       3968
       +
       		}

     

       3969
       3969
       +
       	}()

     

       3970
       3970
       +
       

     

       3971
       3971
       +
       	if maj != cbg.MajMap {

     

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

     

       3973
       3973
       +
       	}

     

       3974
       3974
       +
       

     

       3975
       3975
       +
       	if extra > cbg.MaxLength {

     

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

     

       3977
       3977
       +
       	}

     

       3978
       3978
       +
       

     

       3979
       3979
       +
       	n := extra

     

       3980
       3980
       +
       

     

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

     

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

     

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

     

       3984
       3984
       +
       		if err != nil {

     

       3985
       3985
       +
       			return err

     

       3986
       3986
       +
       		}

     

       3987
       3987
       +
       

     

       3988
       3988
       +
       		if !ok {

     

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

     

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

     

       3991
       3991
       +
       				return err

     

       3992
       3992
       +
       			}

     

       3993
       3993
       +
       			continue

     

       3994
       3994
       +
       		}

     

       3995
       3995
       +
       

     

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

     

       3997
       3997
       +
       		// t.Host (string) (string)

     

       3998
       3998
       +
       		case "host":

     

       3999
       3999
       +
       

     

       4000
       4000
       +
       			{

     

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

     

       4002
       4002
       +
       				if err != nil {

     

       4003
       4003
       +
       					return err

     

       4004
       4004
       +
       				}

     

       4005
       4005
       +
       

     

       4006
       4006
       +
       				t.Host = string(sval)

     

       4007
       4007
       +
       			}

     

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

     

       4009
       4009
       +
       		case "$type":

     

       4010
       4010
       +
       

     

       4011
       4011
       +
       			{

     

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

     

       4013
       4013
       +
       				if err != nil {

     

       4014
       4014
       +
       					return err

     

       4015
       4015
       +
       				}

     

       4016
       4016
       +
       

     

       4017
       4017
       +
       				t.LexiconTypeID = string(sval)

     

       4018
       4018
       +
       			}

     

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

     

       4020
       4020
       +
       		case "createdAt":

     

       4021
       4021
       +
       

     

       4022
       4022
       +
       			{

     

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

     

       4024
       4024
       +
       				if err != nil {

     

       4025
       4025
       +
       					return err

     

       4026
       4026
       +
       				}

     

       4027
       4027
       +
       

     

       4028
       4028
       +
       				t.CreatedAt = string(sval)

     

       4029
       4029
       +
       			}

     

       4030
       4030
       +
       

     

       4031
       4031
       +
       		default:

     

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

     

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

     

       4034
       4034
       +
       				return err

     

       4035
       4035
       +
       			}

     

       4036
       4036
       +
       		}

     

       4037
       4037
       +
       	}

     

       4038
       4038
       +
       

     

       4039
       4039
       +
       	return nil

     

       4040
       4040
       +
       }

+24

api/tangled/tangledknot.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.knot

     

       6
       6
       +
       

     

       7
       7
       +
       import (

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	KnotNSID = "sh.tangled.knot"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	util.RegisterType("sh.tangled.knot", &Knot{})

     

       17
       17
       +
       } //

     

       18
       18
       +
       // RECORDTYPE: Knot

     

       19
       19
       +
       type Knot struct {

     

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

     

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

     

       22
       22
       +
       	// host: publicly reachable host of the knot

     

       23
       23
       +
       	Host string `json:"host" cborgen:"host"`

     

       24
       24
       +
       }

cmd/gen.go

···

       28
       28
        
       		tangled.RepoPullComment{},

     

       29
       29
        
       		tangled.RepoArtifact{},

     

       30
       30
        
       		tangled.ActorProfile{},

     

       31
       31
       +
       		tangled.Knot{},

     

       31
       32
        
       	); err != nil {

     

       32
       33
        
       		panic(err)

     

       33
       34
        
       	}

+29

lexicons/knot.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.knot",

     

       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
       +
                 "host",

     

       14
       14
       +
                 "createdAt"

     

       15
       15
       +
               ],

     

       16
       16
       +
               "properties": {

     

       17
       17
       +
                 "host": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "description": "publicly reachable host of the knot"

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "createdAt": {

     

       22
       22
       +
                   "type": "string",

     

       23
       23
       +
                   "format": "datetime"

     

       24
       24
       +
                 }

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }