patch of lexicons: add sh.tangled.string · round #0 · pull #410 · tangled.org/core

+232

api/tangled/cbor_gen.go

···

       8423
        
       

     

       8424
        
       	return nil

     

       8425
        
       }

     

       8426
       +
       func (t *String) MarshalCBOR(w io.Writer) error {

     

       8427
       +
       	if t == nil {

     

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

     

       8429
       +
       		return err

     

       8430
       +
       	}

     

       8431
       +
       

     

       8432
       +
       	cw := cbg.NewCborWriter(w)

     

       8433
       +
       

     

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

     

       8435
       +
       		return err

     

       8436
       +
       	}

     

       8437
       +
       

     

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

     

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

     

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

     

       8441
       +
       	}

     

       8442
       +
       

     

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

     

       8444
       +
       		return err

     

       8445
       +
       	}

     

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

     

       8447
       +
       		return err

     

       8448
       +
       	}

     

       8449
       +
       

     

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

     

       8451
       +
       		return err

     

       8452
       +
       	}

     

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

     

       8454
       +
       		return err

     

       8455
       +
       	}

     

       8456
       +
       

     

       8457
       +
       	// t.Contents (string) (string)

     

       8458
       +
       	if len("contents") > 1000000 {

     

       8459
       +
       		return xerrors.Errorf("Value in field \"contents\" was too long")

     

       8460
       +
       	}

     

       8461
       +
       

     

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

     

       8463
       +
       		return err

     

       8464
       +
       	}

     

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

     

       8466
       +
       		return err

     

       8467
       +
       	}

     

       8468
       +
       

     

       8469
       +
       	if len(t.Contents) > 1000000 {

     

       8470
       +
       		return xerrors.Errorf("Value in field t.Contents was too long")

     

       8471
       +
       	}

     

       8472
       +
       

     

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

     

       8474
       +
       		return err

     

       8475
       +
       	}

     

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

     

       8477
       +
       		return err

     

       8478
       +
       	}

     

       8479
       +
       

     

       8480
       +
       	// t.Filename (string) (string)

     

       8481
       +
       	if len("filename") > 1000000 {

     

       8482
       +
       		return xerrors.Errorf("Value in field \"filename\" was too long")

     

       8483
       +
       	}

     

       8484
       +
       

     

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

     

       8486
       +
       		return err

     

       8487
       +
       	}

     

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

     

       8489
       +
       		return err

     

       8490
       +
       	}

     

       8491
       +
       

     

       8492
       +
       	if len(t.Filename) > 1000000 {

     

       8493
       +
       		return xerrors.Errorf("Value in field t.Filename was too long")

     

       8494
       +
       	}

     

       8495
       +
       

     

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

     

       8497
       +
       		return err

     

       8498
       +
       	}

     

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

     

       8500
       +
       		return err

     

       8501
       +
       	}

     

       8502
       +
       

     

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

     

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

     

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

     

       8506
       +
       	}

     

       8507
       +
       

     

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

     

       8509
       +
       		return err

     

       8510
       +
       	}

     

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

     

       8512
       +
       		return err

     

       8513
       +
       	}

     

       8514
       +
       

     

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

     

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

     

       8517
       +
       	}

     

       8518
       +
       

     

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

     

       8520
       +
       		return err

     

       8521
       +
       	}

     

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

     

       8523
       +
       		return err

     

       8524
       +
       	}

     

       8525
       +
       

     

       8526
       +
       	// t.Description (string) (string)

     

       8527
       +
       	if len("description") > 1000000 {

     

       8528
       +
       		return xerrors.Errorf("Value in field \"description\" was too long")

     

       8529
       +
       	}

     

       8530
       +
       

     

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

     

       8532
       +
       		return err

     

       8533
       +
       	}

     

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

     

       8535
       +
       		return err

     

       8536
       +
       	}

     

       8537
       +
       

     

       8538
       +
       	if len(t.Description) > 1000000 {

     

       8539
       +
       		return xerrors.Errorf("Value in field t.Description was too long")

     

       8540
       +
       	}

     

       8541
       +
       

     

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

     

       8543
       +
       		return err

     

       8544
       +
       	}

     

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

     

       8546
       +
       		return err

     

       8547
       +
       	}

     

       8548
       +
       	return nil

     

       8549
       +
       }

     

       8550
       +
       

     

       8551
       +
       func (t *String) UnmarshalCBOR(r io.Reader) (err error) {

     

       8552
       +
       	*t = String{}

     

       8553
       +
       

     

       8554
       +
       	cr := cbg.NewCborReader(r)

     

       8555
       +
       

     

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

     

       8557
       +
       	if err != nil {

     

       8558
       +
       		return err

     

       8559
       +
       	}

     

       8560
       +
       	defer func() {

     

       8561
       +
       		if err == io.EOF {

     

       8562
       +
       			err = io.ErrUnexpectedEOF

     

       8563
       +
       		}

     

       8564
       +
       	}()

     

       8565
       +
       

     

       8566
       +
       	if maj != cbg.MajMap {

     

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

     

       8568
       +
       	}

     

       8569
       +
       

     

       8570
       +
       	if extra > cbg.MaxLength {

     

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

     

       8572
       +
       	}

     

       8573
       +
       

     

       8574
       +
       	n := extra

     

       8575
       +
       

     

       8576
       +
       	nameBuf := make([]byte, 11)

     

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

     

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

     

       8579
       +
       		if err != nil {

     

       8580
       +
       			return err

     

       8581
       +
       		}

     

       8582
       +
       

     

       8583
       +
       		if !ok {

     

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

     

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

     

       8586
       +
       				return err

     

       8587
       +
       			}

     

       8588
       +
       			continue

     

       8589
       +
       		}

     

       8590
       +
       

     

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

     

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

     

       8593
       +
       		case "$type":

     

       8594
       +
       

     

       8595
       +
       			{

     

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

     

       8597
       +
       				if err != nil {

     

       8598
       +
       					return err

     

       8599
       +
       				}

     

       8600
       +
       

     

       8601
       +
       				t.LexiconTypeID = string(sval)

     

       8602
       +
       			}

     

       8603
       +
       			// t.Contents (string) (string)

     

       8604
       +
       		case "contents":

     

       8605
       +
       

     

       8606
       +
       			{

     

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

     

       8608
       +
       				if err != nil {

     

       8609
       +
       					return err

     

       8610
       +
       				}

     

       8611
       +
       

     

       8612
       +
       				t.Contents = string(sval)

     

       8613
       +
       			}

     

       8614
       +
       			// t.Filename (string) (string)

     

       8615
       +
       		case "filename":

     

       8616
       +
       

     

       8617
       +
       			{

     

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

     

       8619
       +
       				if err != nil {

     

       8620
       +
       					return err

     

       8621
       +
       				}

     

       8622
       +
       

     

       8623
       +
       				t.Filename = string(sval)

     

       8624
       +
       			}

     

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

     

       8626
       +
       		case "createdAt":

     

       8627
       +
       

     

       8628
       +
       			{

     

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

     

       8630
       +
       				if err != nil {

     

       8631
       +
       					return err

     

       8632
       +
       				}

     

       8633
       +
       

     

       8634
       +
       				t.CreatedAt = string(sval)

     

       8635
       +
       			}

     

       8636
       +
       			// t.Description (string) (string)

     

       8637
       +
       		case "description":

     

       8638
       +
       

     

       8639
       +
       			{

     

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

     

       8641
       +
       				if err != nil {

     

       8642
       +
       					return err

     

       8643
       +
       				}

     

       8644
       +
       

     

       8645
       +
       				t.Description = string(sval)

     

       8646
       +
       			}

     

       8647
       +
       

     

       8648
       +
       		default:

     

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

     

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

     

       8651
       +
       				return err

     

       8652
       +
       			}

     

       8653
       +
       		}

     

       8654
       +
       	}

     

       8655
       +
       

     

       8656
       +
       	return nil

     

       8657
       +
       }

