+416

api/tangled/cbor_gen.go

··· 604 604 605 605 return nil 606 606 } 607 607 + func (t *Comment) MarshalCBOR(w io.Writer) error { 608 608 + if t == nil { 609 609 + _, err := w.Write(cbg.CborNull) 610 610 + return err 611 611 + } 612 612 + 613 613 + cw := cbg.NewCborWriter(w) 614 614 + fieldCount := 7 615 615 + 616 616 + if t.Mentions == nil { 617 617 + fieldCount-- 618 618 + } 619 619 + 620 620 + if t.References == nil { 621 621 + fieldCount-- 622 622 + } 623 623 + 624 624 + if t.ReplyTo == nil { 625 625 + fieldCount-- 626 626 + } 627 627 + 628 628 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 629 629 + return err 630 630 + } 631 631 + 632 632 + // t.Body (string) (string) 633 633 + if len("body") > 1000000 { 634 634 + return xerrors.Errorf("Value in field \"body\" was too long") 635 635 + } 636 636 + 637 637 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 638 638 + return err 639 639 + } 640 640 + if _, err := cw.WriteString(string("body")); err != nil { 641 641 + return err 642 642 + } 643 643 + 644 644 + if len(t.Body) > 1000000 { 645 645 + return xerrors.Errorf("Value in field t.Body was too long") 646 646 + } 647 647 + 648 648 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 649 649 + return err 650 650 + } 651 651 + if _, err := cw.WriteString(string(t.Body)); err != nil { 652 652 + return err 653 653 + } 654 654 + 655 655 + // t.LexiconTypeID (string) (string) 656 656 + if len("$type") > 1000000 { 657 657 + return xerrors.Errorf("Value in field \"$type\" was too long") 658 658 + } 659 659 + 660 660 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 661 661 + return err 662 662 + } 663 663 + if _, err := cw.WriteString(string("$type")); err != nil { 664 664 + return err 665 665 + } 666 666 + 667 667 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.comment"))); err != nil { 668 668 + return err 669 669 + } 670 670 + if _, err := cw.WriteString(string("sh.tangled.comment")); err != nil { 671 671 + return err 672 672 + } 673 673 + 674 674 + // t.ReplyTo (string) (string) 675 675 + if t.ReplyTo != nil { 676 676 + 677 677 + if len("replyTo") > 1000000 { 678 678 + return xerrors.Errorf("Value in field \"replyTo\" was too long") 679 679 + } 680 680 + 681 681 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil { 682 682 + return err 683 683 + } 684 684 + if _, err := cw.WriteString(string("replyTo")); err != nil { 685 685 + return err 686 686 + } 687 687 + 688 688 + if t.ReplyTo == nil { 689 689 + if _, err := cw.Write(cbg.CborNull); err != nil { 690 690 + return err 691 691 + } 692 692 + } else { 693 693 + if len(*t.ReplyTo) > 1000000 { 694 694 + return xerrors.Errorf("Value in field t.ReplyTo was too long") 695 695 + } 696 696 + 697 697 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil { 698 698 + return err 699 699 + } 700 700 + if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil { 701 701 + return err 702 702 + } 703 703 + } 704 704 + } 705 705 + 706 706 + // t.Subject (string) (string) 707 707 + if len("subject") > 1000000 { 708 708 + return xerrors.Errorf("Value in field \"subject\" was too long") 709 709 + } 710 710 + 711 711 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 712 712 + return err 713 713 + } 714 714 + if _, err := cw.WriteString(string("subject")); err != nil { 715 715 + return err 716 716 + } 717 717 + 718 718 + if len(t.Subject) > 1000000 { 719 719 + return xerrors.Errorf("Value in field t.Subject was too long") 720 720 + } 721 721 + 722 722 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 723 723 + return err 724 724 + } 725 725 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 726 726 + return err 727 727 + } 728 728 + 729 729 + // t.Mentions ([]string) (slice) 730 730 + if t.Mentions != nil { 731 731 + 732 732 + if len("mentions") > 1000000 { 733 733 + return xerrors.Errorf("Value in field \"mentions\" was too long") 734 734 + } 735 735 + 736 736 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 737 737 + return err 738 738 + } 739 739 + if _, err := cw.WriteString(string("mentions")); err != nil { 740 740 + return err 741 741 + } 742 742 + 743 743 + if len(t.Mentions) > 8192 { 744 744 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 745 745 + } 746 746 + 747 747 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 748 748 + return err 749 749 + } 750 750 + for _, v := range t.Mentions { 751 751 + if len(v) > 1000000 { 752 752 + return xerrors.Errorf("Value in field v was too long") 753 753 + } 754 754 + 755 755 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 756 756 + return err 757 757 + } 758 758 + if _, err := cw.WriteString(string(v)); err != nil { 759 759 + return err 760 760 + } 761 761 + 762 762 + } 763 763 + } 764 764 + 765 765 + // t.CreatedAt (string) (string) 766 766 + if len("createdAt") > 1000000 { 767 767 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 768 768 + } 769 769 + 770 770 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 771 771 + return err 772 772 + } 773 773 + if _, err := cw.WriteString(string("createdAt")); err != nil { 774 774 + return err 775 775 + } 776 776 + 777 777 + if len(t.CreatedAt) > 1000000 { 778 778 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 779 779 + } 780 780 + 781 781 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 782 782 + return err 783 783 + } 784 784 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 785 785 + return err 786 786 + } 787 787 + 788 788 + // t.References ([]string) (slice) 789 789 + if t.References != nil { 790 790 + 791 791 + if len("references") > 1000000 { 792 792 + return xerrors.Errorf("Value in field \"references\" was too long") 793 793 + } 794 794 + 795 795 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 796 796 + return err 797 797 + } 798 798 + if _, err := cw.WriteString(string("references")); err != nil { 799 799 + return err 800 800 + } 801 801 + 802 802 + if len(t.References) > 8192 { 803 803 + return xerrors.Errorf("Slice value in field t.References was too long") 804 804 + } 805 805 + 806 806 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 807 807 + return err 808 808 + } 809 809 + for _, v := range t.References { 810 810 + if len(v) > 1000000 { 811 811 + return xerrors.Errorf("Value in field v was too long") 812 812 + } 813 813 + 814 814 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 815 815 + return err 816 816 + } 817 817 + if _, err := cw.WriteString(string(v)); err != nil { 818 818 + return err 819 819 + } 820 820 + 821 821 + } 822 822 + } 823 823 + return nil 824 824 + } 825 825 + 826 826 + func (t *Comment) UnmarshalCBOR(r io.Reader) (err error) { 827 827 + *t = Comment{} 828 828 + 829 829 + cr := cbg.NewCborReader(r) 830 830 + 831 831 + maj, extra, err := cr.ReadHeader() 832 832 + if err != nil { 833 833 + return err 834 834 + } 835 835 + defer func() { 836 836 + if err == io.EOF { 837 837 + err = io.ErrUnexpectedEOF 838 838 + } 839 839 + }() 840 840 + 841 841 + if maj != cbg.MajMap { 842 842 + return fmt.Errorf("cbor input should be of type map") 843 843 + } 844 844 + 845 845 + if extra > cbg.MaxLength { 846 846 + return fmt.Errorf("Comment: map struct too large (%d)", extra) 847 847 + } 848 848 + 849 849 + n := extra 850 850 + 851 851 + nameBuf := make([]byte, 10) 852 852 + for i := uint64(0); i < n; i++ { 853 853 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 854 854 + if err != nil { 855 855 + return err 856 856 + } 857 857 + 858 858 + if !ok { 859 859 + // Field doesn't exist on this type, so ignore it 860 860 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 861 861 + return err 862 862 + } 863 863 + continue 864 864 + } 865 865 + 866 866 + switch string(nameBuf[:nameLen]) { 867 867 + // t.Body (string) (string) 868 868 + case "body": 869 869 + 870 870 + { 871 871 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 872 872 + if err != nil { 873 873 + return err 874 874 + } 875 875 + 876 876 + t.Body = string(sval) 877 877 + } 878 878 + // t.LexiconTypeID (string) (string) 879 879 + case "$type": 880 880 + 881 881 + { 882 882 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 883 883 + if err != nil { 884 884 + return err 885 885 + } 886 886 + 887 887 + t.LexiconTypeID = string(sval) 888 888 + } 889 889 + // t.ReplyTo (string) (string) 890 890 + case "replyTo": 891 891 + 892 892 + { 893 893 + b, err := cr.ReadByte() 894 894 + if err != nil { 895 895 + return err 896 896 + } 897 897 + if b != cbg.CborNull[0] { 898 898 + if err := cr.UnreadByte(); err != nil { 899 899 + return err 900 900 + } 901 901 + 902 902 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 903 903 + if err != nil { 904 904 + return err 905 905 + } 906 906 + 907 907 + t.ReplyTo = (*string)(&sval) 908 908 + } 909 909 + } 910 910 + // t.Subject (string) (string) 911 911 + case "subject": 912 912 + 913 913 + { 914 914 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 915 915 + if err != nil { 916 916 + return err 917 917 + } 918 918 + 919 919 + t.Subject = string(sval) 920 920 + } 921 921 + // t.Mentions ([]string) (slice) 922 922 + case "mentions": 923 923 + 924 924 + maj, extra, err = cr.ReadHeader() 925 925 + if err != nil { 926 926 + return err 927 927 + } 928 928 + 929 929 + if extra > 8192 { 930 930 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 931 931 + } 932 932 + 933 933 + if maj != cbg.MajArray { 934 934 + return fmt.Errorf("expected cbor array") 935 935 + } 936 936 + 937 937 + if extra > 0 { 938 938 + t.Mentions = make([]string, extra) 939 939 + } 940 940 + 941 941 + for i := 0; i < int(extra); i++ { 942 942 + { 943 943 + var maj byte 944 944 + var extra uint64 945 945 + var err error 946 946 + _ = maj 947 947 + _ = extra 948 948 + _ = err 949 949 + 950 950 + { 951 951 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 952 952 + if err != nil { 953 953 + return err 954 954 + } 955 955 + 956 956 + t.Mentions[i] = string(sval) 957 957 + } 958 958 + 959 959 + } 960 960 + } 961 961 + // t.CreatedAt (string) (string) 962 962 + case "createdAt": 963 963 + 964 964 + { 965 965 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 966 966 + if err != nil { 967 967 + return err 968 968 + } 969 969 + 970 970 + t.CreatedAt = string(sval) 971 971 + } 972 972 + // t.References ([]string) (slice) 973 973 + case "references": 974 974 + 975 975 + maj, extra, err = cr.ReadHeader() 976 976 + if err != nil { 977 977 + return err 978 978 + } 979 979 + 980 980 + if extra > 8192 { 981 981 + return fmt.Errorf("t.References: array too large (%d)", extra) 982 982 + } 983 983 + 984 984 + if maj != cbg.MajArray { 985 985 + return fmt.Errorf("expected cbor array") 986 986 + } 987 987 + 988 988 + if extra > 0 { 989 989 + t.References = make([]string, extra) 990 990 + } 991 991 + 992 992 + for i := 0; i < int(extra); i++ { 993 993 + { 994 994 + var maj byte 995 995 + var extra uint64 996 996 + var err error 997 997 + _ = maj 998 998 + _ = extra 999 999 + _ = err 1000 1000 + 1001 1001 + { 1002 1002 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1003 1003 + if err != nil { 1004 1004 + return err 1005 1005 + } 1006 1006 + 1007 1007 + t.References[i] = string(sval) 1008 1008 + } 1009 1009 + 1010 1010 + } 1011 1011 + } 1012 1012 + 1013 1013 + default: 1014 1014 + // Field doesn't exist on this type, so ignore it 1015 1015 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1016 1016 + return err 1017 1017 + } 1018 1018 + } 1019 1019 + } 1020 1020 + 1021 1021 + return nil 1022 1022 + } 607 1023 func (t *FeedReaction) MarshalCBOR(w io.Writer) error { 608 1024 if t == nil { 609 1025 _, err := w.Write(cbg.CborNull)

