lexicons: pulls: put target repo and branch together in their own object #404

+166 -64

api/tangled/cbor_gen.go

··· 6741 6741 6742 6742 return nil 6743 6743 } 6744 6744 + func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error { 6745 6745 + if t == nil { 6746 6746 + _, err := w.Write(cbg.CborNull) 6747 6747 + return err 6748 6748 + } 6749 6749 + 6750 6750 + cw := cbg.NewCborWriter(w) 6751 6751 + 6752 6752 + if _, err := cw.Write([]byte{162}); err != nil { 6753 6753 + return err 6754 6754 + } 6755 6755 + 6756 6756 + // t.Repo (string) (string) 6757 6757 + if len("repo") > 1000000 { 6758 6758 + return xerrors.Errorf("Value in field \"repo\" was too long") 6759 6759 + } 6760 6760 + 6761 6761 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6762 6762 + return err 6763 6763 + } 6764 6764 + if _, err := cw.WriteString(string("repo")); err != nil { 6765 6765 + return err 6766 6766 + } 6767 6767 + 6768 6768 + if len(t.Repo) > 1000000 { 6769 6769 + return xerrors.Errorf("Value in field t.Repo was too long") 6770 6770 + } 6771 6771 + 6772 6772 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6773 6773 + return err 6774 6774 + } 6775 6775 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 6776 6776 + return err 6777 6777 + } 6778 6778 + 6779 6779 + // t.Branch (string) (string) 6780 6780 + if len("branch") > 1000000 { 6781 6781 + return xerrors.Errorf("Value in field \"branch\" was too long") 6782 6782 + } 6783 6783 + 6784 6784 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6785 6785 + return err 6786 6786 + } 6787 6787 + if _, err := cw.WriteString(string("branch")); err != nil { 6788 6788 + return err 6789 6789 + } 6790 6790 + 6791 6791 + if len(t.Branch) > 1000000 { 6792 6792 + return xerrors.Errorf("Value in field t.Branch was too long") 6793 6793 + } 6794 6794 + 6795 6795 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6796 6796 + return err 6797 6797 + } 6798 6798 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 6799 6799 + return err 6800 6800 + } 6801 6801 + return nil 6802 6802 + } 6803 6803 + 6804 6804 + func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) { 6805 6805 + *t = RepoPull_Target{} 6806 6806 + 6807 6807 + cr := cbg.NewCborReader(r) 6808 6808 + 6809 6809 + maj, extra, err := cr.ReadHeader() 6810 6810 + if err != nil { 6811 6811 + return err 6812 6812 + } 6813 6813 + defer func() { 6814 6814 + if err == io.EOF { 6815 6815 + err = io.ErrUnexpectedEOF 6816 6816 + } 6817 6817 + }() 6818 6818 + 6819 6819 + if maj != cbg.MajMap { 6820 6820 + return fmt.Errorf("cbor input should be of type map") 6821 6821 + } 6822 6822 + 6823 6823 + if extra > cbg.MaxLength { 6824 6824 + return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra) 6825 6825 + } 6826 6826 + 6827 6827 + n := extra 6828 6828 + 6829 6829 + nameBuf := make([]byte, 6) 6830 6830 + for i := uint64(0); i < n; i++ { 6831 6831 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6832 6832 + if err != nil { 6833 6833 + return err 6834 6834 + } 6835 6835 + 6836 6836 + if !ok { 6837 6837 + // Field doesn't exist on this type, so ignore it 6838 6838 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6839 6839 + return err 6840 6840 + } 6841 6841 + continue 6842 6842 + } 6843 6843 + 6844 6844 + switch string(nameBuf[:nameLen]) { 6845 6845 + // t.Repo (string) (string) 6846 6846 + case "repo": 6847 6847 + 6848 6848 + { 6849 6849 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6850 6850 + if err != nil { 6851 6851 + return err 6852 6852 + } 6853 6853 + 6854 6854 + t.Repo = string(sval) 6855 6855 + } 6856 6856 + // t.Branch (string) (string) 6857 6857 + case "branch": 6858 6858 + 6859 6859 + { 6860 6860 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6861 6861 + if err != nil { 6862 6862 + return err 6863 6863 + } 6864 6864 + 6865 6865 + t.Branch = string(sval) 6866 6866 + } 6867 6867 + 6868 6868 + default: 6869 6869 + // Field doesn't exist on this type, so ignore it 6870 6870 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6871 6871 + return err 6872 6872 + } 6873 6873 + } 6874 6874 + } 6875 6875 + 6876 6876 + return nil 6877 6877 + } 6744 6878 func (t *RepoPull) MarshalCBOR(w io.Writer) error { 6745 6879 if t == nil { 6746 6880 _, err := w.Write(cbg.CborNull) ··· 6748 6882 } 6749 6883 6750 6884 cw := cbg.NewCborWriter(w) 6751 6751 - fieldCount := 8 6885 6885 + fieldCount := 7 6752 6886 6753 6887 if t.Body == nil { 6754 6888 fieldCount-- ··· 6878 7012 } 6879 7013 } 6880 7014 6881 6881 - // t.CreatedAt (string) (string) 6882 6882 - if len("createdAt") > 1000000 { 6883 6883 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 7015 7015 + // t.Target (tangled.RepoPull_Target) (struct) 7016 7016 + if len("target") > 1000000 { 7017 7017 + return xerrors.Errorf("Value in field \"target\" was too long") 6884 7018 } 6885 7019 6886 6886 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 7020 7020 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil { 6887 7021 return err 6888 7022 } 6889 6889 - if _, err := cw.WriteString(string("createdAt")); err != nil { 7023 7023 + if _, err := cw.WriteString(string("target")); err != nil { 6890 7024 return err 6891 7025 } 6892 7026 6893 6893 - if len(t.CreatedAt) > 1000000 { 6894 6894 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 6895 6895 - } 6896 6896 - 6897 6897 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6898 6898 - return err 6899 6899 - } 6900 6900 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6901 6901 - return err 6902 6902 - } 6903 6903 - 6904 6904 - // t.TargetRepo (string) (string) 6905 6905 - if len("targetRepo") > 1000000 { 6906 6906 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 6907 6907 - } 6908 6908 - 6909 6909 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 6910 6910 - return err 6911 6911 - } 6912 6912 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 7027 7027 + if err := t.Target.MarshalCBOR(cw); err != nil { 6913 7028 return err 6914 7029 } 6915 7030 6916 6916 - if len(t.TargetRepo) > 1000000 { 6917 6917 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 6918 6918 - } 6919 6919 - 6920 6920 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 6921 6921 - return err 6922 6922 - } 6923 6923 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 6924 6924 - return err 6925 6925 - } 6926 6926 - 6927 6927 - // t.TargetBranch (string) (string) 6928 6928 - if len("targetBranch") > 1000000 { 6929 6929 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 7031 7031 + // t.CreatedAt (string) (string) 7032 7032 + if len("createdAt") > 1000000 { 7033 7033 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 6930 7034 } 6931 7035 6932 6932 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 7036 7036 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 6933 7037 return err 6934 7038 } 6935 6935 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 7039 7039 + if _, err := cw.WriteString(string("createdAt")); err != nil { 6936 7040 return err 6937 7041 } 6938 7042 6939 6939 - if len(t.TargetBranch) > 1000000 { 6940 6940 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 7043 7043 + if len(t.CreatedAt) > 1000000 { 7044 7044 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 6941 7045 } 6942 7046 6943 6943 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 7047 7047 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6944 7048 return err 6945 7049 } 6946 6946 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 7050 7050 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6947 7051 return err 6948 7052 } 6949 7053 return nil ··· 6974 7078 6975 7079 n := extra 6976 7080 6977 6977 - nameBuf := make([]byte, 12) 7081 7081 + nameBuf := make([]byte, 9) 6978 7082 for i := uint64(0); i < n; i++ { 6979 7083 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6980 7084 if err != nil { ··· 7064 7168 } 7065 7169 7066 7170 } 7067 7067 - // t.CreatedAt (string) (string) 7068 7068 - case "createdAt": 7171 7171 + // t.Target (tangled.RepoPull_Target) (struct) 7172 7172 + case "target": 7069 7173 7070 7174 { 7071 7071 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7072 7072 - if err != nil { 7073 7073 - return err 7074 7074 - } 7075 7175 7076 7076 - t.CreatedAt = string(sval) 7077 7077 - } 7078 7078 - // t.TargetRepo (string) (string) 7079 7079 - case "targetRepo": 7080 7080 - 7081 7081 - { 7082 7082 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7176 7176 + b, err := cr.ReadByte() 7083 7177 if err != nil { 7084 7178 return err 7085 7179 } 7180 7180 + if b != cbg.CborNull[0] { 7181 7181 + if err := cr.UnreadByte(); err != nil { 7182 7182 + return err 7183 7183 + } 7184 7184 + t.Target = new(RepoPull_Target) 7185 7185 + if err := t.Target.UnmarshalCBOR(cr); err != nil { 7186 7186 + return xerrors.Errorf("unmarshaling t.Target pointer: %w", err) 7187 7187 + } 7188 7188 + } 7086 7189 7087 7087 - t.TargetRepo = string(sval) 7088 7190 } 7089 7089 - // t.TargetBranch (string) (string) 7090 7090 - case "targetBranch": 7191 7191 + // t.CreatedAt (string) (string) 7192 7192 + case "createdAt": 7091 7193 7092 7194 { 7093 7195 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 7095 7197 return err 7096 7198 } 7097 7199 7098 7098 - t.TargetBranch = string(sval) 7200 7200 + t.CreatedAt = string(sval) 7099 7201 } 7100 7202 7101 7203 default:

+7 -2

api/tangled/repopull.go

··· 22 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 Patch string `json:"patch" cborgen:"patch"` 24 24 Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 25 25 - TargetBranch string `json:"targetBranch" cborgen:"targetBranch"` 26 26 - TargetRepo string `json:"targetRepo" cborgen:"targetRepo"` 25 25 + Target *RepoPull_Target `json:"target" cborgen:"target"` 27 26 Title string `json:"title" cborgen:"title"` 28 27 } 29 28 ··· 33 32 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 34 33 Sha string `json:"sha" cborgen:"sha"` 35 34 } 35 35 + 36 36 + // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 37 37 + type RepoPull_Target struct { 38 38 + Branch string `json:"branch" cborgen:"branch"` 39 39 + Repo string `json:"repo" cborgen:"repo"` 40 40 + }

+4 -2

appview/db/pulls.go

··· 94 94 Title: p.Title, 95 95 Body: &p.Body, 96 96 CreatedAt: p.Created.Format(time.RFC3339), 97 97 - TargetRepo: p.RepoAt.String(), 98 98 - TargetBranch: p.TargetBranch, 97 97 + Target: &tangled.RepoPull_Target{ 98 98 + Repo: p.RepoAt.String(), 99 99 + Branch: p.TargetBranch, 100 100 + }, 99 101 Patch: p.LatestPatch(), 100 102 Source: source, 101 103 }

+8 -4

appview/pulls/pulls.go

··· 1091 1091 Record: &lexutil.LexiconTypeDecoder{ 1092 1092 Val: &tangled.RepoPull{ 1093 1093 Title: title, 1094 1094 - TargetRepo: string(f.RepoAt), 1095 1095 - TargetBranch: targetBranch, 1094 1094 + Target: &tangled.RepoPull_Target{ 1095 1095 + Repo: string(f.RepoAt), 1096 1096 + Branch: targetBranch, 1097 1097 + }, 1096 1098 Patch: patch, 1097 1099 Source: recordPullSource, 1098 1100 }, ··· 1652 1654 Record: &lexutil.LexiconTypeDecoder{ 1653 1655 Val: &tangled.RepoPull{ 1654 1656 Title: pull.Title, 1655 1655 - TargetRepo: string(f.RepoAt), 1656 1656 - TargetBranch: pull.TargetBranch, 1657 1657 + Target: &tangled.RepoPull_Target{ 1658 1658 + Repo: string(f.RepoAt), 1659 1659 + Branch: pull.TargetBranch, 1660 1660 + }, 1657 1661 Patch: patch, // new patch 1658 1662 Source: recordPullSource, 1659 1663 },

+1

cmd/gen.go

··· 43 43 tangled.RepoIssue{}, 44 44 tangled.RepoIssueComment{}, 45 45 tangled.RepoIssueState{}, 46 46 + tangled.RepoPull_Target{}, 46 47 tangled.RepoPull{}, 47 48 tangled.RepoPullComment{}, 48 49 tangled.RepoPull_Source{},

+20 -8

lexicons/pulls/pull.json

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "targetRepo", 14 14 - "targetBranch", 13 13 + "target", 15 14 "title", 16 15 "patch", 17 16 "createdAt" 18 17 ], 19 18 "properties": { 20 20 - "targetRepo": { 21 21 - "type": "string", 22 22 - "format": "at-uri" 23 23 - }, 24 24 - "targetBranch": { 25 25 - "type": "string" 19 19 + "target": { 20 20 + "type": "ref", 21 21 + "ref": "#target" 26 22 }, 27 23 "title": { 28 24 "type": "string" ··· 44 40 } 45 41 } 46 42 }, 43 43 + "target": { 44 44 + "type": "object", 45 45 + "required": [ 46 46 + "repo", 47 47 + "branch" 48 48 + ], 49 49 + "properties": { 50 50 + "repo": { 51 51 + "type": "string", 52 52 + "format": "at-uri" 53 53 + }, 54 54 + "branch": { 55 55 + "type": "string" 56 56 + } 57 57 + } 58 58 + }, 47 59 "source": { 48 60 "type": "object", 49 61 "required": [