+25

api/tangled/tangledstring.go

···

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

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.string

     

       6
       +
       

     

       7
       +
       import (

     

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

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	StringNSID = "sh.tangled.string"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.string", &String{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: String

     

       19
       +
       type String struct {

     

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

     

       21
       +
       	Contents      string `json:"contents" cborgen:"contents"`

     

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

     

       23
       +
       	Description   string `json:"description" cborgen:"description"`

     

       24
       +
       	Filename      string `json:"filename" cborgen:"filename"`

     

       25
       +
       }

cmd/gen.go

···

       50
        
       		tangled.RepoPullStatus{},

     

       51
        
       		tangled.Spindle{},

     

       52
        
       		tangled.SpindleMember{},

     

       0
        
       
     

       53
        
       	); err != nil {

     

       54
        
       		panic(err)

     

       55
        
       	}

···

       50
        
       		tangled.RepoPullStatus{},

     

       51
        
       		tangled.Spindle{},

     

       52
        
       		tangled.SpindleMember{},

     

       53
       +
       		tangled.String{},

     

       54
        
       	); err != nil {

     

       55
        
       		panic(err)

     

       56
        
       	}

+40

lexicons/string/string.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

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

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "tid",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "filename",

     

       14
       +
                 "description",

     

       15
       +
                 "createdAt",

     

       16
       +
                 "contents"

     

       17
       +
               ],

     

       18
       +
               "properties": {

     

       19
       +
                 "filename": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "maxGraphemes": 140,

     

       22
       +
                   "minGraphemes": 1

     

       23
       +
                 },

     

       24
       +
                 "description": {

     

       25
       +
                   "type": "string",

     

       26
       +
                   "maxGraphemes": 280

     

       27
       +
                 },

     

       28
       +
                 "createdAt": {

     

       29
       +
                   "type": "string",

     

       30
       +
                   "format": "datetime"

     

       31
       +
                 },

     

       32
       +
                 "contents": {

     

       33
       +
                   "type": "string",

     

       34
       +
                   "minGraphemes": 1

     

       35
       +
                 }

     

       36
       +
               }

     

       37
       +
             }

     

       38
       +
           }

     

       39
       +
         }

     

       40
       +
       }