+27

api/tangled/tangledcomment.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.comment 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + CommentNSID = "sh.tangled.comment" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.comment", &Comment{}) 17 17 + } // 18 18 + // RECORDTYPE: Comment 19 19 + type Comment struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.comment" cborgen:"$type,const=sh.tangled.comment"` 21 21 + Body string `json:"body" cborgen:"body"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 25 25 + ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 26 26 + Subject string `json:"subject" cborgen:"subject"` 27 27 + }

+1

cmd/cborgen/cborgen.go

··· 15 15 "api/tangled/cbor_gen.go", 16 16 "tangled", 17 17 tangled.ActorProfile{}, 18 18 + tangled.Comment{}, 18 19 tangled.FeedReaction{}, 19 20 tangled.FeedStar{}, 20 21 tangled.GitRefUpdate{},

+51

lexicons/comment/comment.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.comment", 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 + "body", 15 15 + "createdAt" 16 16 + ], 17 17 + "properties": { 18 18 + "subject": { 19 19 + "type": "string", 20 20 + "format": "at-uri" 21 21 + }, 22 22 + "body": { 23 23 + "type": "string" 24 24 + }, 25 25 + "createdAt": { 26 26 + "type": "string", 27 27 + "format": "datetime" 28 28 + }, 29 29 + "replyTo": { 30 30 + "type": "string", 31 31 + "format": "at-uri" 32 32 + }, 33 33 + "mentions": { 34 34 + "type": "array", 35 35 + "items": { 36 36 + "type": "string", 37 37 + "format": "did" 38 38 + } 39 39 + }, 40 40 + "references": { 41 41 + "type": "array", 42 42 + "items": { 43 43 + "type": "string", 44 44 + "format": "at-uri" 45 45 + } 46 46 + } 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + }