+1640 -1418

api/tangled/cbor_gen.go

··· 668 668 669 669 return nil 670 670 } 671 671 - func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { 671 671 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { 672 672 if t == nil { 673 673 _, err := w.Write(cbg.CborNull) 674 674 return err ··· 676 676 677 677 cw := cbg.NewCborWriter(w) 678 678 679 679 - if _, err := cw.Write([]byte{168}); err != nil { 679 679 + if _, err := cw.Write([]byte{162}); err != nil { 680 680 return err 681 681 } 682 682 683 683 - // t.Ref (string) (string) 684 684 - if len("ref") > 1000000 { 685 685 - return xerrors.Errorf("Value in field \"ref\" was too long") 683 683 + // t.Count (int64) (int64) 684 684 + if len("count") > 1000000 { 685 685 + return xerrors.Errorf("Value in field \"count\" was too long") 686 686 } 687 687 688 688 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 688 688 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { 689 689 return err 690 690 } 691 691 - if _, err := cw.WriteString(string("ref")); err != nil { 691 691 + if _, err := cw.WriteString(string("count")); err != nil { 692 692 return err 693 693 } 694 694 695 695 - if len(t.Ref) > 1000000 { 696 696 - return xerrors.Errorf("Value in field t.Ref was too long") 695 695 + if t.Count >= 0 { 696 696 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { 697 697 + return err 698 698 + } 699 699 + } else { 700 700 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { 701 701 + return err 702 702 + } 697 703 } 698 704 699 699 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 705 705 + // t.Email (string) (string) 706 706 + if len("email") > 1000000 { 707 707 + return xerrors.Errorf("Value in field \"email\" was too long") 708 708 + } 709 709 + 710 710 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { 700 711 return err 701 712 } 702 702 - if _, err := cw.WriteString(string(t.Ref)); err != nil { 713 713 + if _, err := cw.WriteString(string("email")); err != nil { 703 714 return err 704 715 } 705 716 706 706 - // t.Meta (tangled.GitRefUpdate_Meta) (struct) 707 707 - if len("meta") > 1000000 { 708 708 - return xerrors.Errorf("Value in field \"meta\" was too long") 717 717 + if len(t.Email) > 1000000 { 718 718 + return xerrors.Errorf("Value in field t.Email was too long") 709 719 } 710 720 711 711 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 721 721 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { 712 722 return err 713 723 } 714 714 - if _, err := cw.WriteString(string("meta")); err != nil { 724 724 + if _, err := cw.WriteString(string(t.Email)); err != nil { 715 725 return err 716 726 } 727 727 + return nil 728 728 + } 717 729 718 718 - if err := t.Meta.MarshalCBOR(cw); err != nil { 719 719 - return err 720 720 - } 730 730 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { 731 731 + *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} 721 732 722 722 - // t.LexiconTypeID (string) (string) 723 723 - if len("$type") > 1000000 { 724 724 - return xerrors.Errorf("Value in field \"$type\" was too long") 725 725 - } 733 733 + cr := cbg.NewCborReader(r) 726 734 727 727 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 728 728 - return err 729 729 - } 730 730 - if _, err := cw.WriteString(string("$type")); err != nil { 735 735 + maj, extra, err := cr.ReadHeader() 736 736 + if err != nil { 731 737 return err 732 738 } 739 739 + defer func() { 740 740 + if err == io.EOF { 741 741 + err = io.ErrUnexpectedEOF 742 742 + } 743 743 + }() 733 744 734 734 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil { 735 735 - return err 736 736 - } 737 737 - if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil { 738 738 - return err 745 745 + if maj != cbg.MajMap { 746 746 + return fmt.Errorf("cbor input should be of type map") 739 747 } 740 748 741 741 - // t.NewSha (string) (string) 742 742 - if len("newSha") > 1000000 { 743 743 - return xerrors.Errorf("Value in field \"newSha\" was too long") 749 749 + if extra > cbg.MaxLength { 750 750 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) 744 751 } 745 752 746 746 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 747 747 - return err 748 748 - } 749 749 - if _, err := cw.WriteString(string("newSha")); err != nil { 750 750 - return err 751 751 - } 753 753 + n := extra 752 754 753 753 - if len(t.NewSha) > 1000000 { 754 754 - return xerrors.Errorf("Value in field t.NewSha was too long") 755 755 - } 755 755 + nameBuf := make([]byte, 5) 756 756 + for i := uint64(0); i < n; i++ { 757 757 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 758 758 + if err != nil { 759 759 + return err 760 760 + } 756 761 757 757 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 758 758 - return err 759 759 - } 760 760 - if _, err := cw.WriteString(string(t.NewSha)); err != nil { 761 761 - return err 762 762 - } 762 762 + if !ok { 763 763 + // Field doesn't exist on this type, so ignore it 764 764 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 765 765 + return err 766 766 + } 767 767 + continue 768 768 + } 763 769 764 764 - // t.OldSha (string) (string) 765 765 - if len("oldSha") > 1000000 { 766 766 - return xerrors.Errorf("Value in field \"oldSha\" was too long") 767 767 - } 770 770 + switch string(nameBuf[:nameLen]) { 771 771 + // t.Count (int64) (int64) 772 772 + case "count": 773 773 + { 774 774 + maj, extra, err := cr.ReadHeader() 775 775 + if err != nil { 776 776 + return err 777 777 + } 778 778 + var extraI int64 779 779 + switch maj { 780 780 + case cbg.MajUnsignedInt: 781 781 + extraI = int64(extra) 782 782 + if extraI < 0 { 783 783 + return fmt.Errorf("int64 positive overflow") 784 784 + } 785 785 + case cbg.MajNegativeInt: 786 786 + extraI = int64(extra) 787 787 + if extraI < 0 { 788 788 + return fmt.Errorf("int64 negative overflow") 789 789 + } 790 790 + extraI = -1 - extraI 791 791 + default: 792 792 + return fmt.Errorf("wrong type for int64 field: %d", maj) 793 793 + } 768 794 769 769 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 770 770 - return err 771 771 - } 772 772 - if _, err := cw.WriteString(string("oldSha")); err != nil { 773 773 - return err 774 774 - } 795 795 + t.Count = int64(extraI) 796 796 + } 797 797 + // t.Email (string) (string) 798 798 + case "email": 775 799 776 776 - if len(t.OldSha) > 1000000 { 777 777 - return xerrors.Errorf("Value in field t.OldSha was too long") 778 778 - } 800 800 + { 801 801 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 802 802 + if err != nil { 803 803 + return err 804 804 + } 779 805 780 780 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 781 781 - return err 782 782 - } 783 783 - if _, err := cw.WriteString(string(t.OldSha)); err != nil { 784 784 - return err 785 785 - } 806 806 + t.Email = string(sval) 807 807 + } 786 808 787 787 - // t.RepoDid (string) (string) 788 788 - if len("repoDid") > 1000000 { 789 789 - return xerrors.Errorf("Value in field \"repoDid\" was too long") 809 809 + default: 810 810 + // Field doesn't exist on this type, so ignore it 811 811 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 812 812 + return err 813 813 + } 814 814 + } 790 815 } 791 816 792 792 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 793 793 - return err 794 794 - } 795 795 - if _, err := cw.WriteString(string("repoDid")); err != nil { 817 817 + return nil 818 818 + } 819 819 + func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { 820 820 + if t == nil { 821 821 + _, err := w.Write(cbg.CborNull) 796 822 return err 797 823 } 798 824 799 799 - if len(t.RepoDid) > 1000000 { 800 800 - return xerrors.Errorf("Value in field t.RepoDid was too long") 801 801 - } 825 825 + cw := cbg.NewCborWriter(w) 826 826 + fieldCount := 1 802 827 803 803 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 804 804 - return err 805 805 - } 806 806 - if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 807 807 - return err 828 828 + if t.ByEmail == nil { 829 829 + fieldCount-- 808 830 } 809 831 810 810 - // t.RepoName (string) (string) 811 811 - if len("repoName") > 1000000 { 812 812 - return xerrors.Errorf("Value in field \"repoName\" was too long") 813 813 - } 814 814 - 815 815 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil { 816 816 - return err 817 817 - } 818 818 - if _, err := cw.WriteString(string("repoName")); err != nil { 832 832 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 819 833 return err 820 834 } 821 835 822 822 - if len(t.RepoName) > 1000000 { 823 823 - return xerrors.Errorf("Value in field t.RepoName was too long") 824 824 - } 836 836 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 837 837 + if t.ByEmail != nil { 825 838 826 826 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil { 827 827 - return err 828 828 - } 829 829 - if _, err := cw.WriteString(string(t.RepoName)); err != nil { 830 830 - return err 831 831 - } 839 839 + if len("byEmail") > 1000000 { 840 840 + return xerrors.Errorf("Value in field \"byEmail\" was too long") 841 841 + } 832 842 833 833 - // t.CommitterDid (string) (string) 834 834 - if len("committerDid") > 1000000 { 835 835 - return xerrors.Errorf("Value in field \"committerDid\" was too long") 836 836 - } 843 843 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { 844 844 + return err 845 845 + } 846 846 + if _, err := cw.WriteString(string("byEmail")); err != nil { 847 847 + return err 848 848 + } 837 849 838 838 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 839 839 - return err 840 840 - } 841 841 - if _, err := cw.WriteString(string("committerDid")); err != nil { 842 842 - return err 843 843 - } 850 850 + if len(t.ByEmail) > 8192 { 851 851 + return xerrors.Errorf("Slice value in field t.ByEmail was too long") 852 852 + } 844 853 845 845 - if len(t.CommitterDid) > 1000000 { 846 846 - return xerrors.Errorf("Value in field t.CommitterDid was too long") 847 847 - } 854 854 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { 855 855 + return err 856 856 + } 857 857 + for _, v := range t.ByEmail { 858 858 + if err := v.MarshalCBOR(cw); err != nil { 859 859 + return err 860 860 + } 848 861 849 849 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 850 850 - return err 851 851 - } 852 852 - if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 853 853 - return err 862 862 + } 854 863 } 855 864 return nil 856 865 } 857 866 858 858 - func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 859 859 - *t = GitRefUpdate{} 867 867 + func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { 868 868 + *t = GitRefUpdate_Meta_CommitCount{} 860 869 861 870 cr := cbg.NewCborReader(r) 862 871 ··· 875 884 } 876 885 877 886 if extra > cbg.MaxLength { 878 878 - return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra) 887 887 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) 879 888 } 880 889 881 890 n := extra 882 891 883 883 - nameBuf := make([]byte, 12) 892 892 + nameBuf := make([]byte, 7) 884 893 for i := uint64(0); i < n; i++ { 885 894 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 886 895 if err != nil { ··· 896 905 } 897 906 898 907 switch string(nameBuf[:nameLen]) { 899 899 - // t.Ref (string) (string) 900 900 - case "ref": 901 901 - 902 902 - { 903 903 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 904 904 - if err != nil { 905 905 - return err 906 906 - } 908 908 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 909 909 + case "byEmail": 907 910 908 908 - t.Ref = string(sval) 911 911 + maj, extra, err = cr.ReadHeader() 912 912 + if err != nil { 913 913 + return err 909 914 } 910 910 - // t.Meta (tangled.GitRefUpdate_Meta) (struct) 911 911 - case "meta": 912 915 913 913 - { 914 914 - 915 915 - b, err := cr.ReadByte() 916 916 - if err != nil { 917 917 - return err 918 918 - } 919 919 - if b != cbg.CborNull[0] { 920 920 - if err := cr.UnreadByte(); err != nil { 921 921 - return err 922 922 - } 923 923 - t.Meta = new(GitRefUpdate_Meta) 924 924 - if err := t.Meta.UnmarshalCBOR(cr); err != nil { 925 925 - return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 926 926 - } 927 927 - } 928 928 - 916 916 + if extra > 8192 { 917 917 + return fmt.Errorf("t.ByEmail: array too large (%d)", extra) 929 918 } 930 930 - // t.LexiconTypeID (string) (string) 931 931 - case "$type": 932 932 - 933 933 - { 934 934 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 935 935 - if err != nil { 936 936 - return err 937 937 - } 938 919 939 939 - t.LexiconTypeID = string(sval) 920 920 + if maj != cbg.MajArray { 921 921 + return fmt.Errorf("expected cbor array") 940 922 } 941 941 - // t.NewSha (string) (string) 942 942 - case "newSha": 943 923 944 944 - { 945 945 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 946 946 - if err != nil { 947 947 - return err 948 948 - } 949 949 - 950 950 - t.NewSha = string(sval) 924 924 + if extra > 0 { 925 925 + t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) 951 926 } 952 952 - // t.OldSha (string) (string) 953 953 - case "oldSha": 954 927 955 955 - { 956 956 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 957 957 - if err != nil { 958 958 - return err 959 959 - } 928 928 + for i := 0; i < int(extra); i++ { 929 929 + { 930 930 + var maj byte 931 931 + var extra uint64 932 932 + var err error 933 933 + _ = maj 934 934 + _ = extra 935 935 + _ = err 960 936 961 961 - t.OldSha = string(sval) 962 962 - } 963 963 - // t.RepoDid (string) (string) 964 964 - case "repoDid": 937 937 + { 965 938 966 966 - { 967 967 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 968 968 - if err != nil { 969 969 - return err 970 970 - } 971 971 - 972 972 - t.RepoDid = string(sval) 973 973 - } 974 974 - // t.RepoName (string) (string) 975 975 - case "repoName": 976 976 - 977 977 - { 978 978 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 979 979 - if err != nil { 980 980 - return err 981 981 - } 939 939 + b, err := cr.ReadByte() 940 940 + if err != nil { 941 941 + return err 942 942 + } 943 943 + if b != cbg.CborNull[0] { 944 944 + if err := cr.UnreadByte(); err != nil { 945 945 + return err 946 946 + } 947 947 + t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) 948 948 + if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { 949 949 + return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) 950 950 + } 951 951 + } 982 952 983 983 - t.RepoName = string(sval) 984 984 - } 985 985 - // t.CommitterDid (string) (string) 986 986 - case "committerDid": 953 953 + } 987 954 988 988 - { 989 989 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 990 990 - if err != nil { 991 991 - return err 992 955 } 993 993 - 994 994 - t.CommitterDid = string(sval) 995 956 } 996 957 997 958 default: ··· 1140 1101 1141 1102 return nil 1142 1103 } 1143 1143 - func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { 1104 1104 + func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { 1144 1105 if t == nil { 1145 1106 _, err := w.Write(cbg.CborNull) 1146 1107 return err 1147 1108 } 1148 1109 1149 1110 cw := cbg.NewCborWriter(w) 1150 1150 - fieldCount := 1 1151 1111 1152 1152 - if t.ByEmail == nil { 1153 1153 - fieldCount-- 1112 1112 + if _, err := cw.Write([]byte{168}); err != nil { 1113 1113 + return err 1114 1114 + } 1115 1115 + 1116 1116 + // t.Ref (string) (string) 1117 1117 + if len("ref") > 1000000 { 1118 1118 + return xerrors.Errorf("Value in field \"ref\" was too long") 1154 1119 } 1155 1120 1156 1156 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1121 1121 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 1122 1122 + return err 1123 1123 + } 1124 1124 + if _, err := cw.WriteString(string("ref")); err != nil { 1157 1125 return err 1158 1126 } 1159 1127 1160 1160 - // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1161 1161 - if t.ByEmail != nil { 1128 1128 + if len(t.Ref) > 1000000 { 1129 1129 + return xerrors.Errorf("Value in field t.Ref was too long") 1130 1130 + } 1162 1131 1163 1163 - if len("byEmail") > 1000000 { 1164 1164 - return xerrors.Errorf("Value in field \"byEmail\" was too long") 1165 1165 - } 1132 1132 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 1133 1133 + return err 1134 1134 + } 1135 1135 + if _, err := cw.WriteString(string(t.Ref)); err != nil { 1136 1136 + return err 1137 1137 + } 1166 1138 1167 1167 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { 1168 1168 - return err 1169 1169 - } 1170 1170 - if _, err := cw.WriteString(string("byEmail")); err != nil { 1171 1171 - return err 1172 1172 - } 1173 1173 - 1174 1174 - if len(t.ByEmail) > 8192 { 1175 1175 - return xerrors.Errorf("Slice value in field t.ByEmail was too long") 1176 1176 - } 1139 1139 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 1140 1140 + if len("meta") > 1000000 { 1141 1141 + return xerrors.Errorf("Value in field \"meta\" was too long") 1142 1142 + } 1177 1143 1178 1178 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { 1179 1179 - return err 1180 1180 - } 1181 1181 - for _, v := range t.ByEmail { 1182 1182 - if err := v.MarshalCBOR(cw); err != nil { 1183 1183 - return err 1184 1184 - } 1144 1144 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 1145 1145 + return err 1146 1146 + } 1147 1147 + if _, err := cw.WriteString(string("meta")); err != nil { 1148 1148 + return err 1149 1149 + } 1185 1150 1186 1186 - } 1151 1151 + if err := t.Meta.MarshalCBOR(cw); err != nil { 1152 1152 + return err 1187 1153 } 1188 1188 - return nil 1189 1189 - } 1190 1154 1191 1191 - func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { 1192 1192 - *t = GitRefUpdate_Meta_CommitCount{} 1155 1155 + // t.LexiconTypeID (string) (string) 1156 1156 + if len("$type") > 1000000 { 1157 1157 + return xerrors.Errorf("Value in field \"$type\" was too long") 1158 1158 + } 1193 1159 1194 1194 - cr := cbg.NewCborReader(r) 1160 1160 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1161 1161 + return err 1162 1162 + } 1163 1163 + if _, err := cw.WriteString(string("$type")); err != nil { 1164 1164 + return err 1165 1165 + } 1195 1166 1196 1196 - maj, extra, err := cr.ReadHeader() 1197 1197 - if err != nil { 1167 1167 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil { 1168 1168 + return err 1169 1169 + } 1170 1170 + if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil { 1198 1171 return err 1199 1172 } 1200 1200 - defer func() { 1201 1201 - if err == io.EOF { 1202 1202 - err = io.ErrUnexpectedEOF 1203 1203 - } 1204 1204 - }() 1205 1173 1206 1206 - if maj != cbg.MajMap { 1207 1207 - return fmt.Errorf("cbor input should be of type map") 1174 1174 + // t.NewSha (string) (string) 1175 1175 + if len("newSha") > 1000000 { 1176 1176 + return xerrors.Errorf("Value in field \"newSha\" was too long") 1208 1177 } 1209 1178 1210 1210 - if extra > cbg.MaxLength { 1211 1211 - return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) 1179 1179 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 1180 1180 + return err 1181 1181 + } 1182 1182 + if _, err := cw.WriteString(string("newSha")); err != nil { 1183 1183 + return err 1212 1184 } 1213 1185 1214 1214 - n := extra 1186 1186 + if len(t.NewSha) > 1000000 { 1187 1187 + return xerrors.Errorf("Value in field t.NewSha was too long") 1188 1188 + } 1215 1189 1216 1216 - nameBuf := make([]byte, 7) 1217 1217 - for i := uint64(0); i < n; i++ { 1218 1218 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1219 1219 - if err != nil { 1220 1220 - return err 1221 1221 - } 1190 1190 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 1191 1191 + return err 1192 1192 + } 1193 1193 + if _, err := cw.WriteString(string(t.NewSha)); err != nil { 1194 1194 + return err 1195 1195 + } 1222 1196 1223 1223 - if !ok { 1224 1224 - // Field doesn't exist on this type, so ignore it 1225 1225 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1226 1226 - return err 1227 1227 - } 1228 1228 - continue 1229 1229 - } 1197 1197 + // t.OldSha (string) (string) 1198 1198 + if len("oldSha") > 1000000 { 1199 1199 + return xerrors.Errorf("Value in field \"oldSha\" was too long") 1200 1200 + } 1230 1201 1231 1231 - switch string(nameBuf[:nameLen]) { 1232 1232 - // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1233 1233 - case "byEmail": 1202 1202 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 1203 1203 + return err 1204 1204 + } 1205 1205 + if _, err := cw.WriteString(string("oldSha")); err != nil { 1206 1206 + return err 1207 1207 + } 1234 1208 1235 1235 - maj, extra, err = cr.ReadHeader() 1236 1236 - if err != nil { 1237 1237 - return err 1238 1238 - } 1209 1209 + if len(t.OldSha) > 1000000 { 1210 1210 + return xerrors.Errorf("Value in field t.OldSha was too long") 1211 1211 + } 1239 1212 1240 1240 - if extra > 8192 { 1241 1241 - return fmt.Errorf("t.ByEmail: array too large (%d)", extra) 1242 1242 - } 1213 1213 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 1214 1214 + return err 1215 1215 + } 1216 1216 + if _, err := cw.WriteString(string(t.OldSha)); err != nil { 1217 1217 + return err 1218 1218 + } 1243 1219 1244 1244 - if maj != cbg.MajArray { 1245 1245 - return fmt.Errorf("expected cbor array") 1246 1246 - } 1220 1220 + // t.RepoDid (string) (string) 1221 1221 + if len("repoDid") > 1000000 { 1222 1222 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 1223 1223 + } 1247 1224 1248 1248 - if extra > 0 { 1249 1249 - t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) 1250 1250 - } 1225 1225 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 1226 1226 + return err 1227 1227 + } 1228 1228 + if _, err := cw.WriteString(string("repoDid")); err != nil { 1229 1229 + return err 1230 1230 + } 1251 1231 1252 1252 - for i := 0; i < int(extra); i++ { 1253 1253 - { 1254 1254 - var maj byte 1255 1255 - var extra uint64 1256 1256 - var err error 1257 1257 - _ = maj 1258 1258 - _ = extra 1259 1259 - _ = err 1232 1232 + if len(t.RepoDid) > 1000000 { 1233 1233 + return xerrors.Errorf("Value in field t.RepoDid was too long") 1234 1234 + } 1260 1235 1261 1261 - { 1236 1236 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 1237 1237 + return err 1238 1238 + } 1239 1239 + if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 1240 1240 + return err 1241 1241 + } 1262 1242 1263 1263 - b, err := cr.ReadByte() 1264 1264 - if err != nil { 1265 1265 - return err 1266 1266 - } 1267 1267 - if b != cbg.CborNull[0] { 1268 1268 - if err := cr.UnreadByte(); err != nil { 1269 1269 - return err 1270 1270 - } 1271 1271 - t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) 1272 1272 - if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { 1273 1273 - return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) 1274 1274 - } 1275 1275 - } 1276 1276 - 1277 1277 - } 1278 1278 - 1279 1279 - } 1280 1280 - } 1281 1281 - 1282 1282 - default: 1283 1283 - // Field doesn't exist on this type, so ignore it 1284 1284 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1285 1285 - return err 1286 1286 - } 1287 1287 - } 1243 1243 + // t.RepoName (string) (string) 1244 1244 + if len("repoName") > 1000000 { 1245 1245 + return xerrors.Errorf("Value in field \"repoName\" was too long") 1288 1246 } 1289 1247 1290 1290 - return nil 1291 1291 - } 1292 1292 - func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { 1293 1293 - if t == nil { 1294 1294 - _, err := w.Write(cbg.CborNull) 1248 1248 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil { 1295 1249 return err 1296 1250 } 1297 1297 - 1298 1298 - cw := cbg.NewCborWriter(w) 1299 1299 - 1300 1300 - if _, err := cw.Write([]byte{162}); err != nil { 1251 1251 + if _, err := cw.WriteString(string("repoName")); err != nil { 1301 1252 return err 1302 1253 } 1303 1254 1304 1304 - // t.Count (int64) (int64) 1305 1305 - if len("count") > 1000000 { 1306 1306 - return xerrors.Errorf("Value in field \"count\" was too long") 1255 1255 + if len(t.RepoName) > 1000000 { 1256 1256 + return xerrors.Errorf("Value in field t.RepoName was too long") 1307 1257 } 1308 1258 1309 1309 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { 1259 1259 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil { 1310 1260 return err 1311 1261 } 1312 1312 - if _, err := cw.WriteString(string("count")); err != nil { 1262 1262 + if _, err := cw.WriteString(string(t.RepoName)); err != nil { 1313 1263 return err 1314 1264 } 1315 1265 1316 1316 - if t.Count >= 0 { 1317 1317 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { 1318 1318 - return err 1319 1319 - } 1320 1320 - } else { 1321 1321 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { 1322 1322 - return err 1323 1323 - } 1266 1266 + // t.CommitterDid (string) (string) 1267 1267 + if len("committerDid") > 1000000 { 1268 1268 + return xerrors.Errorf("Value in field \"committerDid\" was too long") 1324 1269 } 1325 1270 1326 1326 - // t.Email (string) (string) 1327 1327 - if len("email") > 1000000 { 1328 1328 - return xerrors.Errorf("Value in field \"email\" was too long") 1329 1329 - } 1330 1330 - 1331 1331 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { 1271 1271 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 1332 1272 return err 1333 1273 } 1334 1334 - if _, err := cw.WriteString(string("email")); err != nil { 1274 1274 + if _, err := cw.WriteString(string("committerDid")); err != nil { 1335 1275 return err 1336 1276 } 1337 1277 1338 1338 - if len(t.Email) > 1000000 { 1339 1339 - return xerrors.Errorf("Value in field t.Email was too long") 1278 1278 + if len(t.CommitterDid) > 1000000 { 1279 1279 + return xerrors.Errorf("Value in field t.CommitterDid was too long") 1340 1280 } 1341 1281 1342 1342 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { 1282 1282 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 1343 1283 return err 1344 1284 } 1345 1345 - if _, err := cw.WriteString(string(t.Email)); err != nil { 1285 1285 + if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 1346 1286 return err 1347 1287 } 1348 1288 return nil 1349 1289 } 1350 1290 1351 1351 - func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { 1352 1352 - *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} 1291 1291 + func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 1292 1292 + *t = GitRefUpdate{} 1353 1293 1354 1294 cr := cbg.NewCborReader(r) 1355 1295 ··· 1368 1308 } 1369 1309 1370 1310 if extra > cbg.MaxLength { 1371 1371 - return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) 1311 1311 + return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra) 1372 1312 } 1373 1313 1374 1314 n := extra 1375 1315 1376 1376 - nameBuf := make([]byte, 5) 1316 1316 + nameBuf := make([]byte, 12) 1377 1317 for i := uint64(0); i < n; i++ { 1378 1318 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1379 1319 if err != nil { ··· 1389 1329 } 1390 1330 1391 1331 switch string(nameBuf[:nameLen]) { 1392 1392 - // t.Count (int64) (int64) 1393 1393 - case "count": 1332 1332 + // t.Ref (string) (string) 1333 1333 + case "ref": 1334 1334 + 1335 1335 + { 1336 1336 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1337 1337 + if err != nil { 1338 1338 + return err 1339 1339 + } 1340 1340 + 1341 1341 + t.Ref = string(sval) 1342 1342 + } 1343 1343 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 1344 1344 + case "meta": 1345 1345 + 1394 1346 { 1395 1395 - maj, extra, err := cr.ReadHeader() 1347 1347 + 1348 1348 + b, err := cr.ReadByte() 1396 1349 if err != nil { 1397 1350 return err 1398 1351 } 1399 1399 - var extraI int64 1400 1400 - switch maj { 1401 1401 - case cbg.MajUnsignedInt: 1402 1402 - extraI = int64(extra) 1403 1403 - if extraI < 0 { 1404 1404 - return fmt.Errorf("int64 positive overflow") 1352 1352 + if b != cbg.CborNull[0] { 1353 1353 + if err := cr.UnreadByte(); err != nil { 1354 1354 + return err 1405 1355 } 1406 1406 - case cbg.MajNegativeInt: 1407 1407 - extraI = int64(extra) 1408 1408 - if extraI < 0 { 1409 1409 - return fmt.Errorf("int64 negative overflow") 1356 1356 + t.Meta = new(GitRefUpdate_Meta) 1357 1357 + if err := t.Meta.UnmarshalCBOR(cr); err != nil { 1358 1358 + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 1410 1359 } 1411 1411 - extraI = -1 - extraI 1412 1412 - default: 1413 1413 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1360 1360 + } 1361 1361 + 1362 1362 + } 1363 1363 + // t.LexiconTypeID (string) (string) 1364 1364 + case "$type": 1365 1365 + 1366 1366 + { 1367 1367 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1368 1368 + if err != nil { 1369 1369 + return err 1370 1370 + } 1371 1371 + 1372 1372 + t.LexiconTypeID = string(sval) 1373 1373 + } 1374 1374 + // t.NewSha (string) (string) 1375 1375 + case "newSha": 1376 1376 + 1377 1377 + { 1378 1378 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1379 1379 + if err != nil { 1380 1380 + return err 1414 1381 } 1415 1382 1416 1416 - t.Count = int64(extraI) 1383 1383 + t.NewSha = string(sval) 1417 1384 } 1418 1418 - // t.Email (string) (string) 1419 1419 - case "email": 1385 1385 + // t.OldSha (string) (string) 1386 1386 + case "oldSha": 1420 1387 1421 1388 { 1422 1389 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1424 1391 return err 1425 1392 } 1426 1393 1427 1427 - t.Email = string(sval) 1394 1394 + t.OldSha = string(sval) 1395 1395 + } 1396 1396 + // t.RepoDid (string) (string) 1397 1397 + case "repoDid": 1398 1398 + 1399 1399 + { 1400 1400 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1401 1401 + if err != nil { 1402 1402 + return err 1403 1403 + } 1404 1404 + 1405 1405 + t.RepoDid = string(sval) 1406 1406 + } 1407 1407 + // t.RepoName (string) (string) 1408 1408 + case "repoName": 1409 1409 + 1410 1410 + { 1411 1411 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1412 1412 + if err != nil { 1413 1413 + return err 1414 1414 + } 1415 1415 + 1416 1416 + t.RepoName = string(sval) 1417 1417 + } 1418 1418 + // t.CommitterDid (string) (string) 1419 1419 + case "committerDid": 1420 1420 + 1421 1421 + { 1422 1422 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1423 1423 + if err != nil { 1424 1424 + return err 1425 1425 + } 1426 1426 + 1427 1427 + t.CommitterDid = string(sval) 1428 1428 } 1429 1429 1430 1430 default: ··· 1799 1799 1800 1800 return nil 1801 1801 } 1802 1802 - func (t *Pipeline) MarshalCBOR(w io.Writer) error { 1803 1803 - if t == nil { 1804 1804 - _, err := w.Write(cbg.CborNull) 1805 1805 - return err 1806 1806 - } 1807 1807 - 1808 1808 - cw := cbg.NewCborWriter(w) 1809 1809 - 1810 1810 - if _, err := cw.Write([]byte{163}); err != nil { 1811 1811 - return err 1812 1812 - } 1813 1813 - 1814 1814 - // t.LexiconTypeID (string) (string) 1815 1815 - if len("$type") > 1000000 { 1816 1816 - return xerrors.Errorf("Value in field \"$type\" was too long") 1817 1817 - } 1818 1818 - 1819 1819 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1820 1820 - return err 1821 1821 - } 1822 1822 - if _, err := cw.WriteString(string("$type")); err != nil { 1823 1823 - return err 1824 1824 - } 1825 1825 - 1826 1826 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { 1827 1827 - return err 1828 1828 - } 1829 1829 - if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { 1830 1830 - return err 1831 1831 - } 1832 1832 - 1833 1833 - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 1834 1834 - if len("workflows") > 1000000 { 1835 1835 - return xerrors.Errorf("Value in field \"workflows\" was too long") 1836 1836 - } 1837 1837 - 1838 1838 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { 1839 1839 - return err 1840 1840 - } 1841 1841 - if _, err := cw.WriteString(string("workflows")); err != nil { 1842 1842 - return err 1843 1843 - } 1844 1844 - 1845 1845 - if len(t.Workflows) > 8192 { 1846 1846 - return xerrors.Errorf("Slice value in field t.Workflows was too long") 1847 1847 - } 1848 1848 - 1849 1849 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { 1850 1850 - return err 1851 1851 - } 1852 1852 - for _, v := range t.Workflows { 1853 1853 - if err := v.MarshalCBOR(cw); err != nil { 1854 1854 - return err 1855 1855 - } 1856 1856 - 1857 1857 - } 1858 1858 - 1859 1859 - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 1860 1860 - if len("triggerMetadata") > 1000000 { 1861 1861 - return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") 1862 1862 - } 1863 1863 - 1864 1864 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { 1865 1865 - return err 1866 1866 - } 1867 1867 - if _, err := cw.WriteString(string("triggerMetadata")); err != nil { 1868 1868 - return err 1869 1869 - } 1870 1870 - 1871 1871 - if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { 1872 1872 - return err 1873 1873 - } 1874 1874 - return nil 1875 1875 - } 1876 1876 - 1877 1877 - func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { 1878 1878 - *t = Pipeline{} 1879 1879 - 1880 1880 - cr := cbg.NewCborReader(r) 1881 1881 - 1882 1882 - maj, extra, err := cr.ReadHeader() 1883 1883 - if err != nil { 1884 1884 - return err 1885 1885 - } 1886 1886 - defer func() { 1887 1887 - if err == io.EOF { 1888 1888 - err = io.ErrUnexpectedEOF 1889 1889 - } 1890 1890 - }() 1891 1891 - 1892 1892 - if maj != cbg.MajMap { 1893 1893 - return fmt.Errorf("cbor input should be of type map") 1894 1894 - } 1895 1895 - 1896 1896 - if extra > cbg.MaxLength { 1897 1897 - return fmt.Errorf("Pipeline: map struct too large (%d)", extra) 1898 1898 - } 1899 1899 - 1900 1900 - n := extra 1901 1901 - 1902 1902 - nameBuf := make([]byte, 15) 1903 1903 - for i := uint64(0); i < n; i++ { 1904 1904 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1905 1905 - if err != nil { 1906 1906 - return err 1907 1907 - } 1908 1908 - 1909 1909 - if !ok { 1910 1910 - // Field doesn't exist on this type, so ignore it 1911 1911 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1912 1912 - return err 1913 1913 - } 1914 1914 - continue 1915 1915 - } 1916 1916 - 1917 1917 - switch string(nameBuf[:nameLen]) { 1918 1918 - // t.LexiconTypeID (string) (string) 1919 1919 - case "$type": 1920 1920 - 1921 1921 - { 1922 1922 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1923 1923 - if err != nil { 1924 1924 - return err 1925 1925 - } 1926 1926 - 1927 1927 - t.LexiconTypeID = string(sval) 1928 1928 - } 1929 1929 - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 1930 1930 - case "workflows": 1931 1931 - 1932 1932 - maj, extra, err = cr.ReadHeader() 1933 1933 - if err != nil { 1934 1934 - return err 1935 1935 - } 1936 1936 - 1937 1937 - if extra > 8192 { 1938 1938 - return fmt.Errorf("t.Workflows: array too large (%d)", extra) 1939 1939 - } 1940 1940 - 1941 1941 - if maj != cbg.MajArray { 1942 1942 - return fmt.Errorf("expected cbor array") 1943 1943 - } 1944 1944 - 1945 1945 - if extra > 0 { 1946 1946 - t.Workflows = make([]*Pipeline_Workflow, extra) 1947 1947 - } 1948 1948 - 1949 1949 - for i := 0; i < int(extra); i++ { 1950 1950 - { 1951 1951 - var maj byte 1952 1952 - var extra uint64 1953 1953 - var err error 1954 1954 - _ = maj 1955 1955 - _ = extra 1956 1956 - _ = err 1957 1957 - 1958 1958 - { 1959 1959 - 1960 1960 - b, err := cr.ReadByte() 1961 1961 - if err != nil { 1962 1962 - return err 1963 1963 - } 1964 1964 - if b != cbg.CborNull[0] { 1965 1965 - if err := cr.UnreadByte(); err != nil { 1966 1966 - return err 1967 1967 - } 1968 1968 - t.Workflows[i] = new(Pipeline_Workflow) 1969 1969 - if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { 1970 1970 - return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) 1971 1971 - } 1972 1972 - } 1973 1973 - 1974 1974 - } 1975 1975 - 1976 1976 - } 1977 1977 - } 1978 1978 - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 1979 1979 - case "triggerMetadata": 1980 1980 - 1981 1981 - { 1982 1982 - 1983 1983 - b, err := cr.ReadByte() 1984 1984 - if err != nil { 1985 1985 - return err 1986 1986 - } 1987 1987 - if b != cbg.CborNull[0] { 1988 1988 - if err := cr.UnreadByte(); err != nil { 1989 1989 - return err 1990 1990 - } 1991 1991 - t.TriggerMetadata = new(Pipeline_TriggerMetadata) 1992 1992 - if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { 1993 1993 - return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) 1994 1994 - } 1995 1995 - } 1996 1996 - 1997 1997 - } 1998 1998 - 1999 1999 - default: 2000 2000 - // Field doesn't exist on this type, so ignore it 2001 2001 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2002 2002 - return err 2003 2003 - } 2004 2004 - } 2005 2005 - } 2006 2006 - 2007 2007 - return nil 2008 2008 - } 2009 1802 func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error { 2010 1803 if t == nil { 2011 1804 _, err := w.Write(cbg.CborNull) ··· 2361 2154 2362 2155 return nil 2363 2156 } 2364 2364 - func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error { 2157 2157 + func (t *Pipeline_ManualTriggerData_Inputs_Elem) MarshalCBOR(w io.Writer) error { 2365 2158 if t == nil { 2366 2159 _, err := w.Write(cbg.CborNull) 2367 2160 return err 2368 2161 } 2369 2162 2370 2163 cw := cbg.NewCborWriter(w) 2371 2371 - fieldCount := 1 2372 2164 2373 2373 - if t.Inputs == nil { 2374 2374 - fieldCount-- 2165 2165 + if _, err := cw.Write([]byte{162}); err != nil { 2166 2166 + return err 2375 2167 } 2376 2168 2377 2377 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2169 2169 + // t.Key (string) (string) 2170 2170 + if len("key") > 1000000 { 2171 2171 + return xerrors.Errorf("Value in field \"key\" was too long") 2172 2172 + } 2173 2173 + 2174 2174 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 2175 2175 + return err 2176 2176 + } 2177 2177 + if _, err := cw.WriteString(string("key")); err != nil { 2378 2178 return err 2379 2179 } 2380 2180 2381 2381 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2382 2382 - if t.Inputs != nil { 2181 2181 + if len(t.Key) > 1000000 { 2182 2182 + return xerrors.Errorf("Value in field t.Key was too long") 2183 2183 + } 2383 2184 2384 2384 - if len("inputs") > 1000000 { 2385 2385 - return xerrors.Errorf("Value in field \"inputs\" was too long") 2386 2386 - } 2185 2185 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 2186 2186 + return err 2187 2187 + } 2188 2188 + if _, err := cw.WriteString(string(t.Key)); err != nil { 2189 2189 + return err 2190 2190 + } 2387 2191 2388 2388 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 2389 2389 - return err 2390 2390 - } 2391 2391 - if _, err := cw.WriteString(string("inputs")); err != nil { 2392 2392 - return err 2393 2393 - } 2192 2192 + // t.Value (string) (string) 2193 2193 + if len("value") > 1000000 { 2194 2194 + return xerrors.Errorf("Value in field \"value\" was too long") 2195 2195 + } 2394 2196 2395 2395 - if len(t.Inputs) > 8192 { 2396 2396 - return xerrors.Errorf("Slice value in field t.Inputs was too long") 2397 2397 - } 2197 2197 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 2198 2198 + return err 2199 2199 + } 2200 2200 + if _, err := cw.WriteString(string("value")); err != nil { 2201 2201 + return err 2202 2202 + } 2398 2203 2399 2399 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 2400 2400 - return err 2401 2401 - } 2402 2402 - for _, v := range t.Inputs { 2403 2403 - if err := v.MarshalCBOR(cw); err != nil { 2404 2404 - return err 2405 2405 - } 2204 2204 + if len(t.Value) > 1000000 { 2205 2205 + return xerrors.Errorf("Value in field t.Value was too long") 2206 2206 + } 2406 2207 2407 2407 - } 2208 2208 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 2209 2209 + return err 2210 2210 + } 2211 2211 + if _, err := cw.WriteString(string(t.Value)); err != nil { 2212 2212 + return err 2408 2213 } 2409 2214 return nil 2410 2215 } 2411 2216 2412 2412 - func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) { 2413 2413 - *t = Pipeline_ManualTriggerData{} 2217 2217 + func (t *Pipeline_ManualTriggerData_Inputs_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2218 2218 + *t = Pipeline_ManualTriggerData_Inputs_Elem{} 2414 2219 2415 2220 cr := cbg.NewCborReader(r) 2416 2221 ··· 2429 2234 } 2430 2235 2431 2236 if extra > cbg.MaxLength { 2432 2432 - return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra) 2237 2237 + return fmt.Errorf("Pipeline_ManualTriggerData_Inputs_Elem: map struct too large (%d)", extra) 2433 2238 } 2434 2239 2435 2240 n := extra 2436 2241 2437 2437 - nameBuf := make([]byte, 6) 2242 2242 + nameBuf := make([]byte, 5) 2438 2243 for i := uint64(0); i < n; i++ { 2439 2244 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2440 2245 if err != nil { ··· 2450 2255 } 2451 2256 2452 2257 switch string(nameBuf[:nameLen]) { 2453 2453 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2454 2454 - case "inputs": 2258 2258 + // t.Key (string) (string) 2259 2259 + case "key": 2455 2260 2456 2456 - maj, extra, err = cr.ReadHeader() 2457 2457 - if err != nil { 2458 2458 - return err 2459 2459 - } 2261 2261 + { 2262 2262 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2263 2263 + if err != nil { 2264 2264 + return err 2265 2265 + } 2460 2266 2461 2461 - if extra > 8192 { 2462 2462 - return fmt.Errorf("t.Inputs: array too large (%d)", extra) 2267 2267 + t.Key = string(sval) 2463 2268 } 2269 2269 + // t.Value (string) (string) 2270 2270 + case "value": 2464 2271 2465 2465 - if maj != cbg.MajArray { 2466 2466 - return fmt.Errorf("expected cbor array") 2467 2467 - } 2272 2272 + { 2273 2273 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2274 2274 + if err != nil { 2275 2275 + return err 2276 2276 + } 2468 2277 2469 2469 - if extra > 0 { 2470 2470 - t.Inputs = make([]*Pipeline_ManualTriggerData_Inputs_Elem, extra) 2471 2471 - } 2472 2472 - 2473 2473 - for i := 0; i < int(extra); i++ { 2474 2474 - { 2475 2475 - var maj byte 2476 2476 - var extra uint64 2477 2477 - var err error 2478 2478 - _ = maj 2479 2479 - _ = extra 2480 2480 - _ = err 2481 2481 - 2482 2482 - { 2483 2483 - 2484 2484 - b, err := cr.ReadByte() 2485 2485 - if err != nil { 2486 2486 - return err 2487 2487 - } 2488 2488 - if b != cbg.CborNull[0] { 2489 2489 - if err := cr.UnreadByte(); err != nil { 2490 2490 - return err 2491 2491 - } 2492 2492 - t.Inputs[i] = new(Pipeline_ManualTriggerData_Inputs_Elem) 2493 2493 - if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 2494 2494 - return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 2495 2495 - } 2496 2496 - } 2497 2497 - 2498 2498 - } 2499 2499 - 2500 2500 - } 2278 2278 + t.Value = string(sval) 2501 2279 } 2502 2280 2503 2281 default: ··· 2510 2288 2511 2289 return nil 2512 2290 } 2513 2513 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) MarshalCBOR(w io.Writer) error { 2291 2291 + func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error { 2514 2292 if t == nil { 2515 2293 _, err := w.Write(cbg.CborNull) 2516 2294 return err 2517 2295 } 2518 2296 2519 2297 cw := cbg.NewCborWriter(w) 2520 2520 - 2521 2521 - if _, err := cw.Write([]byte{162}); err != nil { 2522 2522 - return err 2523 2523 - } 2298 2298 + fieldCount := 1 2524 2299 2525 2525 - // t.Key (string) (string) 2526 2526 - if len("key") > 1000000 { 2527 2527 - return xerrors.Errorf("Value in field \"key\" was too long") 2300 2300 + if t.Inputs == nil { 2301 2301 + fieldCount-- 2528 2302 } 2529 2303 2530 2530 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 2531 2531 - return err 2532 2532 - } 2533 2533 - if _, err := cw.WriteString(string("key")); err != nil { 2304 2304 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2534 2305 return err 2535 2306 } 2536 2307 2537 2537 - if len(t.Key) > 1000000 { 2538 2538 - return xerrors.Errorf("Value in field t.Key was too long") 2539 2539 - } 2308 2308 + // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2309 2309 + if t.Inputs != nil { 2540 2310 2541 2541 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 2542 2542 - return err 2543 2543 - } 2544 2544 - if _, err := cw.WriteString(string(t.Key)); err != nil { 2545 2545 - return err 2546 2546 - } 2311 2311 + if len("inputs") > 1000000 { 2312 2312 + return xerrors.Errorf("Value in field \"inputs\" was too long") 2313 2313 + } 2547 2314 2548 2548 - // t.Value (string) (string) 2549 2549 - if len("value") > 1000000 { 2550 2550 - return xerrors.Errorf("Value in field \"value\" was too long") 2551 2551 - } 2315 2315 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 2316 2316 + return err 2317 2317 + } 2318 2318 + if _, err := cw.WriteString(string("inputs")); err != nil { 2319 2319 + return err 2320 2320 + } 2552 2321 2553 2553 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 2554 2554 - return err 2555 2555 - } 2556 2556 - if _, err := cw.WriteString(string("value")); err != nil { 2557 2557 - return err 2558 2558 - } 2322 2322 + if len(t.Inputs) > 8192 { 2323 2323 + return xerrors.Errorf("Slice value in field t.Inputs was too long") 2324 2324 + } 2559 2325 2560 2560 - if len(t.Value) > 1000000 { 2561 2561 - return xerrors.Errorf("Value in field t.Value was too long") 2562 2562 - } 2326 2326 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 2327 2327 + return err 2328 2328 + } 2329 2329 + for _, v := range t.Inputs { 2330 2330 + if err := v.MarshalCBOR(cw); err != nil { 2331 2331 + return err 2332 2332 + } 2563 2333 2564 2564 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 2565 2565 - return err 2566 2566 - } 2567 2567 - if _, err := cw.WriteString(string(t.Value)); err != nil { 2568 2568 - return err 2334 2334 + } 2569 2335 } 2570 2336 return nil 2571 2337 } 2572 2338 2573 2573 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2574 2574 - *t = Pipeline_ManualTriggerData_Inputs_Elem{} 2339 2339 + func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) { 2340 2340 + *t = Pipeline_ManualTriggerData{} 2575 2341 2576 2342 cr := cbg.NewCborReader(r) 2577 2343 ··· 2590 2356 } 2591 2357 2592 2358 if extra > cbg.MaxLength { 2593 2593 - return fmt.Errorf("Pipeline_ManualTriggerData_Inputs_Elem: map struct too large (%d)", extra) 2359 2359 + return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra) 2594 2360 } 2595 2361 2596 2362 n := extra 2597 2363 2598 2598 - nameBuf := make([]byte, 5) 2364 2364 + nameBuf := make([]byte, 6) 2599 2365 for i := uint64(0); i < n; i++ { 2600 2366 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2601 2367 if err != nil { ··· 2611 2377 } 2612 2378 2613 2379 switch string(nameBuf[:nameLen]) { 2614 2614 - // t.Key (string) (string) 2615 2615 - case "key": 2380 2380 + // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2381 2381 + case "inputs": 2616 2382 2617 2617 - { 2618 2618 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2619 2619 - if err != nil { 2620 2620 - return err 2621 2621 - } 2383 2383 + maj, extra, err = cr.ReadHeader() 2384 2384 + if err != nil { 2385 2385 + return err 2386 2386 + } 2622 2387 2623 2623 - t.Key = string(sval) 2388 2388 + if extra > 8192 { 2389 2389 + return fmt.Errorf("t.Inputs: array too large (%d)", extra) 2624 2390 } 2625 2625 - // t.Value (string) (string) 2626 2626 - case "value": 2627 2391 2628 2628 - { 2629 2629 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2630 2630 - if err != nil { 2631 2631 - return err 2632 2632 - } 2392 2392 + if maj != cbg.MajArray { 2393 2393 + return fmt.Errorf("expected cbor array") 2394 2394 + } 2633 2395 2634 2634 - t.Value = string(sval) 2396 2396 + if extra > 0 { 2397 2397 + t.Inputs = make([]*Pipeline_ManualTriggerData_Inputs_Elem, extra) 2398 2398 + } 2399 2399 + 2400 2400 + for i := 0; i < int(extra); i++ { 2401 2401 + { 2402 2402 + var maj byte 2403 2403 + var extra uint64 2404 2404 + var err error 2405 2405 + _ = maj 2406 2406 + _ = extra 2407 2407 + _ = err 2408 2408 + 2409 2409 + { 2410 2410 + 2411 2411 + b, err := cr.ReadByte() 2412 2412 + if err != nil { 2413 2413 + return err 2414 2414 + } 2415 2415 + if b != cbg.CborNull[0] { 2416 2416 + if err := cr.UnreadByte(); err != nil { 2417 2417 + return err 2418 2418 + } 2419 2419 + t.Inputs[i] = new(Pipeline_ManualTriggerData_Inputs_Elem) 2420 2420 + if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 2421 2421 + return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 2422 2422 + } 2423 2423 + } 2424 2424 + 2425 2425 + } 2426 2426 + 2427 2427 + } 2635 2428 } 2636 2429 2637 2430 default: ··· 3616 3409 3617 3410 return nil 3618 3411 } 3412 3412 + func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 3413 3413 + if t == nil { 3414 3414 + _, err := w.Write(cbg.CborNull) 3415 3415 + return err 3416 3416 + } 3417 3417 + 3418 3418 + cw := cbg.NewCborWriter(w) 3419 3419 + 3420 3420 + if _, err := cw.Write([]byte{162}); err != nil { 3421 3421 + return err 3422 3422 + } 3423 3423 + 3424 3424 + // t.Key (string) (string) 3425 3425 + if len("key") > 1000000 { 3426 3426 + return xerrors.Errorf("Value in field \"key\" was too long") 3427 3427 + } 3428 3428 + 3429 3429 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3430 3430 + return err 3431 3431 + } 3432 3432 + if _, err := cw.WriteString(string("key")); err != nil { 3433 3433 + return err 3434 3434 + } 3435 3435 + 3436 3436 + if len(t.Key) > 1000000 { 3437 3437 + return xerrors.Errorf("Value in field t.Key was too long") 3438 3438 + } 3439 3439 + 3440 3440 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3441 3441 + return err 3442 3442 + } 3443 3443 + if _, err := cw.WriteString(string(t.Key)); err != nil { 3444 3444 + return err 3445 3445 + } 3446 3446 + 3447 3447 + // t.Value (string) (string) 3448 3448 + if len("value") > 1000000 { 3449 3449 + return xerrors.Errorf("Value in field \"value\" was too long") 3450 3450 + } 3451 3451 + 3452 3452 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 3453 3453 + return err 3454 3454 + } 3455 3455 + if _, err := cw.WriteString(string("value")); err != nil { 3456 3456 + return err 3457 3457 + } 3458 3458 + 3459 3459 + if len(t.Value) > 1000000 { 3460 3460 + return xerrors.Errorf("Value in field t.Value was too long") 3461 3461 + } 3462 3462 + 3463 3463 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 3464 3464 + return err 3465 3465 + } 3466 3466 + if _, err := cw.WriteString(string(t.Value)); err != nil { 3467 3467 + return err 3468 3468 + } 3469 3469 + return nil 3470 3470 + } 3471 3471 + 3472 3472 + func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 3473 3473 + *t = Pipeline_Workflow_Environment_Elem{} 3474 3474 + 3475 3475 + cr := cbg.NewCborReader(r) 3476 3476 + 3477 3477 + maj, extra, err := cr.ReadHeader() 3478 3478 + if err != nil { 3479 3479 + return err 3480 3480 + } 3481 3481 + defer func() { 3482 3482 + if err == io.EOF { 3483 3483 + err = io.ErrUnexpectedEOF 3484 3484 + } 3485 3485 + }() 3486 3486 + 3487 3487 + if maj != cbg.MajMap { 3488 3488 + return fmt.Errorf("cbor input should be of type map") 3489 3489 + } 3490 3490 + 3491 3491 + if extra > cbg.MaxLength { 3492 3492 + return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 3493 3493 + } 3494 3494 + 3495 3495 + n := extra 3496 3496 + 3497 3497 + nameBuf := make([]byte, 5) 3498 3498 + for i := uint64(0); i < n; i++ { 3499 3499 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3500 3500 + if err != nil { 3501 3501 + return err 3502 3502 + } 3503 3503 + 3504 3504 + if !ok { 3505 3505 + // Field doesn't exist on this type, so ignore it 3506 3506 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3507 3507 + return err 3508 3508 + } 3509 3509 + continue 3510 3510 + } 3511 3511 + 3512 3512 + switch string(nameBuf[:nameLen]) { 3513 3513 + // t.Key (string) (string) 3514 3514 + case "key": 3515 3515 + 3516 3516 + { 3517 3517 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3518 3518 + if err != nil { 3519 3519 + return err 3520 3520 + } 3521 3521 + 3522 3522 + t.Key = string(sval) 3523 3523 + } 3524 3524 + // t.Value (string) (string) 3525 3525 + case "value": 3526 3526 + 3527 3527 + { 3528 3528 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3529 3529 + if err != nil { 3530 3530 + return err 3531 3531 + } 3532 3532 + 3533 3533 + t.Value = string(sval) 3534 3534 + } 3535 3535 + 3536 3536 + default: 3537 3537 + // Field doesn't exist on this type, so ignore it 3538 3538 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3539 3539 + return err 3540 3540 + } 3541 3541 + } 3542 3542 + } 3543 3543 + 3544 3544 + return nil 3545 3545 + } 3619 3546 func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { 3620 3547 if t == nil { 3621 3548 _, err := w.Write(cbg.CborNull) ··· 3967 3894 3968 3895 return nil 3969 3896 } 3970 3970 - func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 3897 3897 + func (t *Pipeline) MarshalCBOR(w io.Writer) error { 3971 3898 if t == nil { 3972 3899 _, err := w.Write(cbg.CborNull) 3973 3900 return err ··· 3975 3902 3976 3903 cw := cbg.NewCborWriter(w) 3977 3904 3978 3978 - if _, err := cw.Write([]byte{162}); err != nil { 3905 3905 + if _, err := cw.Write([]byte{163}); err != nil { 3979 3906 return err 3980 3907 } 3981 3908 3982 3982 - // t.Key (string) (string) 3983 3983 - if len("key") > 1000000 { 3984 3984 - return xerrors.Errorf("Value in field \"key\" was too long") 3909 3909 + // t.LexiconTypeID (string) (string) 3910 3910 + if len("$type") > 1000000 { 3911 3911 + return xerrors.Errorf("Value in field \"$type\" was too long") 3985 3912 } 3986 3913 3987 3987 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3914 3914 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 3988 3915 return err 3989 3916 } 3990 3990 - if _, err := cw.WriteString(string("key")); err != nil { 3917 3917 + if _, err := cw.WriteString(string("$type")); err != nil { 3918 3918 + return err 3919 3919 + } 3920 3920 + 3921 3921 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { 3922 3922 + return err 3923 3923 + } 3924 3924 + if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { 3991 3925 return err 3992 3926 } 3993 3927 3994 3994 - if len(t.Key) > 1000000 { 3995 3995 - return xerrors.Errorf("Value in field t.Key was too long") 3928 3928 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 3929 3929 + if len("workflows") > 1000000 { 3930 3930 + return xerrors.Errorf("Value in field \"workflows\" was too long") 3996 3931 } 3997 3932 3998 3998 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3933 3933 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { 3999 3934 return err 4000 3935 } 4001 4001 - if _, err := cw.WriteString(string(t.Key)); err != nil { 3936 3936 + if _, err := cw.WriteString(string("workflows")); err != nil { 4002 3937 return err 4003 3938 } 4004 3939 4005 4005 - // t.Value (string) (string) 4006 4006 - if len("value") > 1000000 { 4007 4007 - return xerrors.Errorf("Value in field \"value\" was too long") 3940 3940 + if len(t.Workflows) > 8192 { 3941 3941 + return xerrors.Errorf("Slice value in field t.Workflows was too long") 4008 3942 } 4009 3943 4010 4010 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 3944 3944 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { 4011 3945 return err 4012 3946 } 4013 4013 - if _, err := cw.WriteString(string("value")); err != nil { 4014 4014 - return err 3947 3947 + for _, v := range t.Workflows { 3948 3948 + if err := v.MarshalCBOR(cw); err != nil { 3949 3949 + return err 3950 3950 + } 3951 3951 + 4015 3952 } 4016 3953 4017 4017 - if len(t.Value) > 1000000 { 4018 4018 - return xerrors.Errorf("Value in field t.Value was too long") 3954 3954 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 3955 3955 + if len("triggerMetadata") > 1000000 { 3956 3956 + return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") 4019 3957 } 4020 3958 4021 4021 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 3959 3959 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { 3960 3960 + return err 3961 3961 + } 3962 3962 + if _, err := cw.WriteString(string("triggerMetadata")); err != nil { 4022 3963 return err 4023 3964 } 4024 4024 - if _, err := cw.WriteString(string(t.Value)); err != nil { 3965 3965 + 3966 3966 + if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { 4025 3967 return err 4026 3968 } 4027 3969 return nil 4028 3970 } 4029 3971 4030 4030 - func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 4031 4031 - *t = Pipeline_Workflow_Environment_Elem{} 3972 3972 + func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { 3973 3973 + *t = Pipeline{} 4032 3974 4033 3975 cr := cbg.NewCborReader(r) 4034 3976 ··· 4047 3989 } 4048 3990 4049 3991 if extra > cbg.MaxLength { 4050 4050 - return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 3992 3992 + return fmt.Errorf("Pipeline: map struct too large (%d)", extra) 4051 3993 } 4052 3994 4053 3995 n := extra 4054 3996 4055 4055 - nameBuf := make([]byte, 5) 3997 3997 + nameBuf := make([]byte, 15) 4056 3998 for i := uint64(0); i < n; i++ { 4057 3999 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4058 4000 if err != nil { ··· 4068 4010 } 4069 4011 4070 4012 switch string(nameBuf[:nameLen]) { 4071 4071 - // t.Key (string) (string) 4072 4072 - case "key": 4013 4013 + // t.LexiconTypeID (string) (string) 4014 4014 + case "$type": 4073 4015 4074 4016 { 4075 4017 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 4077 4019 return err 4078 4020 } 4079 4021 4080 4080 - t.Key = string(sval) 4022 4022 + t.LexiconTypeID = string(sval) 4023 4023 + } 4024 4024 + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) 4025 4025 + case "workflows": 4026 4026 + 4027 4027 + maj, extra, err = cr.ReadHeader() 4028 4028 + if err != nil { 4029 4029 + return err 4030 4030 + } 4031 4031 + 4032 4032 + if extra > 8192 { 4033 4033 + return fmt.Errorf("t.Workflows: array too large (%d)", extra) 4034 4034 + } 4035 4035 + 4036 4036 + if maj != cbg.MajArray { 4037 4037 + return fmt.Errorf("expected cbor array") 4038 4038 + } 4039 4039 + 4040 4040 + if extra > 0 { 4041 4041 + t.Workflows = make([]*Pipeline_Workflow, extra) 4081 4042 } 4082 4082 - // t.Value (string) (string) 4083 4083 - case "value": 4043 4043 + 4044 4044 + for i := 0; i < int(extra); i++ { 4045 4045 + { 4046 4046 + var maj byte 4047 4047 + var extra uint64 4048 4048 + var err error 4049 4049 + _ = maj 4050 4050 + _ = extra 4051 4051 + _ = err 4052 4052 + 4053 4053 + { 4054 4054 + 4055 4055 + b, err := cr.ReadByte() 4056 4056 + if err != nil { 4057 4057 + return err 4058 4058 + } 4059 4059 + if b != cbg.CborNull[0] { 4060 4060 + if err := cr.UnreadByte(); err != nil { 4061 4061 + return err 4062 4062 + } 4063 4063 + t.Workflows[i] = new(Pipeline_Workflow) 4064 4064 + if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { 4065 4065 + return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) 4066 4066 + } 4067 4067 + } 4068 4068 + 4069 4069 + } 4070 4070 + 4071 4071 + } 4072 4072 + } 4073 4073 + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) 4074 4074 + case "triggerMetadata": 4084 4075 4085 4076 { 4086 4086 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4077 4077 + 4078 4078 + b, err := cr.ReadByte() 4087 4079 if err != nil { 4088 4080 return err 4089 4081 } 4082 4082 + if b != cbg.CborNull[0] { 4083 4083 + if err := cr.UnreadByte(); err != nil { 4084 4084 + return err 4085 4085 + } 4086 4086 + t.TriggerMetadata = new(Pipeline_TriggerMetadata) 4087 4087 + if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { 4088 4088 + return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) 4089 4089 + } 4090 4090 + } 4090 4091 4091 4091 - t.Value = string(sval) 4092 4092 } 4093 4093 4094 4094 default: ··· 4299 4299 4300 4300 return nil 4301 4301 } 4302 4302 - func (t *Repo) MarshalCBOR(w io.Writer) error { 4302 4302 + func (t *RepoArtifact) MarshalCBOR(w io.Writer) error { 4303 4303 if t == nil { 4304 4304 _, err := w.Write(cbg.CborNull) 4305 4305 return err 4306 4306 } 4307 4307 4308 4308 cw := cbg.NewCborWriter(w) 4309 4309 - fieldCount := 7 4309 4309 + fieldCount := 6 4310 4310 4311 4311 - if t.Description == nil { 4312 4312 - fieldCount-- 4313 4313 - } 4314 4314 - 4315 4315 - if t.Source == nil { 4311 4311 + if t.Tag == nil { 4316 4312 fieldCount-- 4317 4313 } 4318 4314 ··· 4320 4316 return err 4321 4317 } 4322 4318 4323 4323 - // t.Knot (string) (string) 4324 4324 - if len("knot") > 1000000 { 4325 4325 - return xerrors.Errorf("Value in field \"knot\" was too long") 4326 4326 - } 4319 4319 + // t.Tag (util.LexBytes) (slice) 4320 4320 + if t.Tag != nil { 4321 4321 + 4322 4322 + if len("tag") > 1000000 { 4323 4323 + return xerrors.Errorf("Value in field \"tag\" was too long") 4324 4324 + } 4327 4325 4328 4328 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 4329 4329 - return err 4330 4330 - } 4331 4331 - if _, err := cw.WriteString(string("knot")); err != nil { 4332 4332 - return err 4333 4333 - } 4326 4326 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil { 4327 4327 + return err 4328 4328 + } 4329 4329 + if _, err := cw.WriteString(string("tag")); err != nil { 4330 4330 + return err 4331 4331 + } 4334 4332 4335 4335 - if len(t.Knot) > 1000000 { 4336 4336 - return xerrors.Errorf("Value in field t.Knot was too long") 4337 4337 - } 4333 4333 + if len(t.Tag) > 2097152 { 4334 4334 + return xerrors.Errorf("Byte array in field t.Tag was too long") 4335 4335 + } 4338 4336 4339 4339 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 4340 4340 - return err 4341 4341 - } 4342 4342 - if _, err := cw.WriteString(string(t.Knot)); err != nil { 4343 4343 - return err 4337 4337 + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil { 4338 4338 + return err 4339 4339 + } 4340 4340 + 4341 4341 + if _, err := cw.Write(t.Tag); err != nil { 4342 4342 + return err 4343 4343 + } 4344 4344 + 4344 4345 } 4345 4346 4346 4347 // t.Name (string) (string) ··· 4366 4367 return err 4367 4368 } 4368 4369 4369 4369 - // t.LexiconTypeID (string) (string) 4370 4370 - if len("$type") > 1000000 { 4371 4371 - return xerrors.Errorf("Value in field \"$type\" was too long") 4370 4370 + // t.Repo (string) (string) 4371 4371 + if len("repo") > 1000000 { 4372 4372 + return xerrors.Errorf("Value in field \"repo\" was too long") 4372 4373 } 4373 4374 4374 4374 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4375 4375 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 4375 4376 return err 4376 4377 } 4377 4377 - if _, err := cw.WriteString(string("$type")); err != nil { 4378 4378 + if _, err := cw.WriteString(string("repo")); err != nil { 4378 4379 return err 4379 4380 } 4380 4381 4381 4381 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil { 4382 4382 + if len(t.Repo) > 1000000 { 4383 4383 + return xerrors.Errorf("Value in field t.Repo was too long") 4384 4384 + } 4385 4385 + 4386 4386 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 4382 4387 return err 4383 4388 } 4384 4384 - if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil { 4389 4389 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 4385 4390 return err 4386 4391 } 4387 4392 4388 4388 - // t.Owner (string) (string) 4389 4389 - if len("owner") > 1000000 { 4390 4390 - return xerrors.Errorf("Value in field \"owner\" was too long") 4393 4393 + // t.LexiconTypeID (string) (string) 4394 4394 + if len("$type") > 1000000 { 4395 4395 + return xerrors.Errorf("Value in field \"$type\" was too long") 4391 4396 } 4392 4397 4393 4393 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 4398 4398 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4394 4399 return err 4395 4400 } 4396 4396 - if _, err := cw.WriteString(string("owner")); err != nil { 4401 4401 + if _, err := cw.WriteString(string("$type")); err != nil { 4397 4402 return err 4398 4403 } 4399 4404 4400 4400 - if len(t.Owner) > 1000000 { 4401 4401 - return xerrors.Errorf("Value in field t.Owner was too long") 4402 4402 - } 4403 4403 - 4404 4404 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 4405 4405 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil { 4405 4406 return err 4406 4407 } 4407 4407 - if _, err := cw.WriteString(string(t.Owner)); err != nil { 4408 4408 + if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 4408 4409 return err 4409 4410 } 4410 4411 4411 4411 - // t.Source (string) (string) 4412 4412 - if t.Source != nil { 4413 4413 - 4414 4414 - if len("source") > 1000000 { 4415 4415 - return xerrors.Errorf("Value in field \"source\" was too long") 4416 4416 - } 4417 4417 - 4418 4418 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 4419 4419 - return err 4420 4420 - } 4421 4421 - if _, err := cw.WriteString(string("source")); err != nil { 4422 4422 - return err 4423 4423 - } 4412 4412 + // t.Artifact (util.LexBlob) (struct) 4413 4413 + if len("artifact") > 1000000 { 4414 4414 + return xerrors.Errorf("Value in field \"artifact\" was too long") 4415 4415 + } 4424 4416 4425 4425 - if t.Source == nil { 4426 4426 - if _, err := cw.Write(cbg.CborNull); err != nil { 4427 4427 - return err 4428 4428 - } 4429 4429 - } else { 4430 4430 - if len(*t.Source) > 1000000 { 4431 4431 - return xerrors.Errorf("Value in field t.Source was too long") 4432 4432 - } 4417 4417 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil { 4418 4418 + return err 4419 4419 + } 4420 4420 + if _, err := cw.WriteString(string("artifact")); err != nil { 4421 4421 + return err 4422 4422 + } 4433 4423 4434 4434 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil { 4435 4435 - return err 4436 4436 - } 4437 4437 - if _, err := cw.WriteString(string(*t.Source)); err != nil { 4438 4438 - return err 4439 4439 - } 4440 4440 - } 4424 4424 + if err := t.Artifact.MarshalCBOR(cw); err != nil { 4425 4425 + return err 4441 4426 } 4442 4427 4443 4428 // t.CreatedAt (string) (string) ··· 4462 4447 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 4463 4448 return err 4464 4449 } 4465 4465 - 4466 4466 - // t.Description (string) (string) 4467 4467 - if t.Description != nil { 4468 4468 - 4469 4469 - if len("description") > 1000000 { 4470 4470 - return xerrors.Errorf("Value in field \"description\" was too long") 4471 4471 - } 4472 4472 - 4473 4473 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 4474 4474 - return err 4475 4475 - } 4476 4476 - if _, err := cw.WriteString(string("description")); err != nil { 4477 4477 - return err 4478 4478 - } 4479 4479 - 4480 4480 - if t.Description == nil { 4481 4481 - if _, err := cw.Write(cbg.CborNull); err != nil { 4482 4482 - return err 4483 4483 - } 4484 4484 - } else { 4485 4485 - if len(*t.Description) > 1000000 { 4486 4486 - return xerrors.Errorf("Value in field t.Description was too long") 4487 4487 - } 4488 4488 - 4489 4489 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 4490 4490 - return err 4491 4491 - } 4492 4492 - if _, err := cw.WriteString(string(*t.Description)); err != nil { 4493 4493 - return err 4494 4494 - } 4495 4495 - } 4496 4496 - } 4497 4450 return nil 4498 4451 } 4499 4452 4500 4500 - func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) { 4501 4501 - *t = Repo{} 4453 4453 + func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) { 4454 4454 + *t = RepoArtifact{} 4502 4455 4503 4456 cr := cbg.NewCborReader(r) 4504 4457 ··· 4517 4470 } 4518 4471 4519 4472 if extra > cbg.MaxLength { 4520 4520 - return fmt.Errorf("Repo: map struct too large (%d)", extra) 4473 4473 + return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra) 4521 4474 } 4522 4475 4523 4476 n := extra 4524 4477 4525 4525 - nameBuf := make([]byte, 11) 4478 4478 + nameBuf := make([]byte, 9) 4526 4479 for i := uint64(0); i < n; i++ { 4527 4480 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4528 4481 if err != nil { ··· 4538 4491 } 4539 4492 4540 4493 switch string(nameBuf[:nameLen]) { 4541 4541 - // t.Knot (string) (string) 4542 4542 - case "knot": 4494 4494 + // t.Tag (util.LexBytes) (slice) 4495 4495 + case "tag": 4543 4496 4544 4544 - { 4545 4545 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4546 4546 - if err != nil { 4547 4547 - return err 4548 4548 - } 4497 4497 + maj, extra, err = cr.ReadHeader() 4498 4498 + if err != nil { 4499 4499 + return err 4500 4500 + } 4549 4501 4550 4550 - t.Knot = string(sval) 4502 4502 + if extra > 2097152 { 4503 4503 + return fmt.Errorf("t.Tag: byte array too large (%d)", extra) 4551 4504 } 4505 4505 + if maj != cbg.MajByteString { 4506 4506 + return fmt.Errorf("expected byte array") 4507 4507 + } 4508 4508 + 4509 4509 + if extra > 0 { 4510 4510 + t.Tag = make([]uint8, extra) 4511 4511 + } 4512 4512 + 4513 4513 + if _, err := io.ReadFull(cr, t.Tag); err != nil { 4514 4514 + return err 4515 4515 + } 4516 4516 + 4552 4517 // t.Name (string) (string) 4553 4518 case "name": 4554 4519 ··· 4560 4525 4561 4526 t.Name = string(sval) 4562 4527 } 4563 4563 - // t.LexiconTypeID (string) (string) 4564 4564 - case "$type": 4528 4528 + // t.Repo (string) (string) 4529 4529 + case "repo": 4565 4530 4566 4531 { 4567 4532 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 4569 4534 return err 4570 4535 } 4571 4536 4572 4572 - t.LexiconTypeID = string(sval) 4537 4537 + t.Repo = string(sval) 4573 4538 } 4574 4574 - // t.Owner (string) (string) 4575 4575 - case "owner": 4539 4539 + // t.LexiconTypeID (string) (string) 4540 4540 + case "$type": 4576 4541 4577 4542 { 4578 4543 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 4580 4545 return err 4581 4546 } 4582 4547 4583 4583 - t.Owner = string(sval) 4548 4548 + t.LexiconTypeID = string(sval) 4584 4549 } 4585 4585 - // t.Source (string) (string) 4586 4586 - case "source": 4550 4550 + // t.Artifact (util.LexBlob) (struct) 4551 4551 + case "artifact": 4587 4552 4588 4553 { 4554 4554 + 4589 4555 b, err := cr.ReadByte() 4590 4556 if err != nil { 4591 4557 return err ··· 4594 4560 if err := cr.UnreadByte(); err != nil { 4595 4561 return err 4596 4562 } 4597 4597 - 4598 4598 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4599 4599 - if err != nil { 4600 4600 - return err 4563 4563 + t.Artifact = new(util.LexBlob) 4564 4564 + if err := t.Artifact.UnmarshalCBOR(cr); err != nil { 4565 4565 + return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err) 4601 4566 } 4567 4567 + } 4602 4568 4603 4603 - t.Source = (*string)(&sval) 4604 4604 - } 4605 4569 } 4606 4570 // t.CreatedAt (string) (string) 4607 4571 case "createdAt": ··· 4614 4578 4615 4579 t.CreatedAt = string(sval) 4616 4580 } 4617 4617 - // t.Description (string) (string) 4618 4618 - case "description": 4619 4619 - 4620 4620 - { 4621 4621 - b, err := cr.ReadByte() 4622 4622 - if err != nil { 4623 4623 - return err 4624 4624 - } 4625 4625 - if b != cbg.CborNull[0] { 4626 4626 - if err := cr.UnreadByte(); err != nil { 4627 4627 - return err 4628 4628 - } 4629 4629 - 4630 4630 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4631 4631 - if err != nil { 4632 4632 - return err 4633 4633 - } 4634 4634 - 4635 4635 - t.Description = (*string)(&sval) 4636 4636 - } 4637 4637 - } 4638 4581 4639 4582 default: 4640 4583 // Field doesn't exist on this type, so ignore it ··· 4646 4589 4647 4590 return nil 4648 4591 } 4649 4649 - func (t *RepoArtifact) MarshalCBOR(w io.Writer) error { 4592 4592 + func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error { 4650 4593 if t == nil { 4651 4594 _, err := w.Write(cbg.CborNull) 4652 4595 return err 4653 4596 } 4654 4597 4655 4598 cw := cbg.NewCborWriter(w) 4656 4656 - fieldCount := 6 4599 4599 + fieldCount := 7 4657 4600 4658 4658 - if t.Tag == nil { 4601 4601 + if t.CommentId == nil { 4659 4602 fieldCount-- 4660 4603 } 4661 4604 4662 4662 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 4663 4663 - return err 4605 4605 + if t.Owner == nil { 4606 4606 + fieldCount-- 4664 4607 } 4665 4608 4666 4666 - // t.Tag (util.LexBytes) (slice) 4667 4667 - if t.Tag != nil { 4668 4668 - 4669 4669 - if len("tag") > 1000000 { 4670 4670 - return xerrors.Errorf("Value in field \"tag\" was too long") 4671 4671 - } 4672 4672 - 4673 4673 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil { 4674 4674 - return err 4675 4675 - } 4676 4676 - if _, err := cw.WriteString(string("tag")); err != nil { 4677 4677 - return err 4678 4678 - } 4679 4679 - 4680 4680 - if len(t.Tag) > 2097152 { 4681 4681 - return xerrors.Errorf("Byte array in field t.Tag was too long") 4682 4682 - } 4683 4683 - 4684 4684 - if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil { 4685 4685 - return err 4686 4686 - } 4687 4687 - 4688 4688 - if _, err := cw.Write(t.Tag); err != nil { 4689 4689 - return err 4690 4690 - } 4609 4609 + if t.Repo == nil { 4610 4610 + fieldCount-- 4611 4611 + } 4691 4612 4613 4613 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 4614 4614 + return err 4692 4615 } 4693 4616 4694 4694 - // t.Name (string) (string) 4695 4695 - if len("name") > 1000000 { 4696 4696 - return xerrors.Errorf("Value in field \"name\" was too long") 4617 4617 + // t.Body (string) (string) 4618 4618 + if len("body") > 1000000 { 4619 4619 + return xerrors.Errorf("Value in field \"body\" was too long") 4697 4620 } 4698 4621 4699 4699 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 4622 4622 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 4700 4623 return err 4701 4624 } 4702 4702 - if _, err := cw.WriteString(string("name")); err != nil { 4625 4625 + if _, err := cw.WriteString(string("body")); err != nil { 4703 4626 return err 4704 4627 } 4705 4628 4706 4706 - if len(t.Name) > 1000000 { 4707 4707 - return xerrors.Errorf("Value in field t.Name was too long") 4629 4629 + if len(t.Body) > 1000000 { 4630 4630 + return xerrors.Errorf("Value in field t.Body was too long") 4708 4631 } 4709 4632 4710 4710 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 4633 4633 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 4711 4634 return err 4712 4635 } 4713 4713 - if _, err := cw.WriteString(string(t.Name)); err != nil { 4636 4636 + if _, err := cw.WriteString(string(t.Body)); err != nil { 4714 4637 return err 4715 4638 } 4716 4639 4717 4640 // t.Repo (string) (string) 4718 4718 - if len("repo") > 1000000 { 4719 4719 - return xerrors.Errorf("Value in field \"repo\" was too long") 4720 4720 - } 4641 4641 + if t.Repo != nil { 4721 4642 4722 4722 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 4723 4723 - return err 4724 4724 - } 4725 4725 - if _, err := cw.WriteString(string("repo")); err != nil { 4726 4726 - return err 4727 4727 - } 4643 4643 + if len("repo") > 1000000 { 4644 4644 + return xerrors.Errorf("Value in field \"repo\" was too long") 4645 4645 + } 4728 4646 4729 4729 - if len(t.Repo) > 1000000 { 4730 4730 - return xerrors.Errorf("Value in field t.Repo was too long") 4731 4731 - } 4647 4647 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 4648 4648 + return err 4649 4649 + } 4650 4650 + if _, err := cw.WriteString(string("repo")); err != nil { 4651 4651 + return err 4652 4652 + } 4653 4653 + 4654 4654 + if t.Repo == nil { 4655 4655 + if _, err := cw.Write(cbg.CborNull); err != nil { 4656 4656 + return err 4657 4657 + } 4658 4658 + } else { 4659 4659 + if len(*t.Repo) > 1000000 { 4660 4660 + return xerrors.Errorf("Value in field t.Repo was too long") 4661 4661 + } 4732 4662 4733 4733 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 4734 4734 - return err 4735 4735 - } 4736 4736 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 4737 4737 - return err 4663 4663 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 4664 4664 + return err 4665 4665 + } 4666 4666 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 4667 4667 + return err 4668 4668 + } 4669 4669 + } 4738 4670 } 4739 4671 4740 4672 // t.LexiconTypeID (string) (string) ··· 4749 4681 return err 4750 4682 } 4751 4683 4752 4752 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil { 4684 4684 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil { 4753 4685 return err 4754 4686 } 4755 4755 - if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 4687 4687 + if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil { 4756 4688 return err 4757 4689 } 4758 4690 4759 4759 - // t.Artifact (util.LexBlob) (struct) 4760 4760 - if len("artifact") > 1000000 { 4761 4761 - return xerrors.Errorf("Value in field \"artifact\" was too long") 4691 4691 + // t.Issue (string) (string) 4692 4692 + if len("issue") > 1000000 { 4693 4693 + return xerrors.Errorf("Value in field \"issue\" was too long") 4762 4694 } 4763 4695 4764 4764 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil { 4696 4696 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 4765 4697 return err 4766 4698 } 4767 4767 - if _, err := cw.WriteString(string("artifact")); err != nil { 4699 4699 + if _, err := cw.WriteString(string("issue")); err != nil { 4768 4700 return err 4769 4701 } 4770 4702 4771 4771 - if err := t.Artifact.MarshalCBOR(cw); err != nil { 4703 4703 + if len(t.Issue) > 1000000 { 4704 4704 + return xerrors.Errorf("Value in field t.Issue was too long") 4705 4705 + } 4706 4706 + 4707 4707 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 4708 4708 + return err 4709 4709 + } 4710 4710 + if _, err := cw.WriteString(string(t.Issue)); err != nil { 4772 4711 return err 4773 4712 } 4774 4713 4714 4714 + // t.Owner (string) (string) 4715 4715 + if t.Owner != nil { 4716 4716 + 4717 4717 + if len("owner") > 1000000 { 4718 4718 + return xerrors.Errorf("Value in field \"owner\" was too long") 4719 4719 + } 4720 4720 + 4721 4721 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 4722 4722 + return err 4723 4723 + } 4724 4724 + if _, err := cw.WriteString(string("owner")); err != nil { 4725 4725 + return err 4726 4726 + } 4727 4727 + 4728 4728 + if t.Owner == nil { 4729 4729 + if _, err := cw.Write(cbg.CborNull); err != nil { 4730 4730 + return err 4731 4731 + } 4732 4732 + } else { 4733 4733 + if len(*t.Owner) > 1000000 { 4734 4734 + return xerrors.Errorf("Value in field t.Owner was too long") 4735 4735 + } 4736 4736 + 4737 4737 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil { 4738 4738 + return err 4739 4739 + } 4740 4740 + if _, err := cw.WriteString(string(*t.Owner)); err != nil { 4741 4741 + return err 4742 4742 + } 4743 4743 + } 4744 4744 + } 4745 4745 + 4746 4746 + // t.CommentId (int64) (int64) 4747 4747 + if t.CommentId != nil { 4748 4748 + 4749 4749 + if len("commentId") > 1000000 { 4750 4750 + return xerrors.Errorf("Value in field \"commentId\" was too long") 4751 4751 + } 4752 4752 + 4753 4753 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil { 4754 4754 + return err 4755 4755 + } 4756 4756 + if _, err := cw.WriteString(string("commentId")); err != nil { 4757 4757 + return err 4758 4758 + } 4759 4759 + 4760 4760 + if t.CommentId == nil { 4761 4761 + if _, err := cw.Write(cbg.CborNull); err != nil { 4762 4762 + return err 4763 4763 + } 4764 4764 + } else { 4765 4765 + if *t.CommentId >= 0 { 4766 4766 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil { 4767 4767 + return err 4768 4768 + } 4769 4769 + } else { 4770 4770 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil { 4771 4771 + return err 4772 4772 + } 4773 4773 + } 4774 4774 + } 4775 4775 + 4776 4776 + } 4777 4777 + 4775 4778 // t.CreatedAt (string) (string) 4776 4779 if len("createdAt") > 1000000 { 4777 4780 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 4797 4800 return nil 4798 4801 } 4799 4802 4800 4800 - func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) { 4801 4801 - *t = RepoArtifact{} 4803 4803 + func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) { 4804 4804 + *t = RepoIssueComment{} 4802 4805 4803 4806 cr := cbg.NewCborReader(r) 4804 4807 ··· 4817 4820 } 4818 4821 4819 4822 if extra > cbg.MaxLength { 4820 4820 - return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra) 4823 4823 + return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra) 4821 4824 } 4822 4825 4823 4826 n := extra ··· 4838 4841 } 4839 4842 4840 4843 switch string(nameBuf[:nameLen]) { 4841 4841 - // t.Tag (util.LexBytes) (slice) 4842 4842 - case "tag": 4843 4843 - 4844 4844 - maj, extra, err = cr.ReadHeader() 4845 4845 - if err != nil { 4846 4846 - return err 4847 4847 - } 4848 4848 - 4849 4849 - if extra > 2097152 { 4850 4850 - return fmt.Errorf("t.Tag: byte array too large (%d)", extra) 4851 4851 - } 4852 4852 - if maj != cbg.MajByteString { 4853 4853 - return fmt.Errorf("expected byte array") 4854 4854 - } 4855 4855 - 4856 4856 - if extra > 0 { 4857 4857 - t.Tag = make([]uint8, extra) 4858 4858 - } 4859 4859 - 4860 4860 - if _, err := io.ReadFull(cr, t.Tag); err != nil { 4861 4861 - return err 4862 4862 - } 4863 4863 - 4864 4864 - // t.Name (string) (string) 4865 4865 - case "name": 4844 4844 + // t.Body (string) (string) 4845 4845 + case "body": 4866 4846 4867 4847 { 4868 4848 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 4870 4850 return err 4871 4851 } 4872 4852 4873 4873 - t.Name = string(sval) 4853 4853 + t.Body = string(sval) 4874 4854 } 4875 4855 // t.Repo (string) (string) 4876 4856 case "repo": 4877 4857 4878 4858 { 4879 4879 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4859 4859 + b, err := cr.ReadByte() 4880 4860 if err != nil { 4881 4861 return err 4882 4862 } 4863 4863 + if b != cbg.CborNull[0] { 4864 4864 + if err := cr.UnreadByte(); err != nil { 4865 4865 + return err 4866 4866 + } 4883 4867 4884 4884 - t.Repo = string(sval) 4868 4868 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4869 4869 + if err != nil { 4870 4870 + return err 4871 4871 + } 4872 4872 + 4873 4873 + t.Repo = (*string)(&sval) 4874 4874 + } 4885 4875 } 4886 4876 // t.LexiconTypeID (string) (string) 4887 4877 case "$type": ··· 4894 4884 4895 4885 t.LexiconTypeID = string(sval) 4896 4886 } 4897 4897 - // t.Artifact (util.LexBlob) (struct) 4898 4898 - case "artifact": 4887 4887 + // t.Issue (string) (string) 4888 4888 + case "issue": 4899 4889 4900 4890 { 4891 4891 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4892 4892 + if err != nil { 4893 4893 + return err 4894 4894 + } 4901 4895 4896 4896 + t.Issue = string(sval) 4897 4897 + } 4898 4898 + // t.Owner (string) (string) 4899 4899 + case "owner": 4900 4900 + 4901 4901 + { 4902 4902 b, err := cr.ReadByte() 4903 4903 if err != nil { 4904 4904 return err ··· 4907 4907 if err := cr.UnreadByte(); err != nil { 4908 4908 return err 4909 4909 } 4910 4910 - t.Artifact = new(util.LexBlob) 4911 4911 - if err := t.Artifact.UnmarshalCBOR(cr); err != nil { 4912 4912 - return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err) 4910 4910 + 4911 4911 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4912 4912 + if err != nil { 4913 4913 + return err 4913 4914 } 4915 4915 + 4916 4916 + t.Owner = (*string)(&sval) 4914 4917 } 4918 4918 + } 4919 4919 + // t.CommentId (int64) (int64) 4920 4920 + case "commentId": 4921 4921 + { 4915 4922 4923 4923 + b, err := cr.ReadByte() 4924 4924 + if err != nil { 4925 4925 + return err 4926 4926 + } 4927 4927 + if b != cbg.CborNull[0] { 4928 4928 + if err := cr.UnreadByte(); err != nil { 4929 4929 + return err 4930 4930 + } 4931 4931 + maj, extra, err := cr.ReadHeader() 4932 4932 + if err != nil { 4933 4933 + return err 4934 4934 + } 4935 4935 + var extraI int64 4936 4936 + switch maj { 4937 4937 + case cbg.MajUnsignedInt: 4938 4938 + extraI = int64(extra) 4939 4939 + if extraI < 0 { 4940 4940 + return fmt.Errorf("int64 positive overflow") 4941 4941 + } 4942 4942 + case cbg.MajNegativeInt: 4943 4943 + extraI = int64(extra) 4944 4944 + if extraI < 0 { 4945 4945 + return fmt.Errorf("int64 negative overflow") 4946 4946 + } 4947 4947 + extraI = -1 - extraI 4948 4948 + default: 4949 4949 + return fmt.Errorf("wrong type for int64 field: %d", maj) 4950 4950 + } 4951 4951 + 4952 4952 + t.CommentId = (*int64)(&extraI) 4953 4953 + } 4916 4954 } 4917 4955 // t.CreatedAt (string) (string) 4918 4956 case "createdAt": ··· 4936 4974 4937 4975 return nil 4938 4976 } 4977 4977 + func (t *RepoIssueState) MarshalCBOR(w io.Writer) error { 4978 4978 + if t == nil { 4979 4979 + _, err := w.Write(cbg.CborNull) 4980 4980 + return err 4981 4981 + } 4982 4982 + 4983 4983 + cw := cbg.NewCborWriter(w) 4984 4984 + 4985 4985 + if _, err := cw.Write([]byte{163}); err != nil { 4986 4986 + return err 4987 4987 + } 4988 4988 + 4989 4989 + // t.LexiconTypeID (string) (string) 4990 4990 + if len("$type") > 1000000 { 4991 4991 + return xerrors.Errorf("Value in field \"$type\" was too long") 4992 4992 + } 4993 4993 + 4994 4994 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 4995 4995 + return err 4996 4996 + } 4997 4997 + if _, err := cw.WriteString(string("$type")); err != nil { 4998 4998 + return err 4999 4999 + } 5000 5000 + 5001 5001 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil { 5002 5002 + return err 5003 5003 + } 5004 5004 + if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil { 5005 5005 + return err 5006 5006 + } 5007 5007 + 5008 5008 + // t.Issue (string) (string) 5009 5009 + if len("issue") > 1000000 { 5010 5010 + return xerrors.Errorf("Value in field \"issue\" was too long") 5011 5011 + } 5012 5012 + 5013 5013 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 5014 5014 + return err 5015 5015 + } 5016 5016 + if _, err := cw.WriteString(string("issue")); err != nil { 5017 5017 + return err 5018 5018 + } 5019 5019 + 5020 5020 + if len(t.Issue) > 1000000 { 5021 5021 + return xerrors.Errorf("Value in field t.Issue was too long") 5022 5022 + } 5023 5023 + 5024 5024 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 5025 5025 + return err 5026 5026 + } 5027 5027 + if _, err := cw.WriteString(string(t.Issue)); err != nil { 5028 5028 + return err 5029 5029 + } 5030 5030 + 5031 5031 + // t.State (string) (string) 5032 5032 + if len("state") > 1000000 { 5033 5033 + return xerrors.Errorf("Value in field \"state\" was too long") 5034 5034 + } 5035 5035 + 5036 5036 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 5037 5037 + return err 5038 5038 + } 5039 5039 + if _, err := cw.WriteString(string("state")); err != nil { 5040 5040 + return err 5041 5041 + } 5042 5042 + 5043 5043 + if len(t.State) > 1000000 { 5044 5044 + return xerrors.Errorf("Value in field t.State was too long") 5045 5045 + } 5046 5046 + 5047 5047 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 5048 5048 + return err 5049 5049 + } 5050 5050 + if _, err := cw.WriteString(string(t.State)); err != nil { 5051 5051 + return err 5052 5052 + } 5053 5053 + return nil 5054 5054 + } 5055 5055 + 5056 5056 + func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) { 5057 5057 + *t = RepoIssueState{} 5058 5058 + 5059 5059 + cr := cbg.NewCborReader(r) 5060 5060 + 5061 5061 + maj, extra, err := cr.ReadHeader() 5062 5062 + if err != nil { 5063 5063 + return err 5064 5064 + } 5065 5065 + defer func() { 5066 5066 + if err == io.EOF { 5067 5067 + err = io.ErrUnexpectedEOF 5068 5068 + } 5069 5069 + }() 5070 5070 + 5071 5071 + if maj != cbg.MajMap { 5072 5072 + return fmt.Errorf("cbor input should be of type map") 5073 5073 + } 5074 5074 + 5075 5075 + if extra > cbg.MaxLength { 5076 5076 + return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra) 5077 5077 + } 5078 5078 + 5079 5079 + n := extra 5080 5080 + 5081 5081 + nameBuf := make([]byte, 5) 5082 5082 + for i := uint64(0); i < n; i++ { 5083 5083 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5084 5084 + if err != nil { 5085 5085 + return err 5086 5086 + } 5087 5087 + 5088 5088 + if !ok { 5089 5089 + // Field doesn't exist on this type, so ignore it 5090 5090 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5091 5091 + return err 5092 5092 + } 5093 5093 + continue 5094 5094 + } 5095 5095 + 5096 5096 + switch string(nameBuf[:nameLen]) { 5097 5097 + // t.LexiconTypeID (string) (string) 5098 5098 + case "$type": 5099 5099 + 5100 5100 + { 5101 5101 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5102 5102 + if err != nil { 5103 5103 + return err 5104 5104 + } 5105 5105 + 5106 5106 + t.LexiconTypeID = string(sval) 5107 5107 + } 5108 5108 + // t.Issue (string) (string) 5109 5109 + case "issue": 5110 5110 + 5111 5111 + { 5112 5112 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5113 5113 + if err != nil { 5114 5114 + return err 5115 5115 + } 5116 5116 + 5117 5117 + t.Issue = string(sval) 5118 5118 + } 5119 5119 + // t.State (string) (string) 5120 5120 + case "state": 5121 5121 + 5122 5122 + { 5123 5123 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5124 5124 + if err != nil { 5125 5125 + return err 5126 5126 + } 5127 5127 + 5128 5128 + t.State = string(sval) 5129 5129 + } 5130 5130 + 5131 5131 + default: 5132 5132 + // Field doesn't exist on this type, so ignore it 5133 5133 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5134 5134 + return err 5135 5135 + } 5136 5136 + } 5137 5137 + } 5138 5138 + 5139 5139 + return nil 5140 5140 + } 4939 5141 func (t *RepoIssue) MarshalCBOR(w io.Writer) error { 4940 5142 if t == nil { 4941 5143 _, err := w.Write(cbg.CborNull) ··· 5274 5476 5275 5477 return nil 5276 5478 } 5277 5277 - func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error { 5479 5479 + func (t *RepoPullComment) MarshalCBOR(w io.Writer) error { 5278 5480 if t == nil { 5279 5481 _, err := w.Write(cbg.CborNull) 5280 5482 return err ··· 5322 5524 return err 5323 5525 } 5324 5526 5527 5527 + // t.Pull (string) (string) 5528 5528 + if len("pull") > 1000000 { 5529 5529 + return xerrors.Errorf("Value in field \"pull\" was too long") 5530 5530 + } 5531 5531 + 5532 5532 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 5533 5533 + return err 5534 5534 + } 5535 5535 + if _, err := cw.WriteString(string("pull")); err != nil { 5536 5536 + return err 5537 5537 + } 5538 5538 + 5539 5539 + if len(t.Pull) > 1000000 { 5540 5540 + return xerrors.Errorf("Value in field t.Pull was too long") 5541 5541 + } 5542 5542 + 5543 5543 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 5544 5544 + return err 5545 5545 + } 5546 5546 + if _, err := cw.WriteString(string(t.Pull)); err != nil { 5547 5547 + return err 5548 5548 + } 5549 5549 + 5325 5550 // t.Repo (string) (string) 5326 5551 if t.Repo != nil { 5327 5552 ··· 5366 5591 return err 5367 5592 } 5368 5593 5369 5369 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil { 5370 5370 - return err 5371 5371 - } 5372 5372 - if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil { 5373 5373 - return err 5374 5374 - } 5375 5375 - 5376 5376 - // t.Issue (string) (string) 5377 5377 - if len("issue") > 1000000 { 5378 5378 - return xerrors.Errorf("Value in field \"issue\" was too long") 5379 5379 - } 5380 5380 - 5381 5381 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 5594 5594 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil { 5382 5595 return err 5383 5596 } 5384 5384 - if _, err := cw.WriteString(string("issue")); err != nil { 5385 5385 - return err 5386 5386 - } 5387 5387 - 5388 5388 - if len(t.Issue) > 1000000 { 5389 5389 - return xerrors.Errorf("Value in field t.Issue was too long") 5390 5390 - } 5391 5391 - 5392 5392 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 5393 5393 - return err 5394 5394 - } 5395 5395 - if _, err := cw.WriteString(string(t.Issue)); err != nil { 5597 5597 + if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil { 5396 5598 return err 5397 5599 } 5398 5600 ··· 5485 5687 return nil 5486 5688 } 5487 5689 5488 5488 - func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) { 5489 5489 - *t = RepoIssueComment{} 5690 5690 + func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) { 5691 5691 + *t = RepoPullComment{} 5490 5692 5491 5693 cr := cbg.NewCborReader(r) 5492 5694 ··· 5505 5707 } 5506 5708 5507 5709 if extra > cbg.MaxLength { 5508 5508 - return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra) 5710 5710 + return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra) 5509 5711 } 5510 5712 5511 5713 n := extra ··· 5537 5739 5538 5740 t.Body = string(sval) 5539 5741 } 5742 5742 + // t.Pull (string) (string) 5743 5743 + case "pull": 5744 5744 + 5745 5745 + { 5746 5746 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5747 5747 + if err != nil { 5748 5748 + return err 5749 5749 + } 5750 5750 + 5751 5751 + t.Pull = string(sval) 5752 5752 + } 5540 5753 // t.Repo (string) (string) 5541 5754 case "repo": 5542 5755 ··· 5568 5781 } 5569 5782 5570 5783 t.LexiconTypeID = string(sval) 5571 5571 - } 5572 5572 - // t.Issue (string) (string) 5573 5573 - case "issue": 5574 5574 - 5575 5575 - { 5576 5576 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5577 5577 - if err != nil { 5578 5578 - return err 5579 5579 - } 5580 5580 - 5581 5581 - t.Issue = string(sval) 5582 5784 } 5583 5785 // t.Owner (string) (string) 5584 5786 case "owner": ··· 5659 5861 5660 5862 return nil 5661 5863 } 5662 5662 - func (t *RepoIssueState) MarshalCBOR(w io.Writer) error { 5864 5864 + func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 5663 5865 if t == nil { 5664 5866 _, err := w.Write(cbg.CborNull) 5665 5867 return err ··· 5671 5873 return err 5672 5874 } 5673 5875 5674 5674 - // t.LexiconTypeID (string) (string) 5675 5675 - if len("$type") > 1000000 { 5676 5676 - return xerrors.Errorf("Value in field \"$type\" was too long") 5876 5876 + // t.Pull (string) (string) 5877 5877 + if len("pull") > 1000000 { 5878 5878 + return xerrors.Errorf("Value in field \"pull\" was too long") 5677 5879 } 5678 5880 5679 5679 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 5881 5881 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 5680 5882 return err 5681 5883 } 5682 5682 - if _, err := cw.WriteString(string("$type")); err != nil { 5884 5884 + if _, err := cw.WriteString(string("pull")); err != nil { 5683 5885 return err 5684 5886 } 5685 5887 5686 5686 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil { 5888 5888 + if len(t.Pull) > 1000000 { 5889 5889 + return xerrors.Errorf("Value in field t.Pull was too long") 5890 5890 + } 5891 5891 + 5892 5892 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 5687 5893 return err 5688 5894 } 5689 5689 - if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil { 5895 5895 + if _, err := cw.WriteString(string(t.Pull)); err != nil { 5690 5896 return err 5691 5897 } 5692 5898 5693 5693 - // t.Issue (string) (string) 5694 5694 - if len("issue") > 1000000 { 5695 5695 - return xerrors.Errorf("Value in field \"issue\" was too long") 5899 5899 + // t.LexiconTypeID (string) (string) 5900 5900 + if len("$type") > 1000000 { 5901 5901 + return xerrors.Errorf("Value in field \"$type\" was too long") 5696 5902 } 5697 5903 5698 5698 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil { 5904 5904 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 5699 5905 return err 5700 5906 } 5701 5701 - if _, err := cw.WriteString(string("issue")); err != nil { 5907 5907 + if _, err := cw.WriteString(string("$type")); err != nil { 5702 5908 return err 5703 5909 } 5704 5910 5705 5705 - if len(t.Issue) > 1000000 { 5706 5706 - return xerrors.Errorf("Value in field t.Issue was too long") 5707 5707 - } 5708 5708 - 5709 5709 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil { 5911 5911 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 5710 5912 return err 5711 5913 } 5712 5712 - if _, err := cw.WriteString(string(t.Issue)); err != nil { 5914 5914 + if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 5713 5915 return err 5714 5916 } 5715 5917 5716 5716 - // t.State (string) (string) 5717 5717 - if len("state") > 1000000 { 5718 5718 - return xerrors.Errorf("Value in field \"state\" was too long") 5918 5918 + // t.Status (string) (string) 5919 5919 + if len("status") > 1000000 { 5920 5920 + return xerrors.Errorf("Value in field \"status\" was too long") 5719 5921 } 5720 5922 5721 5721 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 5923 5923 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 5722 5924 return err 5723 5925 } 5724 5724 - if _, err := cw.WriteString(string("state")); err != nil { 5926 5926 + if _, err := cw.WriteString(string("status")); err != nil { 5725 5927 return err 5726 5928 } 5727 5929 5728 5728 - if len(t.State) > 1000000 { 5729 5729 - return xerrors.Errorf("Value in field t.State was too long") 5930 5930 + if len(t.Status) > 1000000 { 5931 5931 + return xerrors.Errorf("Value in field t.Status was too long") 5730 5932 } 5731 5933 5732 5732 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 5934 5934 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 5733 5935 return err 5734 5936 } 5735 5735 - if _, err := cw.WriteString(string(t.State)); err != nil { 5937 5937 + if _, err := cw.WriteString(string(t.Status)); err != nil { 5736 5938 return err 5737 5939 } 5738 5940 return nil 5739 5941 } 5740 5942 5741 5741 - func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) { 5742 5742 - *t = RepoIssueState{} 5943 5943 + func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 5944 5944 + *t = RepoPullStatus{} 5743 5945 5744 5946 cr := cbg.NewCborReader(r) 5745 5947 ··· 5758 5960 } 5759 5961 5760 5962 if extra > cbg.MaxLength { 5761 5761 - return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra) 5963 5963 + return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 5762 5964 } 5763 5965 5764 5966 n := extra 5765 5967 5766 5766 - nameBuf := make([]byte, 5) 5968 5968 + nameBuf := make([]byte, 6) 5767 5969 for i := uint64(0); i < n; i++ { 5768 5970 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5769 5971 if err != nil { ··· 5779 5981 } 5780 5982 5781 5983 switch string(nameBuf[:nameLen]) { 5782 5782 - // t.LexiconTypeID (string) (string) 5984 5984 + // t.Pull (string) (string) 5985 5985 + case "pull": 5986 5986 + 5987 5987 + { 5988 5988 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5989 5989 + if err != nil { 5990 5990 + return err 5991 5991 + } 5992 5992 + 5993 5993 + t.Pull = string(sval) 5994 5994 + } 5995 5995 + // t.LexiconTypeID (string) (string) 5783 5996 case "$type": 5784 5997 5785 5998 { ··· 5790 6003 5791 6004 t.LexiconTypeID = string(sval) 5792 6005 } 5793 5793 - // t.Issue (string) (string) 5794 5794 - case "issue": 6006 6006 + // t.Status (string) (string) 6007 6007 + case "status": 5795 6008 5796 6009 { 5797 6010 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 5799 6012 return err 5800 6013 } 5801 6014 5802 5802 - t.Issue = string(sval) 6015 6015 + t.Status = string(sval) 6016 6016 + } 6017 6017 + 6018 6018 + default: 6019 6019 + // Field doesn't exist on this type, so ignore it 6020 6020 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6021 6021 + return err 6022 6022 + } 6023 6023 + } 6024 6024 + } 6025 6025 + 6026 6026 + return nil 6027 6027 + } 6028 6028 + func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 6029 6029 + if t == nil { 6030 6030 + _, err := w.Write(cbg.CborNull) 6031 6031 + return err 6032 6032 + } 6033 6033 + 6034 6034 + cw := cbg.NewCborWriter(w) 6035 6035 + fieldCount := 2 6036 6036 + 6037 6037 + if t.Repo == nil { 6038 6038 + fieldCount-- 6039 6039 + } 6040 6040 + 6041 6041 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6042 6042 + return err 6043 6043 + } 6044 6044 + 6045 6045 + // t.Repo (string) (string) 6046 6046 + if t.Repo != nil { 6047 6047 + 6048 6048 + if len("repo") > 1000000 { 6049 6049 + return xerrors.Errorf("Value in field \"repo\" was too long") 6050 6050 + } 6051 6051 + 6052 6052 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6053 6053 + return err 6054 6054 + } 6055 6055 + if _, err := cw.WriteString(string("repo")); err != nil { 6056 6056 + return err 6057 6057 + } 6058 6058 + 6059 6059 + if t.Repo == nil { 6060 6060 + if _, err := cw.Write(cbg.CborNull); err != nil { 6061 6061 + return err 6062 6062 + } 6063 6063 + } else { 6064 6064 + if len(*t.Repo) > 1000000 { 6065 6065 + return xerrors.Errorf("Value in field t.Repo was too long") 6066 6066 + } 6067 6067 + 6068 6068 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 6069 6069 + return err 6070 6070 + } 6071 6071 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 6072 6072 + return err 6073 6073 + } 6074 6074 + } 6075 6075 + } 6076 6076 + 6077 6077 + // t.Branch (string) (string) 6078 6078 + if len("branch") > 1000000 { 6079 6079 + return xerrors.Errorf("Value in field \"branch\" was too long") 6080 6080 + } 6081 6081 + 6082 6082 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6083 6083 + return err 6084 6084 + } 6085 6085 + if _, err := cw.WriteString(string("branch")); err != nil { 6086 6086 + return err 6087 6087 + } 6088 6088 + 6089 6089 + if len(t.Branch) > 1000000 { 6090 6090 + return xerrors.Errorf("Value in field t.Branch was too long") 6091 6091 + } 6092 6092 + 6093 6093 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6094 6094 + return err 6095 6095 + } 6096 6096 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 6097 6097 + return err 6098 6098 + } 6099 6099 + return nil 6100 6100 + } 6101 6101 + 6102 6102 + func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) { 6103 6103 + *t = RepoPull_Source{} 6104 6104 + 6105 6105 + cr := cbg.NewCborReader(r) 6106 6106 + 6107 6107 + maj, extra, err := cr.ReadHeader() 6108 6108 + if err != nil { 6109 6109 + return err 6110 6110 + } 6111 6111 + defer func() { 6112 6112 + if err == io.EOF { 6113 6113 + err = io.ErrUnexpectedEOF 6114 6114 + } 6115 6115 + }() 6116 6116 + 6117 6117 + if maj != cbg.MajMap { 6118 6118 + return fmt.Errorf("cbor input should be of type map") 6119 6119 + } 6120 6120 + 6121 6121 + if extra > cbg.MaxLength { 6122 6122 + return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra) 6123 6123 + } 6124 6124 + 6125 6125 + n := extra 6126 6126 + 6127 6127 + nameBuf := make([]byte, 6) 6128 6128 + for i := uint64(0); i < n; i++ { 6129 6129 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6130 6130 + if err != nil { 6131 6131 + return err 6132 6132 + } 6133 6133 + 6134 6134 + if !ok { 6135 6135 + // Field doesn't exist on this type, so ignore it 6136 6136 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6137 6137 + return err 5803 6138 } 5804 5804 - // t.State (string) (string) 5805 5805 - case "state": 6139 6139 + continue 6140 6140 + } 6141 6141 + 6142 6142 + switch string(nameBuf[:nameLen]) { 6143 6143 + // t.Repo (string) (string) 6144 6144 + case "repo": 6145 6145 + 6146 6146 + { 6147 6147 + b, err := cr.ReadByte() 6148 6148 + if err != nil { 6149 6149 + return err 6150 6150 + } 6151 6151 + if b != cbg.CborNull[0] { 6152 6152 + if err := cr.UnreadByte(); err != nil { 6153 6153 + return err 6154 6154 + } 6155 6155 + 6156 6156 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6157 6157 + if err != nil { 6158 6158 + return err 6159 6159 + } 6160 6160 + 6161 6161 + t.Repo = (*string)(&sval) 6162 6162 + } 6163 6163 + } 6164 6164 + // t.Branch (string) (string) 6165 6165 + case "branch": 5806 6166 5807 6167 { 5808 6168 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 5810 6170 return err 5811 6171 } 5812 6172 5813 5813 - t.State = string(sval) 6173 6173 + t.Branch = string(sval) 5814 6174 } 5815 6175 5816 6176 default: ··· 6238 6598 6239 6599 return nil 6240 6600 } 6241 6241 - func (t *RepoPullComment) MarshalCBOR(w io.Writer) error { 6601 6601 + func (t *Repo) MarshalCBOR(w io.Writer) error { 6242 6602 if t == nil { 6243 6603 _, err := w.Write(cbg.CborNull) 6244 6604 return err ··· 6247 6607 cw := cbg.NewCborWriter(w) 6248 6608 fieldCount := 7 6249 6609 6250 6250 - if t.CommentId == nil { 6610 6610 + if t.Description == nil { 6251 6611 fieldCount-- 6252 6612 } 6253 6613 6254 6254 - if t.Owner == nil { 6255 6255 - fieldCount-- 6256 6256 - } 6257 6257 - 6258 6258 - if t.Repo == nil { 6614 6614 + if t.Source == nil { 6259 6615 fieldCount-- 6260 6616 } 6261 6617 ··· 6263 6619 return err 6264 6620 } 6265 6621 6266 6266 - // t.Body (string) (string) 6267 6267 - if len("body") > 1000000 { 6268 6268 - return xerrors.Errorf("Value in field \"body\" was too long") 6622 6622 + // t.Knot (string) (string) 6623 6623 + if len("knot") > 1000000 { 6624 6624 + return xerrors.Errorf("Value in field \"knot\" was too long") 6269 6625 } 6270 6626 6271 6271 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 6627 6627 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 6272 6628 return err 6273 6629 } 6274 6274 - if _, err := cw.WriteString(string("body")); err != nil { 6630 6630 + if _, err := cw.WriteString(string("knot")); err != nil { 6275 6631 return err 6276 6632 } 6277 6633 6278 6278 - if len(t.Body) > 1000000 { 6279 6279 - return xerrors.Errorf("Value in field t.Body was too long") 6634 6634 + if len(t.Knot) > 1000000 { 6635 6635 + return xerrors.Errorf("Value in field t.Knot was too long") 6280 6636 } 6281 6637 6282 6282 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 6638 6638 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 6283 6639 return err 6284 6640 } 6285 6285 - if _, err := cw.WriteString(string(t.Body)); err != nil { 6641 6641 + if _, err := cw.WriteString(string(t.Knot)); err != nil { 6286 6642 return err 6287 6643 } 6288 6644 6289 6289 - // t.Pull (string) (string) 6290 6290 - if len("pull") > 1000000 { 6291 6291 - return xerrors.Errorf("Value in field \"pull\" was too long") 6645 6645 + // t.Name (string) (string) 6646 6646 + if len("name") > 1000000 { 6647 6647 + return xerrors.Errorf("Value in field \"name\" was too long") 6292 6648 } 6293 6649 6294 6294 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 6650 6650 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 6295 6651 return err 6296 6652 } 6297 6297 - if _, err := cw.WriteString(string("pull")); err != nil { 6653 6653 + if _, err := cw.WriteString(string("name")); err != nil { 6298 6654 return err 6299 6655 } 6300 6656 6301 6301 - if len(t.Pull) > 1000000 { 6302 6302 - return xerrors.Errorf("Value in field t.Pull was too long") 6657 6657 + if len(t.Name) > 1000000 { 6658 6658 + return xerrors.Errorf("Value in field t.Name was too long") 6303 6659 } 6304 6660 6305 6305 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 6661 6661 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 6306 6662 return err 6307 6663 } 6308 6308 - if _, err := cw.WriteString(string(t.Pull)); err != nil { 6664 6664 + if _, err := cw.WriteString(string(t.Name)); err != nil { 6309 6665 return err 6310 6666 } 6311 6667 6312 6312 - // t.Repo (string) (string) 6313 6313 - if t.Repo != nil { 6314 6314 - 6315 6315 - if len("repo") > 1000000 { 6316 6316 - return xerrors.Errorf("Value in field \"repo\" was too long") 6317 6317 - } 6318 6318 - 6319 6319 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6320 6320 - return err 6321 6321 - } 6322 6322 - if _, err := cw.WriteString(string("repo")); err != nil { 6323 6323 - return err 6324 6324 - } 6325 6325 - 6326 6326 - if t.Repo == nil { 6327 6327 - if _, err := cw.Write(cbg.CborNull); err != nil { 6328 6328 - return err 6329 6329 - } 6330 6330 - } else { 6331 6331 - if len(*t.Repo) > 1000000 { 6332 6332 - return xerrors.Errorf("Value in field t.Repo was too long") 6333 6333 - } 6334 6334 - 6335 6335 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 6336 6336 - return err 6337 6337 - } 6338 6338 - if _, err := cw.WriteString(string(*t.Repo)); err != nil { 6339 6339 - return err 6340 6340 - } 6341 6341 - } 6342 6342 - } 6343 6343 - 6344 6668 // t.LexiconTypeID (string) (string) 6345 6669 if len("$type") > 1000000 { 6346 6670 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 6353 6677 return err 6354 6678 } 6355 6679 6356 6356 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil { 6680 6680 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil { 6357 6681 return err 6358 6682 } 6359 6359 - if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil { 6683 6683 + if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil { 6360 6684 return err 6361 6685 } 6362 6686 6363 6687 // t.Owner (string) (string) 6364 6364 - if t.Owner != nil { 6365 6365 - 6366 6366 - if len("owner") > 1000000 { 6367 6367 - return xerrors.Errorf("Value in field \"owner\" was too long") 6368 6368 - } 6688 6688 + if len("owner") > 1000000 { 6689 6689 + return xerrors.Errorf("Value in field \"owner\" was too long") 6690 6690 + } 6369 6691 6370 6370 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 6371 6371 - return err 6372 6372 - } 6373 6373 - if _, err := cw.WriteString(string("owner")); err != nil { 6374 6374 - return err 6375 6375 - } 6692 6692 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 6693 6693 + return err 6694 6694 + } 6695 6695 + if _, err := cw.WriteString(string("owner")); err != nil { 6696 6696 + return err 6697 6697 + } 6376 6698 6377 6377 - if t.Owner == nil { 6378 6378 - if _, err := cw.Write(cbg.CborNull); err != nil { 6379 6379 - return err 6380 6380 - } 6381 6381 - } else { 6382 6382 - if len(*t.Owner) > 1000000 { 6383 6383 - return xerrors.Errorf("Value in field t.Owner was too long") 6384 6384 - } 6699 6699 + if len(t.Owner) > 1000000 { 6700 6700 + return xerrors.Errorf("Value in field t.Owner was too long") 6701 6701 + } 6385 6702 6386 6386 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Owner))); err != nil { 6387 6387 - return err 6388 6388 - } 6389 6389 - if _, err := cw.WriteString(string(*t.Owner)); err != nil { 6390 6390 - return err 6391 6391 - } 6392 6392 - } 6703 6703 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 6704 6704 + return err 6705 6705 + } 6706 6706 + if _, err := cw.WriteString(string(t.Owner)); err != nil { 6707 6707 + return err 6393 6708 } 6394 6709 6395 6395 - // t.CommentId (int64) (int64) 6396 6396 - if t.CommentId != nil { 6710 6710 + // t.Source (string) (string) 6711 6711 + if t.Source != nil { 6397 6712 6398 6398 - if len("commentId") > 1000000 { 6399 6399 - return xerrors.Errorf("Value in field \"commentId\" was too long") 6713 6713 + if len("source") > 1000000 { 6714 6714 + return xerrors.Errorf("Value in field \"source\" was too long") 6400 6715 } 6401 6716 6402 6402 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil { 6717 6717 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil { 6403 6718 return err 6404 6719 } 6405 6405 - if _, err := cw.WriteString(string("commentId")); err != nil { 6720 6720 + if _, err := cw.WriteString(string("source")); err != nil { 6406 6721 return err 6407 6722 } 6408 6723 6409 6409 - if t.CommentId == nil { 6724 6724 + if t.Source == nil { 6410 6725 if _, err := cw.Write(cbg.CborNull); err != nil { 6411 6726 return err 6412 6727 } 6413 6728 } else { 6414 6414 - if *t.CommentId >= 0 { 6415 6415 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil { 6416 6416 - return err 6417 6417 - } 6418 6418 - } else { 6419 6419 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil { 6420 6420 - return err 6421 6421 - } 6729 6729 + if len(*t.Source) > 1000000 { 6730 6730 + return xerrors.Errorf("Value in field t.Source was too long") 6731 6731 + } 6732 6732 + 6733 6733 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil { 6734 6734 + return err 6735 6735 + } 6736 6736 + if _, err := cw.WriteString(string(*t.Source)); err != nil { 6737 6737 + return err 6422 6738 } 6423 6739 } 6424 6424 - 6425 6740 } 6426 6741 6427 6742 // t.CreatedAt (string) (string) ··· 6446 6761 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6447 6762 return err 6448 6763 } 6764 6764 + 6765 6765 + // t.Description (string) (string) 6766 6766 + if t.Description != nil { 6767 6767 + 6768 6768 + if len("description") > 1000000 { 6769 6769 + return xerrors.Errorf("Value in field \"description\" was too long") 6770 6770 + } 6771 6771 + 6772 6772 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 6773 6773 + return err 6774 6774 + } 6775 6775 + if _, err := cw.WriteString(string("description")); err != nil { 6776 6776 + return err 6777 6777 + } 6778 6778 + 6779 6779 + if t.Description == nil { 6780 6780 + if _, err := cw.Write(cbg.CborNull); err != nil { 6781 6781 + return err 6782 6782 + } 6783 6783 + } else { 6784 6784 + if len(*t.Description) > 1000000 { 6785 6785 + return xerrors.Errorf("Value in field t.Description was too long") 6786 6786 + } 6787 6787 + 6788 6788 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 6789 6789 + return err 6790 6790 + } 6791 6791 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 6792 6792 + return err 6793 6793 + } 6794 6794 + } 6795 6795 + } 6449 6796 return nil 6450 6797 } 6451 6798 6452 6452 - func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) { 6453 6453 - *t = RepoPullComment{} 6799 6799 + func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) { 6800 6800 + *t = Repo{} 6454 6801 6455 6802 cr := cbg.NewCborReader(r) 6456 6803 ··· 6469 6816 } 6470 6817 6471 6818 if extra > cbg.MaxLength { 6472 6472 - return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra) 6819 6819 + return fmt.Errorf("Repo: map struct too large (%d)", extra) 6473 6820 } 6474 6821 6475 6822 n := extra 6476 6823 6477 6477 - nameBuf := make([]byte, 9) 6824 6824 + nameBuf := make([]byte, 11) 6478 6825 for i := uint64(0); i < n; i++ { 6479 6826 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6480 6827 if err != nil { ··· 6490 6837 } 6491 6838 6492 6839 switch string(nameBuf[:nameLen]) { 6493 6493 - // t.Body (string) (string) 6494 6494 - case "body": 6840 6840 + // t.Knot (string) (string) 6841 6841 + case "knot": 6495 6842 6496 6843 { 6497 6844 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6499 6846 return err 6500 6847 } 6501 6848 6502 6502 - t.Body = string(sval) 6849 6849 + t.Knot = string(sval) 6503 6850 } 6504 6504 - // t.Pull (string) (string) 6505 6505 - case "pull": 6851 6851 + // t.Name (string) (string) 6852 6852 + case "name": 6506 6853 6507 6854 { 6508 6855 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6510 6857 return err 6511 6858 } 6512 6859 6513 6513 - t.Pull = string(sval) 6860 6860 + t.Name = string(sval) 6514 6861 } 6515 6515 - // t.Repo (string) (string) 6516 6516 - case "repo": 6862 6862 + // t.LexiconTypeID (string) (string) 6863 6863 + case "$type": 6517 6864 6518 6865 { 6519 6519 - b, err := cr.ReadByte() 6866 6866 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6520 6867 if err != nil { 6521 6868 return err 6522 6869 } 6523 6523 - if b != cbg.CborNull[0] { 6524 6524 - if err := cr.UnreadByte(); err != nil { 6525 6525 - return err 6526 6526 - } 6527 6870 6528 6528 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6529 6529 - if err != nil { 6530 6530 - return err 6531 6531 - } 6532 6532 - 6533 6533 - t.Repo = (*string)(&sval) 6534 6534 - } 6871 6871 + t.LexiconTypeID = string(sval) 6535 6872 } 6536 6536 - // t.LexiconTypeID (string) (string) 6537 6537 - case "$type": 6873 6873 + // t.Owner (string) (string) 6874 6874 + case "owner": 6538 6875 6539 6876 { 6540 6877 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6542 6879 return err 6543 6880 } 6544 6881 6545 6545 - t.LexiconTypeID = string(sval) 6882 6882 + t.Owner = string(sval) 6546 6883 } 6547 6547 - // t.Owner (string) (string) 6548 6548 - case "owner": 6884 6884 + // t.Source (string) (string) 6885 6885 + case "source": 6549 6886 6550 6887 { 6551 6888 b, err := cr.ReadByte() ··· 6562 6899 return err 6563 6900 } 6564 6901 6565 6565 - t.Owner = (*string)(&sval) 6902 6902 + t.Source = (*string)(&sval) 6566 6903 } 6567 6904 } 6568 6568 - // t.CommentId (int64) (int64) 6569 6569 - case "commentId": 6905 6905 + // t.CreatedAt (string) (string) 6906 6906 + case "createdAt": 6907 6907 + 6570 6908 { 6909 6909 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6910 6910 + if err != nil { 6911 6911 + return err 6912 6912 + } 6571 6913 6914 6914 + t.CreatedAt = string(sval) 6915 6915 + } 6916 6916 + // t.Description (string) (string) 6917 6917 + case "description": 6918 6918 + 6919 6919 + { 6572 6920 b, err := cr.ReadByte() 6573 6921 if err != nil { 6574 6922 return err ··· 6577 6925 if err := cr.UnreadByte(); err != nil { 6578 6926 return err 6579 6927 } 6580 6580 - maj, extra, err := cr.ReadHeader() 6928 6928 + 6929 6929 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6581 6930 if err != nil { 6582 6931 return err 6583 6932 } 6584 6584 - var extraI int64 6585 6585 - switch maj { 6586 6586 - case cbg.MajUnsignedInt: 6587 6587 - extraI = int64(extra) 6588 6588 - if extraI < 0 { 6589 6589 - return fmt.Errorf("int64 positive overflow") 6590 6590 - } 6591 6591 - case cbg.MajNegativeInt: 6592 6592 - extraI = int64(extra) 6593 6593 - if extraI < 0 { 6594 6594 - return fmt.Errorf("int64 negative overflow") 6595 6595 - } 6596 6596 - extraI = -1 - extraI 6597 6597 - default: 6598 6598 - return fmt.Errorf("wrong type for int64 field: %d", maj) 6599 6599 - } 6600 6933 6601 6601 - t.CommentId = (*int64)(&extraI) 6602 6602 - } 6603 6603 - } 6604 6604 - // t.CreatedAt (string) (string) 6605 6605 - case "createdAt": 6606 6606 - 6607 6607 - { 6608 6608 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6609 6609 - if err != nil { 6610 6610 - return err 6934 6934 + t.Description = (*string)(&sval) 6611 6935 } 6612 6612 - 6613 6613 - t.CreatedAt = string(sval) 6614 6936 } 6615 6937 6616 6938 default: ··· 6623 6945 6624 6946 return nil 6625 6947 } 6626 6626 - func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 6948 6948 + func (t *SpindleMember) MarshalCBOR(w io.Writer) error { 6627 6949 if t == nil { 6628 6950 _, err := w.Write(cbg.CborNull) 6629 6951 return err 6630 6952 } 6631 6953 6632 6954 cw := cbg.NewCborWriter(w) 6633 6633 - fieldCount := 2 6955 6955 + fieldCount := 4 6634 6956 6635 6635 - if t.Repo == nil { 6957 6957 + if t.Instance == nil { 6636 6958 fieldCount-- 6637 6959 } 6638 6960 ··· 6640 6962 return err 6641 6963 } 6642 6964 6643 6643 - // t.Repo (string) (string) 6644 6644 - if t.Repo != nil { 6645 6645 - 6646 6646 - if len("repo") > 1000000 { 6647 6647 - return xerrors.Errorf("Value in field \"repo\" was too long") 6648 6648 - } 6649 6649 - 6650 6650 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6651 6651 - return err 6652 6652 - } 6653 6653 - if _, err := cw.WriteString(string("repo")); err != nil { 6654 6654 - return err 6655 6655 - } 6965 6965 + // t.LexiconTypeID (string) (string) 6966 6966 + if len("$type") > 1000000 { 6967 6967 + return xerrors.Errorf("Value in field \"$type\" was too long") 6968 6968 + } 6656 6969 6657 6657 - if t.Repo == nil { 6658 6658 - if _, err := cw.Write(cbg.CborNull); err != nil { 6659 6659 - return err 6660 6660 - } 6661 6661 - } else { 6662 6662 - if len(*t.Repo) > 1000000 { 6663 6663 - return xerrors.Errorf("Value in field t.Repo was too long") 6664 6664 - } 6665 6665 - 6666 6666 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 6667 6667 - return err 6668 6668 - } 6669 6669 - if _, err := cw.WriteString(string(*t.Repo)); err != nil { 6670 6670 - return err 6671 6671 - } 6672 6672 - } 6970 6970 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 6971 6971 + return err 6673 6972 } 6674 6674 - 6675 6675 - // t.Branch (string) (string) 6676 6676 - if len("branch") > 1000000 { 6677 6677 - return xerrors.Errorf("Value in field \"branch\" was too long") 6973 6973 + if _, err := cw.WriteString(string("$type")); err != nil { 6974 6974 + return err 6678 6975 } 6679 6976 6680 6680 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6977 6977 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil { 6681 6978 return err 6682 6979 } 6683 6683 - if _, err := cw.WriteString(string("branch")); err != nil { 6980 6980 + if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil { 6684 6981 return err 6685 6982 } 6686 6983 6687 6687 - if len(t.Branch) > 1000000 { 6688 6688 - return xerrors.Errorf("Value in field t.Branch was too long") 6984 6984 + // t.Subject (string) (string) 6985 6985 + if len("subject") > 1000000 { 6986 6986 + return xerrors.Errorf("Value in field \"subject\" was too long") 6689 6987 } 6690 6988 6691 6691 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6989 6989 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 6692 6990 return err 6693 6991 } 6694 6694 - if _, err := cw.WriteString(string(t.Branch)); err != nil { 6992 6992 + if _, err := cw.WriteString(string("subject")); err != nil { 6695 6993 return err 6696 6994 } 6697 6697 - return nil 6698 6698 - } 6699 6995 6700 6700 - func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) { 6701 6701 - *t = RepoPull_Source{} 6702 6702 - 6703 6703 - cr := cbg.NewCborReader(r) 6996 6996 + if len(t.Subject) > 1000000 { 6997 6997 + return xerrors.Errorf("Value in field t.Subject was too long") 6998 6998 + } 6704 6999 6705 6705 - maj, extra, err := cr.ReadHeader() 6706 6706 - if err != nil { 7000 7000 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 6707 7001 return err 6708 7002 } 6709 6709 - defer func() { 6710 6710 - if err == io.EOF { 6711 6711 - err = io.ErrUnexpectedEOF 6712 6712 - } 6713 6713 - }() 6714 6714 - 6715 6715 - if maj != cbg.MajMap { 6716 6716 - return fmt.Errorf("cbor input should be of type map") 7003 7003 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 7004 7004 + return err 6717 7005 } 6718 7006 6719 6719 - if extra > cbg.MaxLength { 6720 6720 - return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra) 6721 6721 - } 7007 7007 + // t.Instance (string) (string) 7008 7008 + if t.Instance != nil { 6722 7009 6723 6723 - n := extra 7010 7010 + if len("instance") > 1000000 { 7011 7011 + return xerrors.Errorf("Value in field \"instance\" was too long") 7012 7012 + } 6724 7013 6725 6725 - nameBuf := make([]byte, 6) 6726 6726 - for i := uint64(0); i < n; i++ { 6727 6727 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6728 6728 - if err != nil { 7014 7014 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil { 7015 7015 + return err 7016 7016 + } 7017 7017 + if _, err := cw.WriteString(string("instance")); err != nil { 6729 7018 return err 6730 7019 } 6731 7020 6732 6732 - if !ok { 6733 6733 - // Field doesn't exist on this type, so ignore it 6734 6734 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7021 7021 + if t.Instance == nil { 7022 7022 + if _, err := cw.Write(cbg.CborNull); err != nil { 6735 7023 return err 6736 7024 } 6737 6737 - continue 6738 6738 - } 6739 6739 - 6740 6740 - switch string(nameBuf[:nameLen]) { 6741 6741 - // t.Repo (string) (string) 6742 6742 - case "repo": 6743 6743 - 6744 6744 - { 6745 6745 - b, err := cr.ReadByte() 6746 6746 - if err != nil { 6747 6747 - return err 6748 6748 - } 6749 6749 - if b != cbg.CborNull[0] { 6750 6750 - if err := cr.UnreadByte(); err != nil { 6751 6751 - return err 6752 6752 - } 6753 6753 - 6754 6754 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6755 6755 - if err != nil { 6756 6756 - return err 6757 6757 - } 6758 6758 - 6759 6759 - t.Repo = (*string)(&sval) 6760 6760 - } 7025 7025 + } else { 7026 7026 + if len(*t.Instance) > 1000000 { 7027 7027 + return xerrors.Errorf("Value in field t.Instance was too long") 6761 7028 } 6762 6762 - // t.Branch (string) (string) 6763 6763 - case "branch": 6764 7029 6765 6765 - { 6766 6766 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6767 6767 - if err != nil { 6768 6768 - return err 6769 6769 - } 6770 6770 - 6771 6771 - t.Branch = string(sval) 7030 7030 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Instance))); err != nil { 7031 7031 + return err 6772 7032 } 6773 6773 - 6774 6774 - default: 6775 6775 - // Field doesn't exist on this type, so ignore it 6776 6776 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7033 7033 + if _, err := cw.WriteString(string(*t.Instance)); err != nil { 6777 7034 return err 6778 7035 } 6779 7036 } 6780 7037 } 6781 7038 6782 6782 - return nil 6783 6783 - } 6784 6784 - func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error { 6785 6785 - if t == nil { 6786 6786 - _, err := w.Write(cbg.CborNull) 6787 6787 - return err 6788 6788 - } 6789 6789 - 6790 6790 - cw := cbg.NewCborWriter(w) 6791 6791 - 6792 6792 - if _, err := cw.Write([]byte{163}); err != nil { 6793 6793 - return err 6794 6794 - } 6795 6795 - 6796 6796 - // t.Pull (string) (string) 6797 6797 - if len("pull") > 1000000 { 6798 6798 - return xerrors.Errorf("Value in field \"pull\" was too long") 7039 7039 + // t.CreatedAt (string) (string) 7040 7040 + if len("createdAt") > 1000000 { 7041 7041 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 6799 7042 } 6800 7043 6801 6801 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil { 7044 7044 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 6802 7045 return err 6803 7046 } 6804 6804 - if _, err := cw.WriteString(string("pull")); err != nil { 7047 7047 + if _, err := cw.WriteString(string("createdAt")); err != nil { 6805 7048 return err 6806 7049 } 6807 7050 6808 6808 - if len(t.Pull) > 1000000 { 6809 6809 - return xerrors.Errorf("Value in field t.Pull was too long") 7051 7051 + if len(t.CreatedAt) > 1000000 { 7052 7052 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 6810 7053 } 6811 7054 6812 6812 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil { 6813 6813 - return err 6814 6814 - } 6815 6815 - if _, err := cw.WriteString(string(t.Pull)); err != nil { 6816 6816 - return err 6817 6817 - } 6818 6818 - 6819 6819 - // t.LexiconTypeID (string) (string) 6820 6820 - if len("$type") > 1000000 { 6821 6821 - return xerrors.Errorf("Value in field \"$type\" was too long") 6822 6822 - } 6823 6823 - 6824 6824 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 6825 6825 - return err 6826 6826 - } 6827 6827 - if _, err := cw.WriteString(string("$type")); err != nil { 6828 6828 - return err 6829 6829 - } 6830 6830 - 6831 6831 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil { 6832 6832 - return err 6833 6833 - } 6834 6834 - if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil { 6835 6835 - return err 6836 6836 - } 6837 6837 - 6838 6838 - // t.Status (string) (string) 6839 6839 - if len("status") > 1000000 { 6840 6840 - return xerrors.Errorf("Value in field \"status\" was too long") 6841 6841 - } 6842 6842 - 6843 6843 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 6844 6844 - return err 6845 6845 - } 6846 6846 - if _, err := cw.WriteString(string("status")); err != nil { 6847 6847 - return err 6848 6848 - } 6849 6849 - 6850 6850 - if len(t.Status) > 1000000 { 6851 6851 - return xerrors.Errorf("Value in field t.Status was too long") 6852 6852 - } 6853 6853 - 6854 6854 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 7055 7055 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6855 7056 return err 6856 7057 } 6857 6857 - if _, err := cw.WriteString(string(t.Status)); err != nil { 7058 7058 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6858 7059 return err 6859 7060 } 6860 7061 return nil 6861 7062 } 6862 7063 6863 6863 - func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) { 6864 6864 - *t = RepoPullStatus{} 7064 7064 + func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) { 7065 7065 + *t = SpindleMember{} 6865 7066 6866 7067 cr := cbg.NewCborReader(r) 6867 7068 ··· 6880 7081 } 6881 7082 6882 7083 if extra > cbg.MaxLength { 6883 6883 - return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra) 7084 7084 + return fmt.Errorf("SpindleMember: map struct too large (%d)", extra) 6884 7085 } 6885 7086 6886 7087 n := extra 6887 7088 6888 6888 - nameBuf := make([]byte, 6) 7089 7089 + nameBuf := make([]byte, 9) 6889 7090 for i := uint64(0); i < n; i++ { 6890 7091 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6891 7092 if err != nil { ··· 6901 7102 } 6902 7103 6903 7104 switch string(nameBuf[:nameLen]) { 6904 6904 - // t.Pull (string) (string) 6905 6905 - case "pull": 7105 7105 + // t.LexiconTypeID (string) (string) 7106 7106 + case "$type": 6906 7107 6907 7108 { 6908 7109 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6910 7111 return err 6911 7112 } 6912 7113 6913 6913 - t.Pull = string(sval) 7114 7114 + t.LexiconTypeID = string(sval) 6914 7115 } 6915 6915 - // t.LexiconTypeID (string) (string) 6916 6916 - case "$type": 7116 7116 + // t.Subject (string) (string) 7117 7117 + case "subject": 6917 7118 6918 7119 { 6919 7120 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6921 7122 return err 6922 7123 } 6923 7124 6924 6924 - t.LexiconTypeID = string(sval) 7125 7125 + t.Subject = string(sval) 7126 7126 + } 7127 7127 + // t.Instance (string) (string) 7128 7128 + case "instance": 7129 7129 + 7130 7130 + { 7131 7131 + b, err := cr.ReadByte() 7132 7132 + if err != nil { 7133 7133 + return err 7134 7134 + } 7135 7135 + if b != cbg.CborNull[0] { 7136 7136 + if err := cr.UnreadByte(); err != nil { 7137 7137 + return err 7138 7138 + } 7139 7139 + 7140 7140 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7141 7141 + if err != nil { 7142 7142 + return err 7143 7143 + } 7144 7144 + 7145 7145 + t.Instance = (*string)(&sval) 7146 7146 + } 6925 7147 } 6926 6926 - // t.Status (string) (string) 6927 6927 - case "status": 7148 7148 + // t.CreatedAt (string) (string) 7149 7149 + case "createdAt": 6928 7150 6929 7151 { 6930 7152 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6932 7154 return err 6933 7155 } 6934 7156 6935 6935 - t.Status = string(sval) 7157 7157 + t.CreatedAt = string(sval) 6936 7158 } 6937 7159 6938 7160 default:

+25

api/tangled/spindlemember.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.spindle.member 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + SpindleMemberNSID = "sh.tangled.spindle.member" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.spindle.member", &SpindleMember{}) 17 17 + } // 18 18 + // RECORDTYPE: SpindleMember 19 19 + type SpindleMember struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.spindle.member" cborgen:"$type,const=sh.tangled.spindle.member"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 + // instance: spindle instance that the subject is now a member of 23 23 + Instance *string `json:"instance,omitempty" cborgen:"instance,omitempty"` 24 24 + Subject string `json:"subject" cborgen:"subject"` 25 25 + }

+11 -10

cmd/gen.go

··· 16 16 "tangled", 17 17 tangled.ActorProfile{}, 18 18 tangled.FeedStar{}, 19 19 - tangled.GitRefUpdate{}, 20 20 - tangled.GitRefUpdate_Meta{}, 21 21 - tangled.GitRefUpdate_Meta_CommitCount{}, 22 19 tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}, 20 20 + tangled.GitRefUpdate_Meta_CommitCount{}, 21 21 + tangled.GitRefUpdate_Meta{}, 22 22 + tangled.GitRefUpdate{}, 23 23 tangled.GraphFollow{}, 24 24 tangled.KnotMember{}, 25 25 - tangled.Pipeline{}, 26 25 tangled.Pipeline_CloneOpts{}, 27 26 tangled.Pipeline_Dependencies_Elem{}, 27 27 + tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, 28 28 tangled.Pipeline_ManualTriggerData{}, 29 29 - tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, 30 29 tangled.Pipeline_PullRequestTriggerData{}, 31 30 tangled.Pipeline_PushTriggerData{}, 32 31 tangled.Pipeline_Step{}, 33 32 tangled.Pipeline_TriggerMetadata{}, 34 33 tangled.Pipeline_TriggerRepo{}, 34 34 + tangled.Pipeline_Workflow_Environment_Elem{}, 35 35 tangled.Pipeline_Workflow{}, 36 36 - tangled.Pipeline_Workflow_Environment_Elem{}, 36 36 + tangled.Pipeline{}, 37 37 tangled.PublicKey{}, 38 38 - tangled.Repo{}, 39 38 tangled.RepoArtifact{}, 40 40 - tangled.RepoIssue{}, 41 39 tangled.RepoIssueComment{}, 42 40 tangled.RepoIssueState{}, 43 43 - tangled.RepoPull{}, 41 41 + tangled.RepoIssue{}, 44 42 tangled.RepoPullComment{}, 43 43 + tangled.RepoPullStatus{}, 45 44 tangled.RepoPull_Source{}, 46 46 - tangled.RepoPullStatus{}, 45 45 + tangled.RepoPull{}, 46 46 + tangled.Repo{}, 47 47 + tangled.SpindleMember{}, 47 48 ); err != nil { 48 49 panic(err) 49 50 }

+4

cmd/spindle/main.go

··· 1 1 + package main 2 2 + 3 3 + func main() { 4 4 + }

+34

lexicons/spindle/member.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.spindle.member", 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 + "domain", 15 15 + "createdAt" 16 16 + ], 17 17 + "properties": { 18 18 + "subject": { 19 19 + "type": "string", 20 20 + "format": "did" 21 21 + }, 22 22 + "instance": { 23 23 + "type": "string", 24 24 + "description": "spindle instance that the subject is now a member of" 25 25 + }, 26 26 + "createdAt": { 27 27 + "type": "string", 28 28 + "format": "datetime" 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + }