commit 4b332cd3b1a0204362e604ef22f54d4f7ffc9b9c · dunkirk.sh/core

+1096 -2

api/tangled/cbor_gen.go

···

       1753
       1753
        
       	}

     

       1754
       1754
        
       

     

       1755
       1755
        
       	cw := cbg.NewCborWriter(w)

     

       1756
       1756
       -
       	fieldCount := 5

     

       1756
       1756
       +
       	fieldCount := 6

     

       1757
       1757
        
       

     

       1758
       1758
        
       	if t.AddedAt == nil {

     

       1759
       1759
       +
       		fieldCount--

     

       1760
       1760
       +
       	}

     

       1761
       1761
       +
       

     

       1762
       1762
       +
       	if t.Description == nil {

     

       1759
       1763
        
       		fieldCount--

     

       1760
       1764
        
       	}

     

       1761
       1765
        
       

     
···

       1882
       1886
        
       			}

     

       1883
       1887
        
       		}

     

       1884
       1888
        
       	}

     

       1889
       1889
       +
       

     

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

     

       1891
       1891
       +
       	if t.Description != nil {

     

       1892
       1892
       +
       

     

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

     

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

     

       1895
       1895
       +
       		}

     

       1896
       1896
       +
       

     

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

     

       1898
       1898
       +
       			return err

     

       1899
       1899
       +
       		}

     

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

     

       1901
       1901
       +
       			return err

     

       1902
       1902
       +
       		}

     

       1903
       1903
       +
       

     

       1904
       1904
       +
       		if t.Description == nil {

     

       1905
       1905
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       1906
       1906
       +
       				return err

     

       1907
       1907
       +
       			}

     

       1908
       1908
       +
       		} else {

     

       1909
       1909
       +
       			if len(*t.Description) > 1000000 {

     

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

     

       1911
       1911
       +
       			}

     

       1912
       1912
       +
       

     

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

     

       1914
       1914
       +
       				return err

     

       1915
       1915
       +
       			}

     

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

     

       1917
       1917
       +
       				return err

     

       1918
       1918
       +
       			}

     

       1919
       1919
       +
       		}

     

       1920
       1920
       +
       	}

     

       1885
       1921
        
       	return nil

     

       1886
       1922
        
       }

     

       1887
       1923
        
       

     
···

       1910
       1946
        
       

     

       1911
       1947
        
       	n := extra

     

       1912
       1948
        
       

     

       1913
       1913
       -
       	nameBuf := make([]byte, 7)

     

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

     

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

     

       1915
       1951
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       1916
       1952
        
       		if err != nil {

     
···

       1989
       2025
        
       					}

     

       1990
       2026
        
       

     

       1991
       2027
        
       					t.AddedAt = (*string)(&sval)

     

       2028
       2028
       +
       				}

     

       2029
       2029
       +
       			}

     

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

     

       2031
       2031
       +
       		case "description":

     

       2032
       2032
       +
       

     

       2033
       2033
       +
       			{

     

       2034
       2034
       +
       				b, err := cr.ReadByte()

     

       2035
       2035
       +
       				if err != nil {

     

       2036
       2036
       +
       					return err

     

       2037
       2037
       +
       				}

     

       2038
       2038
       +
       				if b != cbg.CborNull[0] {

     

       2039
       2039
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2040
       2040
       +
       						return err

     

       2041
       2041
       +
       					}

     

       2042
       2042
       +
       

     

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

     

       2044
       2044
       +
       					if err != nil {

     

       2045
       2045
       +
       						return err

     

       2046
       2046
       +
       					}

     

       2047
       2047
       +
       

     

       2048
       2048
       +
       					t.Description = (*string)(&sval)

     

       2049
       2049
       +
       				}

     

       2050
       2050
       +
       			}

     

       2051
       2051
       +
       

     

       2052
       2052
       +
       		default:

     

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

     

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

     

       2055
       2055
       +
       				return err

     

       2056
       2056
       +
       			}

     

       2057
       2057
       +
       		}

     

       2058
       2058
       +
       	}

     

       2059
       2059
       +
       

     

       2060
       2060
       +
       	return nil

     

       2061
       2061
       +
       }

     

       2062
       2062
       +
       func (t *RepoPullPatch) MarshalCBOR(w io.Writer) error {

     

       2063
       2063
       +
       	if t == nil {

     

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

     

       2065
       2065
       +
       		return err

     

       2066
       2066
       +
       	}

     

       2067
       2067
       +
       

     

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

     

       2069
       2069
       +
       	fieldCount := 8

     

       2070
       2070
       +
       

     

       2071
       2071
       +
       	if t.Body == nil {

     

       2072
       2072
       +
       		fieldCount--

     

       2073
       2073
       +
       	}

     

       2074
       2074
       +
       

     

       2075
       2075
       +
       	if t.CreatedAt == nil {

     

       2076
       2076
       +
       		fieldCount--

     

       2077
       2077
       +
       	}

     

       2078
       2078
       +
       

     

       2079
       2079
       +
       	if t.SourceRepo == nil {

     

       2080
       2080
       +
       		fieldCount--

     

       2081
       2081
       +
       	}

     

       2082
       2082
       +
       

     

       2083
       2083
       +
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       2084
       2084
       +
       		return err

     

       2085
       2085
       +
       	}

     

       2086
       2086
       +
       

     

       2087
       2087
       +
       	// t.Body (string) (string)

     

       2088
       2088
       +
       	if t.Body != nil {

     

       2089
       2089
       +
       

     

       2090
       2090
       +
       		if len("body") > 1000000 {

     

       2091
       2091
       +
       			return xerrors.Errorf("Value in field \"body\" was too long")

     

       2092
       2092
       +
       		}

     

       2093
       2093
       +
       

     

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

     

       2095
       2095
       +
       			return err

     

       2096
       2096
       +
       		}

     

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

     

       2098
       2098
       +
       			return err

     

       2099
       2099
       +
       		}

     

       2100
       2100
       +
       

     

       2101
       2101
       +
       		if t.Body == nil {

     

       2102
       2102
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2103
       2103
       +
       				return err

     

       2104
       2104
       +
       			}

     

       2105
       2105
       +
       		} else {

     

       2106
       2106
       +
       			if len(*t.Body) > 1000000 {

     

       2107
       2107
       +
       				return xerrors.Errorf("Value in field t.Body was too long")

     

       2108
       2108
       +
       			}

     

       2109
       2109
       +
       

     

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

     

       2111
       2111
       +
       				return err

     

       2112
       2112
       +
       			}

     

       2113
       2113
       +
       			if _, err := cw.WriteString(string(*t.Body)); err != nil {

     

       2114
       2114
       +
       				return err

     

       2115
       2115
       +
       			}

     

       2116
       2116
       +
       		}

     

       2117
       2117
       +
       	}

     

       2118
       2118
       +
       

     

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

     

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

     

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

     

       2122
       2122
       +
       	}

     

       2123
       2123
       +
       

     

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

     

       2125
       2125
       +
       		return err

     

       2126
       2126
       +
       	}

     

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

     

       2128
       2128
       +
       		return err

     

       2129
       2129
       +
       	}

     

       2130
       2130
       +
       

     

       2131
       2131
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.patch"))); err != nil {

     

       2132
       2132
       +
       		return err

     

       2133
       2133
       +
       	}

     

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

     

       2135
       2135
       +
       		return err

     

       2136
       2136
       +
       	}

     

       2137
       2137
       +
       

     

       2138
       2138
       +
       	// t.Patch (string) (string)

     

       2139
       2139
       +
       	if len("patch") > 1000000 {

     

       2140
       2140
       +
       		return xerrors.Errorf("Value in field \"patch\" was too long")

     

       2141
       2141
       +
       	}

     

       2142
       2142
       +
       

     

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

     

       2144
       2144
       +
       		return err

     

       2145
       2145
       +
       	}

     

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

     

       2147
       2147
       +
       		return err

     

       2148
       2148
       +
       	}

     

       2149
       2149
       +
       

     

       2150
       2150
       +
       	if len(t.Patch) > 1000000 {

     

       2151
       2151
       +
       		return xerrors.Errorf("Value in field t.Patch was too long")

     

       2152
       2152
       +
       	}

     

       2153
       2153
       +
       

     

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

     

       2155
       2155
       +
       		return err

     

       2156
       2156
       +
       	}

     

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

     

       2158
       2158
       +
       		return err

     

       2159
       2159
       +
       	}

     

       2160
       2160
       +
       

     

       2161
       2161
       +
       	// t.Title (string) (string)

     

       2162
       2162
       +
       	if len("title") > 1000000 {

     

       2163
       2163
       +
       		return xerrors.Errorf("Value in field \"title\" was too long")

     

       2164
       2164
       +
       	}

     

       2165
       2165
       +
       

     

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

     

       2167
       2167
       +
       		return err

     

       2168
       2168
       +
       	}

     

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

     

       2170
       2170
       +
       		return err

     

       2171
       2171
       +
       	}

     

       2172
       2172
       +
       

     

       2173
       2173
       +
       	if len(t.Title) > 1000000 {

     

       2174
       2174
       +
       		return xerrors.Errorf("Value in field t.Title was too long")

     

       2175
       2175
       +
       	}

     

       2176
       2176
       +
       

     

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

     

       2178
       2178
       +
       		return err

     

       2179
       2179
       +
       	}

     

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

     

       2181
       2181
       +
       		return err

     

       2182
       2182
       +
       	}

     

       2183
       2183
       +
       

     

       2184
       2184
       +
       	// t.PullId (int64) (int64)

     

       2185
       2185
       +
       	if len("pullId") > 1000000 {

     

       2186
       2186
       +
       		return xerrors.Errorf("Value in field \"pullId\" was too long")

     

       2187
       2187
       +
       	}

     

       2188
       2188
       +
       

     

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

     

       2190
       2190
       +
       		return err

     

       2191
       2191
       +
       	}

     

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

     

       2193
       2193
       +
       		return err

     

       2194
       2194
       +
       	}

     

       2195
       2195
       +
       

     

       2196
       2196
       +
       	if t.PullId >= 0 {

     

       2197
       2197
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {

     

       2198
       2198
       +
       			return err

     

       2199
       2199
       +
       		}

     

       2200
       2200
       +
       	} else {

     

       2201
       2201
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {

     

       2202
       2202
       +
       			return err

     

       2203
       2203
       +
       		}

     

       2204
       2204
       +
       	}

     

       2205
       2205
       +
       

     

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

     

       2207
       2207
       +
       	if t.CreatedAt != nil {

     

       2208
       2208
       +
       

     

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

     

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

     

       2211
       2211
       +
       		}

     

       2212
       2212
       +
       

     

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

     

       2214
       2214
       +
       			return err

     

       2215
       2215
       +
       		}

     

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

     

       2217
       2217
       +
       			return err

     

       2218
       2218
       +
       		}

     

       2219
       2219
       +
       

     

       2220
       2220
       +
       		if t.CreatedAt == nil {

     

       2221
       2221
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2222
       2222
       +
       				return err

     

       2223
       2223
       +
       			}

     

       2224
       2224
       +
       		} else {

     

       2225
       2225
       +
       			if len(*t.CreatedAt) > 1000000 {

     

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

     

       2227
       2227
       +
       			}

     

       2228
       2228
       +
       

     

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

     

       2230
       2230
       +
       				return err

     

       2231
       2231
       +
       			}

     

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

     

       2233
       2233
       +
       				return err

     

       2234
       2234
       +
       			}

     

       2235
       2235
       +
       		}

     

       2236
       2236
       +
       	}

     

       2237
       2237
       +
       

     

       2238
       2238
       +
       	// t.SourceRepo (string) (string)

     

       2239
       2239
       +
       	if t.SourceRepo != nil {

     

       2240
       2240
       +
       

     

       2241
       2241
       +
       		if len("sourceRepo") > 1000000 {

     

       2242
       2242
       +
       			return xerrors.Errorf("Value in field \"sourceRepo\" was too long")

     

       2243
       2243
       +
       		}

     

       2244
       2244
       +
       

     

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

     

       2246
       2246
       +
       			return err

     

       2247
       2247
       +
       		}

     

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

     

       2249
       2249
       +
       			return err

     

       2250
       2250
       +
       		}

     

       2251
       2251
       +
       

     

       2252
       2252
       +
       		if t.SourceRepo == nil {

     

       2253
       2253
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2254
       2254
       +
       				return err

     

       2255
       2255
       +
       			}

     

       2256
       2256
       +
       		} else {

     

       2257
       2257
       +
       			if len(*t.SourceRepo) > 1000000 {

     

       2258
       2258
       +
       				return xerrors.Errorf("Value in field t.SourceRepo was too long")

     

       2259
       2259
       +
       			}

     

       2260
       2260
       +
       

     

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

     

       2262
       2262
       +
       				return err

     

       2263
       2263
       +
       			}

     

       2264
       2264
       +
       			if _, err := cw.WriteString(string(*t.SourceRepo)); err != nil {

     

       2265
       2265
       +
       				return err

     

       2266
       2266
       +
       			}

     

       2267
       2267
       +
       		}

     

       2268
       2268
       +
       	}

     

       2269
       2269
       +
       

     

       2270
       2270
       +
       	// t.TargetRepo (string) (string)

     

       2271
       2271
       +
       	if len("targetRepo") > 1000000 {

     

       2272
       2272
       +
       		return xerrors.Errorf("Value in field \"targetRepo\" was too long")

     

       2273
       2273
       +
       	}

     

       2274
       2274
       +
       

     

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

     

       2276
       2276
       +
       		return err

     

       2277
       2277
       +
       	}

     

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

     

       2279
       2279
       +
       		return err

     

       2280
       2280
       +
       	}

     

       2281
       2281
       +
       

     

       2282
       2282
       +
       	if len(t.TargetRepo) > 1000000 {

     

       2283
       2283
       +
       		return xerrors.Errorf("Value in field t.TargetRepo was too long")

     

       2284
       2284
       +
       	}

     

       2285
       2285
       +
       

     

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

     

       2287
       2287
       +
       		return err

     

       2288
       2288
       +
       	}

     

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

     

       2290
       2290
       +
       		return err

     

       2291
       2291
       +
       	}

     

       2292
       2292
       +
       	return nil

     

       2293
       2293
       +
       }

     

       2294
       2294
       +
       

     

       2295
       2295
       +
       func (t *RepoPullPatch) UnmarshalCBOR(r io.Reader) (err error) {

     

       2296
       2296
       +
       	*t = RepoPullPatch{}

     

       2297
       2297
       +
       

     

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

     

       2299
       2299
       +
       

     

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

     

       2301
       2301
       +
       	if err != nil {

     

       2302
       2302
       +
       		return err

     

       2303
       2303
       +
       	}

     

       2304
       2304
       +
       	defer func() {

     

       2305
       2305
       +
       		if err == io.EOF {

     

       2306
       2306
       +
       			err = io.ErrUnexpectedEOF

     

       2307
       2307
       +
       		}

     

       2308
       2308
       +
       	}()

     

       2309
       2309
       +
       

     

       2310
       2310
       +
       	if maj != cbg.MajMap {

     

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

     

       2312
       2312
       +
       	}

     

       2313
       2313
       +
       

     

       2314
       2314
       +
       	if extra > cbg.MaxLength {

     

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

     

       2316
       2316
       +
       	}

     

       2317
       2317
       +
       

     

       2318
       2318
       +
       	n := extra

     

       2319
       2319
       +
       

     

       2320
       2320
       +
       	nameBuf := make([]byte, 10)

     

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

     

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

     

       2323
       2323
       +
       		if err != nil {

     

       2324
       2324
       +
       			return err

     

       2325
       2325
       +
       		}

     

       2326
       2326
       +
       

     

       2327
       2327
       +
       		if !ok {

     

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

     

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

     

       2330
       2330
       +
       				return err

     

       2331
       2331
       +
       			}

     

       2332
       2332
       +
       			continue

     

       2333
       2333
       +
       		}

     

       2334
       2334
       +
       

     

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

     

       2336
       2336
       +
       		// t.Body (string) (string)

     

       2337
       2337
       +
       		case "body":

     

       2338
       2338
       +
       

     

       2339
       2339
       +
       			{

     

       2340
       2340
       +
       				b, err := cr.ReadByte()

     

       2341
       2341
       +
       				if err != nil {

     

       2342
       2342
       +
       					return err

     

       2343
       2343
       +
       				}

     

       2344
       2344
       +
       				if b != cbg.CborNull[0] {

     

       2345
       2345
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2346
       2346
       +
       						return err

     

       2347
       2347
       +
       					}

     

       2348
       2348
       +
       

     

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

     

       2350
       2350
       +
       					if err != nil {

     

       2351
       2351
       +
       						return err

     

       2352
       2352
       +
       					}

     

       2353
       2353
       +
       

     

       2354
       2354
       +
       					t.Body = (*string)(&sval)

     

       2355
       2355
       +
       				}

     

       2356
       2356
       +
       			}

     

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

     

       2358
       2358
       +
       		case "$type":

     

       2359
       2359
       +
       

     

       2360
       2360
       +
       			{

     

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

     

       2362
       2362
       +
       				if err != nil {

     

       2363
       2363
       +
       					return err

     

       2364
       2364
       +
       				}

     

       2365
       2365
       +
       

     

       2366
       2366
       +
       				t.LexiconTypeID = string(sval)

     

       2367
       2367
       +
       			}

     

       2368
       2368
       +
       			// t.Patch (string) (string)

     

       2369
       2369
       +
       		case "patch":

     

       2370
       2370
       +
       

     

       2371
       2371
       +
       			{

     

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

     

       2373
       2373
       +
       				if err != nil {

     

       2374
       2374
       +
       					return err

     

       2375
       2375
       +
       				}

     

       2376
       2376
       +
       

     

       2377
       2377
       +
       				t.Patch = string(sval)

     

       2378
       2378
       +
       			}

     

       2379
       2379
       +
       			// t.Title (string) (string)

     

       2380
       2380
       +
       		case "title":

     

       2381
       2381
       +
       

     

       2382
       2382
       +
       			{

     

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

     

       2384
       2384
       +
       				if err != nil {

     

       2385
       2385
       +
       					return err

     

       2386
       2386
       +
       				}

     

       2387
       2387
       +
       

     

       2388
       2388
       +
       				t.Title = string(sval)

     

       2389
       2389
       +
       			}

     

       2390
       2390
       +
       			// t.PullId (int64) (int64)

     

       2391
       2391
       +
       		case "pullId":

     

       2392
       2392
       +
       			{

     

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

     

       2394
       2394
       +
       				if err != nil {

     

       2395
       2395
       +
       					return err

     

       2396
       2396
       +
       				}

     

       2397
       2397
       +
       				var extraI int64

     

       2398
       2398
       +
       				switch maj {

     

       2399
       2399
       +
       				case cbg.MajUnsignedInt:

     

       2400
       2400
       +
       					extraI = int64(extra)

     

       2401
       2401
       +
       					if extraI < 0 {

     

       2402
       2402
       +
       						return fmt.Errorf("int64 positive overflow")

     

       2403
       2403
       +
       					}

     

       2404
       2404
       +
       				case cbg.MajNegativeInt:

     

       2405
       2405
       +
       					extraI = int64(extra)

     

       2406
       2406
       +
       					if extraI < 0 {

     

       2407
       2407
       +
       						return fmt.Errorf("int64 negative overflow")

     

       2408
       2408
       +
       					}

     

       2409
       2409
       +
       					extraI = -1 - extraI

     

       2410
       2410
       +
       				default:

     

       2411
       2411
       +
       					return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       2412
       2412
       +
       				}

     

       2413
       2413
       +
       

     

       2414
       2414
       +
       				t.PullId = int64(extraI)

     

       2415
       2415
       +
       			}

     

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

     

       2417
       2417
       +
       		case "createdAt":

     

       2418
       2418
       +
       

     

       2419
       2419
       +
       			{

     

       2420
       2420
       +
       				b, err := cr.ReadByte()

     

       2421
       2421
       +
       				if err != nil {

     

       2422
       2422
       +
       					return err

     

       2423
       2423
       +
       				}

     

       2424
       2424
       +
       				if b != cbg.CborNull[0] {

     

       2425
       2425
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2426
       2426
       +
       						return err

     

       2427
       2427
       +
       					}

     

       2428
       2428
       +
       

     

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

     

       2430
       2430
       +
       					if err != nil {

     

       2431
       2431
       +
       						return err

     

       2432
       2432
       +
       					}

     

       2433
       2433
       +
       

     

       2434
       2434
       +
       					t.CreatedAt = (*string)(&sval)

     

       2435
       2435
       +
       				}

     

       2436
       2436
       +
       			}

     

       2437
       2437
       +
       			// t.SourceRepo (string) (string)

     

       2438
       2438
       +
       		case "sourceRepo":

     

       2439
       2439
       +
       

     

       2440
       2440
       +
       			{

     

       2441
       2441
       +
       				b, err := cr.ReadByte()

     

       2442
       2442
       +
       				if err != nil {

     

       2443
       2443
       +
       					return err

     

       2444
       2444
       +
       				}

     

       2445
       2445
       +
       				if b != cbg.CborNull[0] {

     

       2446
       2446
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2447
       2447
       +
       						return err

     

       2448
       2448
       +
       					}

     

       2449
       2449
       +
       

     

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

     

       2451
       2451
       +
       					if err != nil {

     

       2452
       2452
       +
       						return err

     

       2453
       2453
       +
       					}

     

       2454
       2454
       +
       

     

       2455
       2455
       +
       					t.SourceRepo = (*string)(&sval)

     

       2456
       2456
       +
       				}

     

       2457
       2457
       +
       			}

     

       2458
       2458
       +
       			// t.TargetRepo (string) (string)

     

       2459
       2459
       +
       		case "targetRepo":

     

       2460
       2460
       +
       

     

       2461
       2461
       +
       			{

     

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

     

       2463
       2463
       +
       				if err != nil {

     

       2464
       2464
       +
       					return err

     

       2465
       2465
       +
       				}

     

       2466
       2466
       +
       

     

       2467
       2467
       +
       				t.TargetRepo = string(sval)

     

       2468
       2468
       +
       			}

     

       2469
       2469
       +
       

     

       2470
       2470
       +
       		default:

     

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

     

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

     

       2473
       2473
       +
       				return err

     

       2474
       2474
       +
       			}

     

       2475
       2475
       +
       		}

     

       2476
       2476
       +
       	}

     

       2477
       2477
       +
       

     

       2478
       2478
       +
       	return nil

     

       2479
       2479
       +
       }

     

       2480
       2480
       +
       func (t *RepoPullState) MarshalCBOR(w io.Writer) error {

     

       2481
       2481
       +
       	if t == nil {

     

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

     

       2483
       2483
       +
       		return err

     

       2484
       2484
       +
       	}

     

       2485
       2485
       +
       

     

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

     

       2487
       2487
       +
       	fieldCount := 3

     

       2488
       2488
       +
       

     

       2489
       2489
       +
       	if t.State == nil {

     

       2490
       2490
       +
       		fieldCount--

     

       2491
       2491
       +
       	}

     

       2492
       2492
       +
       

     

       2493
       2493
       +
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       2494
       2494
       +
       		return err

     

       2495
       2495
       +
       	}

     

       2496
       2496
       +
       

     

       2497
       2497
       +
       	// t.Pull (string) (string)

     

       2498
       2498
       +
       	if len("pull") > 1000000 {

     

       2499
       2499
       +
       		return xerrors.Errorf("Value in field \"pull\" was too long")

     

       2500
       2500
       +
       	}

     

       2501
       2501
       +
       

     

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

     

       2503
       2503
       +
       		return err

     

       2504
       2504
       +
       	}

     

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

     

       2506
       2506
       +
       		return err

     

       2507
       2507
       +
       	}

     

       2508
       2508
       +
       

     

       2509
       2509
       +
       	if len(t.Pull) > 1000000 {

     

       2510
       2510
       +
       		return xerrors.Errorf("Value in field t.Pull was too long")

     

       2511
       2511
       +
       	}

     

       2512
       2512
       +
       

     

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

     

       2514
       2514
       +
       		return err

     

       2515
       2515
       +
       	}

     

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

     

       2517
       2517
       +
       		return err

     

       2518
       2518
       +
       	}

     

       2519
       2519
       +
       

     

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

     

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

     

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

     

       2523
       2523
       +
       	}

     

       2524
       2524
       +
       

     

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

     

       2526
       2526
       +
       		return err

     

       2527
       2527
       +
       	}

     

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

     

       2529
       2529
       +
       		return err

     

       2530
       2530
       +
       	}

     

       2531
       2531
       +
       

     

       2532
       2532
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.state"))); err != nil {

     

       2533
       2533
       +
       		return err

     

       2534
       2534
       +
       	}

     

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

     

       2536
       2536
       +
       		return err

     

       2537
       2537
       +
       	}

     

       2538
       2538
       +
       

     

       2539
       2539
       +
       	// t.State (string) (string)

     

       2540
       2540
       +
       	if t.State != nil {

     

       2541
       2541
       +
       

     

       2542
       2542
       +
       		if len("state") > 1000000 {

     

       2543
       2543
       +
       			return xerrors.Errorf("Value in field \"state\" was too long")

     

       2544
       2544
       +
       		}

     

       2545
       2545
       +
       

     

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

     

       2547
       2547
       +
       			return err

     

       2548
       2548
       +
       		}

     

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

     

       2550
       2550
       +
       			return err

     

       2551
       2551
       +
       		}

     

       2552
       2552
       +
       

     

       2553
       2553
       +
       		if t.State == nil {

     

       2554
       2554
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2555
       2555
       +
       				return err

     

       2556
       2556
       +
       			}

     

       2557
       2557
       +
       		} else {

     

       2558
       2558
       +
       			if len(*t.State) > 1000000 {

     

       2559
       2559
       +
       				return xerrors.Errorf("Value in field t.State was too long")

     

       2560
       2560
       +
       			}

     

       2561
       2561
       +
       

     

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

     

       2563
       2563
       +
       				return err

     

       2564
       2564
       +
       			}

     

       2565
       2565
       +
       			if _, err := cw.WriteString(string(*t.State)); err != nil {

     

       2566
       2566
       +
       				return err

     

       2567
       2567
       +
       			}

     

       2568
       2568
       +
       		}

     

       2569
       2569
       +
       	}

     

       2570
       2570
       +
       	return nil

     

       2571
       2571
       +
       }

     

       2572
       2572
       +
       

     

       2573
       2573
       +
       func (t *RepoPullState) UnmarshalCBOR(r io.Reader) (err error) {

     

       2574
       2574
       +
       	*t = RepoPullState{}

     

       2575
       2575
       +
       

     

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

     

       2577
       2577
       +
       

     

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

     

       2579
       2579
       +
       	if err != nil {

     

       2580
       2580
       +
       		return err

     

       2581
       2581
       +
       	}

     

       2582
       2582
       +
       	defer func() {

     

       2583
       2583
       +
       		if err == io.EOF {

     

       2584
       2584
       +
       			err = io.ErrUnexpectedEOF

     

       2585
       2585
       +
       		}

     

       2586
       2586
       +
       	}()

     

       2587
       2587
       +
       

     

       2588
       2588
       +
       	if maj != cbg.MajMap {

     

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

     

       2590
       2590
       +
       	}

     

       2591
       2591
       +
       

     

       2592
       2592
       +
       	if extra > cbg.MaxLength {

     

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

     

       2594
       2594
       +
       	}

     

       2595
       2595
       +
       

     

       2596
       2596
       +
       	n := extra

     

       2597
       2597
       +
       

     

       2598
       2598
       +
       	nameBuf := make([]byte, 5)

     

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

     

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

     

       2601
       2601
       +
       		if err != nil {

     

       2602
       2602
       +
       			return err

     

       2603
       2603
       +
       		}

     

       2604
       2604
       +
       

     

       2605
       2605
       +
       		if !ok {

     

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

     

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

     

       2608
       2608
       +
       				return err

     

       2609
       2609
       +
       			}

     

       2610
       2610
       +
       			continue

     

       2611
       2611
       +
       		}

     

       2612
       2612
       +
       

     

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

     

       2614
       2614
       +
       		// t.Pull (string) (string)

     

       2615
       2615
       +
       		case "pull":

     

       2616
       2616
       +
       

     

       2617
       2617
       +
       			{

     

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

     

       2619
       2619
       +
       				if err != nil {

     

       2620
       2620
       +
       					return err

     

       2621
       2621
       +
       				}

     

       2622
       2622
       +
       

     

       2623
       2623
       +
       				t.Pull = string(sval)

     

       2624
       2624
       +
       			}

     

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

     

       2626
       2626
       +
       		case "$type":

     

       2627
       2627
       +
       

     

       2628
       2628
       +
       			{

     

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

     

       2630
       2630
       +
       				if err != nil {

     

       2631
       2631
       +
       					return err

     

       2632
       2632
       +
       				}

     

       2633
       2633
       +
       

     

       2634
       2634
       +
       				t.LexiconTypeID = string(sval)

     

       2635
       2635
       +
       			}

     

       2636
       2636
       +
       			// t.State (string) (string)

     

       2637
       2637
       +
       		case "state":

     

       2638
       2638
       +
       

     

       2639
       2639
       +
       			{

     

       2640
       2640
       +
       				b, err := cr.ReadByte()

     

       2641
       2641
       +
       				if err != nil {

     

       2642
       2642
       +
       					return err

     

       2643
       2643
       +
       				}

     

       2644
       2644
       +
       				if b != cbg.CborNull[0] {

     

       2645
       2645
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2646
       2646
       +
       						return err

     

       2647
       2647
       +
       					}

     

       2648
       2648
       +
       

     

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

     

       2650
       2650
       +
       					if err != nil {

     

       2651
       2651
       +
       						return err

     

       2652
       2652
       +
       					}

     

       2653
       2653
       +
       

     

       2654
       2654
       +
       					t.State = (*string)(&sval)

     

       2655
       2655
       +
       				}

     

       2656
       2656
       +
       			}

     

       2657
       2657
       +
       

     

       2658
       2658
       +
       		default:

     

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

     

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

     

       2661
       2661
       +
       				return err

     

       2662
       2662
       +
       			}

     

       2663
       2663
       +
       		}

     

       2664
       2664
       +
       	}

     

       2665
       2665
       +
       

     

       2666
       2666
       +
       	return nil

     

       2667
       2667
       +
       }

     

       2668
       2668
       +
       func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {

     

       2669
       2669
       +
       	if t == nil {

     

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

     

       2671
       2671
       +
       		return err

     

       2672
       2672
       +
       	}

     

       2673
       2673
       +
       

     

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

     

       2675
       2675
       +
       	fieldCount := 7

     

       2676
       2676
       +
       

     

       2677
       2677
       +
       	if t.Body == nil {

     

       2678
       2678
       +
       		fieldCount--

     

       2679
       2679
       +
       	}

     

       2680
       2680
       +
       

     

       2681
       2681
       +
       	if t.CommentId == nil {

     

       2682
       2682
       +
       		fieldCount--

     

       2683
       2683
       +
       	}

     

       2684
       2684
       +
       

     

       2685
       2685
       +
       	if t.CreatedAt == nil {

     

       2686
       2686
       +
       		fieldCount--

     

       2687
       2687
       +
       	}

     

       2688
       2688
       +
       

     

       2689
       2689
       +
       	if t.Owner == nil {

     

       2690
       2690
       +
       		fieldCount--

     

       2691
       2691
       +
       	}

     

       2692
       2692
       +
       

     

       2693
       2693
       +
       	if t.Repo == nil {

     

       2694
       2694
       +
       		fieldCount--

     

       2695
       2695
       +
       	}

     

       2696
       2696
       +
       

     

       2697
       2697
       +
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       2698
       2698
       +
       		return err

     

       2699
       2699
       +
       	}

     

       2700
       2700
       +
       

     

       2701
       2701
       +
       	// t.Body (string) (string)

     

       2702
       2702
       +
       	if t.Body != nil {

     

       2703
       2703
       +
       

     

       2704
       2704
       +
       		if len("body") > 1000000 {

     

       2705
       2705
       +
       			return xerrors.Errorf("Value in field \"body\" was too long")

     

       2706
       2706
       +
       		}

     

       2707
       2707
       +
       

     

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

     

       2709
       2709
       +
       			return err

     

       2710
       2710
       +
       		}

     

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

     

       2712
       2712
       +
       			return err

     

       2713
       2713
       +
       		}

     

       2714
       2714
       +
       

     

       2715
       2715
       +
       		if t.Body == nil {

     

       2716
       2716
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2717
       2717
       +
       				return err

     

       2718
       2718
       +
       			}

     

       2719
       2719
       +
       		} else {

     

       2720
       2720
       +
       			if len(*t.Body) > 1000000 {

     

       2721
       2721
       +
       				return xerrors.Errorf("Value in field t.Body was too long")

     

       2722
       2722
       +
       			}

     

       2723
       2723
       +
       

     

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

     

       2725
       2725
       +
       				return err

     

       2726
       2726
       +
       			}

     

       2727
       2727
       +
       			if _, err := cw.WriteString(string(*t.Body)); err != nil {

     

       2728
       2728
       +
       				return err

     

       2729
       2729
       +
       			}

     

       2730
       2730
       +
       		}

     

       2731
       2731
       +
       	}

     

       2732
       2732
       +
       

     

       2733
       2733
       +
       	// t.Pull (string) (string)

     

       2734
       2734
       +
       	if len("pull") > 1000000 {

     

       2735
       2735
       +
       		return xerrors.Errorf("Value in field \"pull\" was too long")

     

       2736
       2736
       +
       	}

     

       2737
       2737
       +
       

     

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

     

       2739
       2739
       +
       		return err

     

       2740
       2740
       +
       	}

     

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

     

       2742
       2742
       +
       		return err

     

       2743
       2743
       +
       	}

     

       2744
       2744
       +
       

     

       2745
       2745
       +
       	if len(t.Pull) > 1000000 {

     

       2746
       2746
       +
       		return xerrors.Errorf("Value in field t.Pull was too long")

     

       2747
       2747
       +
       	}

     

       2748
       2748
       +
       

     

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

     

       2750
       2750
       +
       		return err

     

       2751
       2751
       +
       	}

     

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

     

       2753
       2753
       +
       		return err

     

       2754
       2754
       +
       	}

     

       2755
       2755
       +
       

     

       2756
       2756
       +
       	// t.Repo (string) (string)

     

       2757
       2757
       +
       	if t.Repo != nil {

     

       2758
       2758
       +
       

     

       2759
       2759
       +
       		if len("repo") > 1000000 {

     

       2760
       2760
       +
       			return xerrors.Errorf("Value in field \"repo\" was too long")

     

       2761
       2761
       +
       		}

     

       2762
       2762
       +
       

     

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

     

       2764
       2764
       +
       			return err

     

       2765
       2765
       +
       		}

     

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

     

       2767
       2767
       +
       			return err

     

       2768
       2768
       +
       		}

     

       2769
       2769
       +
       

     

       2770
       2770
       +
       		if t.Repo == nil {

     

       2771
       2771
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2772
       2772
       +
       				return err

     

       2773
       2773
       +
       			}

     

       2774
       2774
       +
       		} else {

     

       2775
       2775
       +
       			if len(*t.Repo) > 1000000 {

     

       2776
       2776
       +
       				return xerrors.Errorf("Value in field t.Repo was too long")

     

       2777
       2777
       +
       			}

     

       2778
       2778
       +
       

     

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

     

       2780
       2780
       +
       				return err

     

       2781
       2781
       +
       			}

     

       2782
       2782
       +
       			if _, err := cw.WriteString(string(*t.Repo)); err != nil {

     

       2783
       2783
       +
       				return err

     

       2784
       2784
       +
       			}

     

       2785
       2785
       +
       		}

     

       2786
       2786
       +
       	}

     

       2787
       2787
       +
       

     

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

     

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

     

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

     

       2791
       2791
       +
       	}

     

       2792
       2792
       +
       

     

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

     

       2794
       2794
       +
       		return err

     

       2795
       2795
       +
       	}

     

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

     

       2797
       2797
       +
       		return err

     

       2798
       2798
       +
       	}

     

       2799
       2799
       +
       

     

       2800
       2800
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {

     

       2801
       2801
       +
       		return err

     

       2802
       2802
       +
       	}

     

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

     

       2804
       2804
       +
       		return err

     

       2805
       2805
       +
       	}

     

       2806
       2806
       +
       

     

       2807
       2807
       +
       	// t.Owner (string) (string)

     

       2808
       2808
       +
       	if t.Owner != nil {

     

       2809
       2809
       +
       

     

       2810
       2810
       +
       		if len("owner") > 1000000 {

     

       2811
       2811
       +
       			return xerrors.Errorf("Value in field \"owner\" was too long")

     

       2812
       2812
       +
       		}

     

       2813
       2813
       +
       

     

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

     

       2815
       2815
       +
       			return err

     

       2816
       2816
       +
       		}

     

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

     

       2818
       2818
       +
       			return err

     

       2819
       2819
       +
       		}

     

       2820
       2820
       +
       

     

       2821
       2821
       +
       		if t.Owner == nil {

     

       2822
       2822
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2823
       2823
       +
       				return err

     

       2824
       2824
       +
       			}

     

       2825
       2825
       +
       		} else {

     

       2826
       2826
       +
       			if len(*t.Owner) > 1000000 {

     

       2827
       2827
       +
       				return xerrors.Errorf("Value in field t.Owner was too long")

     

       2828
       2828
       +
       			}

     

       2829
       2829
       +
       

     

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

     

       2831
       2831
       +
       				return err

     

       2832
       2832
       +
       			}

     

       2833
       2833
       +
       			if _, err := cw.WriteString(string(*t.Owner)); err != nil {

     

       2834
       2834
       +
       				return err

     

       2835
       2835
       +
       			}

     

       2836
       2836
       +
       		}

     

       2837
       2837
       +
       	}

     

       2838
       2838
       +
       

     

       2839
       2839
       +
       	// t.CommentId (int64) (int64)

     

       2840
       2840
       +
       	if t.CommentId != nil {

     

       2841
       2841
       +
       

     

       2842
       2842
       +
       		if len("commentId") > 1000000 {

     

       2843
       2843
       +
       			return xerrors.Errorf("Value in field \"commentId\" was too long")

     

       2844
       2844
       +
       		}

     

       2845
       2845
       +
       

     

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

     

       2847
       2847
       +
       			return err

     

       2848
       2848
       +
       		}

     

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

     

       2850
       2850
       +
       			return err

     

       2851
       2851
       +
       		}

     

       2852
       2852
       +
       

     

       2853
       2853
       +
       		if t.CommentId == nil {

     

       2854
       2854
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2855
       2855
       +
       				return err

     

       2856
       2856
       +
       			}

     

       2857
       2857
       +
       		} else {

     

       2858
       2858
       +
       			if *t.CommentId >= 0 {

     

       2859
       2859
       +
       				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {

     

       2860
       2860
       +
       					return err

     

       2861
       2861
       +
       				}

     

       2862
       2862
       +
       			} else {

     

       2863
       2863
       +
       				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {

     

       2864
       2864
       +
       					return err

     

       2865
       2865
       +
       				}

     

       2866
       2866
       +
       			}

     

       2867
       2867
       +
       		}

     

       2868
       2868
       +
       

     

       2869
       2869
       +
       	}

     

       2870
       2870
       +
       

     

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

     

       2872
       2872
       +
       	if t.CreatedAt != nil {

     

       2873
       2873
       +
       

     

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

     

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

     

       2876
       2876
       +
       		}

     

       2877
       2877
       +
       

     

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

     

       2879
       2879
       +
       			return err

     

       2880
       2880
       +
       		}

     

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

     

       2882
       2882
       +
       			return err

     

       2883
       2883
       +
       		}

     

       2884
       2884
       +
       

     

       2885
       2885
       +
       		if t.CreatedAt == nil {

     

       2886
       2886
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       2887
       2887
       +
       				return err

     

       2888
       2888
       +
       			}

     

       2889
       2889
       +
       		} else {

     

       2890
       2890
       +
       			if len(*t.CreatedAt) > 1000000 {

     

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

     

       2892
       2892
       +
       			}

     

       2893
       2893
       +
       

     

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

     

       2895
       2895
       +
       				return err

     

       2896
       2896
       +
       			}

     

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

     

       2898
       2898
       +
       				return err

     

       2899
       2899
       +
       			}

     

       2900
       2900
       +
       		}

     

       2901
       2901
       +
       	}

     

       2902
       2902
       +
       	return nil

     

       2903
       2903
       +
       }

     

       2904
       2904
       +
       

     

       2905
       2905
       +
       func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {

     

       2906
       2906
       +
       	*t = RepoPullComment{}

     

       2907
       2907
       +
       

     

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

     

       2909
       2909
       +
       

     

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

     

       2911
       2911
       +
       	if err != nil {

     

       2912
       2912
       +
       		return err

     

       2913
       2913
       +
       	}

     

       2914
       2914
       +
       	defer func() {

     

       2915
       2915
       +
       		if err == io.EOF {

     

       2916
       2916
       +
       			err = io.ErrUnexpectedEOF

     

       2917
       2917
       +
       		}

     

       2918
       2918
       +
       	}()

     

       2919
       2919
       +
       

     

       2920
       2920
       +
       	if maj != cbg.MajMap {

     

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

     

       2922
       2922
       +
       	}

     

       2923
       2923
       +
       

     

       2924
       2924
       +
       	if extra > cbg.MaxLength {

     

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

     

       2926
       2926
       +
       	}

     

       2927
       2927
       +
       

     

       2928
       2928
       +
       	n := extra

     

       2929
       2929
       +
       

     

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

     

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

     

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

     

       2933
       2933
       +
       		if err != nil {

     

       2934
       2934
       +
       			return err

     

       2935
       2935
       +
       		}

     

       2936
       2936
       +
       

     

       2937
       2937
       +
       		if !ok {

     

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

     

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

     

       2940
       2940
       +
       				return err

     

       2941
       2941
       +
       			}

     

       2942
       2942
       +
       			continue

     

       2943
       2943
       +
       		}

     

       2944
       2944
       +
       

     

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

     

       2946
       2946
       +
       		// t.Body (string) (string)

     

       2947
       2947
       +
       		case "body":

     

       2948
       2948
       +
       

     

       2949
       2949
       +
       			{

     

       2950
       2950
       +
       				b, err := cr.ReadByte()

     

       2951
       2951
       +
       				if err != nil {

     

       2952
       2952
       +
       					return err

     

       2953
       2953
       +
       				}

     

       2954
       2954
       +
       				if b != cbg.CborNull[0] {

     

       2955
       2955
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2956
       2956
       +
       						return err

     

       2957
       2957
       +
       					}

     

       2958
       2958
       +
       

     

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

     

       2960
       2960
       +
       					if err != nil {

     

       2961
       2961
       +
       						return err

     

       2962
       2962
       +
       					}

     

       2963
       2963
       +
       

     

       2964
       2964
       +
       					t.Body = (*string)(&sval)

     

       2965
       2965
       +
       				}

     

       2966
       2966
       +
       			}

     

       2967
       2967
       +
       			// t.Pull (string) (string)

     

       2968
       2968
       +
       		case "pull":

     

       2969
       2969
       +
       

     

       2970
       2970
       +
       			{

     

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

     

       2972
       2972
       +
       				if err != nil {

     

       2973
       2973
       +
       					return err

     

       2974
       2974
       +
       				}

     

       2975
       2975
       +
       

     

       2976
       2976
       +
       				t.Pull = string(sval)

     

       2977
       2977
       +
       			}

     

       2978
       2978
       +
       			// t.Repo (string) (string)

     

       2979
       2979
       +
       		case "repo":

     

       2980
       2980
       +
       

     

       2981
       2981
       +
       			{

     

       2982
       2982
       +
       				b, err := cr.ReadByte()

     

       2983
       2983
       +
       				if err != nil {

     

       2984
       2984
       +
       					return err

     

       2985
       2985
       +
       				}

     

       2986
       2986
       +
       				if b != cbg.CborNull[0] {

     

       2987
       2987
       +
       					if err := cr.UnreadByte(); err != nil {

     

       2988
       2988
       +
       						return err

     

       2989
       2989
       +
       					}

     

       2990
       2990
       +
       

     

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

     

       2992
       2992
       +
       					if err != nil {

     

       2993
       2993
       +
       						return err

     

       2994
       2994
       +
       					}

     

       2995
       2995
       +
       

     

       2996
       2996
       +
       					t.Repo = (*string)(&sval)

     

       2997
       2997
       +
       				}

     

       2998
       2998
       +
       			}

     

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

     

       3000
       3000
       +
       		case "$type":

     

       3001
       3001
       +
       

     

       3002
       3002
       +
       			{

     

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

     

       3004
       3004
       +
       				if err != nil {

     

       3005
       3005
       +
       					return err

     

       3006
       3006
       +
       				}

     

       3007
       3007
       +
       

     

       3008
       3008
       +
       				t.LexiconTypeID = string(sval)

     

       3009
       3009
       +
       			}

     

       3010
       3010
       +
       			// t.Owner (string) (string)

     

       3011
       3011
       +
       		case "owner":

     

       3012
       3012
       +
       

     

       3013
       3013
       +
       			{

     

       3014
       3014
       +
       				b, err := cr.ReadByte()

     

       3015
       3015
       +
       				if err != nil {

     

       3016
       3016
       +
       					return err

     

       3017
       3017
       +
       				}

     

       3018
       3018
       +
       				if b != cbg.CborNull[0] {

     

       3019
       3019
       +
       					if err := cr.UnreadByte(); err != nil {

     

       3020
       3020
       +
       						return err

     

       3021
       3021
       +
       					}

     

       3022
       3022
       +
       

     

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

     

       3024
       3024
       +
       					if err != nil {

     

       3025
       3025
       +
       						return err

     

       3026
       3026
       +
       					}

     

       3027
       3027
       +
       

     

       3028
       3028
       +
       					t.Owner = (*string)(&sval)

     

       3029
       3029
       +
       				}

     

       3030
       3030
       +
       			}

     

       3031
       3031
       +
       			// t.CommentId (int64) (int64)

     

       3032
       3032
       +
       		case "commentId":

     

       3033
       3033
       +
       			{

     

       3034
       3034
       +
       

     

       3035
       3035
       +
       				b, err := cr.ReadByte()

     

       3036
       3036
       +
       				if err != nil {

     

       3037
       3037
       +
       					return err

     

       3038
       3038
       +
       				}

     

       3039
       3039
       +
       				if b != cbg.CborNull[0] {

     

       3040
       3040
       +
       					if err := cr.UnreadByte(); err != nil {

     

       3041
       3041
       +
       						return err

     

       3042
       3042
       +
       					}

     

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

     

       3044
       3044
       +
       					if err != nil {

     

       3045
       3045
       +
       						return err

     

       3046
       3046
       +
       					}

     

       3047
       3047
       +
       					var extraI int64

     

       3048
       3048
       +
       					switch maj {

     

       3049
       3049
       +
       					case cbg.MajUnsignedInt:

     

       3050
       3050
       +
       						extraI = int64(extra)

     

       3051
       3051
       +
       						if extraI < 0 {

     

       3052
       3052
       +
       							return fmt.Errorf("int64 positive overflow")

     

       3053
       3053
       +
       						}

     

       3054
       3054
       +
       					case cbg.MajNegativeInt:

     

       3055
       3055
       +
       						extraI = int64(extra)

     

       3056
       3056
       +
       						if extraI < 0 {

     

       3057
       3057
       +
       							return fmt.Errorf("int64 negative overflow")

     

       3058
       3058
       +
       						}

     

       3059
       3059
       +
       						extraI = -1 - extraI

     

       3060
       3060
       +
       					default:

     

       3061
       3061
       +
       						return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       3062
       3062
       +
       					}

     

       3063
       3063
       +
       

     

       3064
       3064
       +
       					t.CommentId = (*int64)(&extraI)

     

       3065
       3065
       +
       				}

     

       3066
       3066
       +
       			}

     

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

     

       3068
       3068
       +
       		case "createdAt":

     

       3069
       3069
       +
       

     

       3070
       3070
       +
       			{

     

       3071
       3071
       +
       				b, err := cr.ReadByte()

     

       3072
       3072
       +
       				if err != nil {

     

       3073
       3073
       +
       					return err

     

       3074
       3074
       +
       				}

     

       3075
       3075
       +
       				if b != cbg.CborNull[0] {

     

       3076
       3076
       +
       					if err := cr.UnreadByte(); err != nil {

     

       3077
       3077
       +
       						return err

     

       3078
       3078
       +
       					}

     

       3079
       3079
       +
       

     

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

     

       3081
       3081
       +
       					if err != nil {

     

       3082
       3082
       +
       						return err

     

       3083
       3083
       +
       					}

     

       3084
       3084
       +
       

     

       3085
       3085
       +
       					t.CreatedAt = (*string)(&sval)

     

       1992
       3086
        
       				}

     

       1993
       3087
        
       			}

     

       1994
       3088

+27

api/tangled/pullcomment.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.repo.pull.comment

     

       6
       6
       +
       

     

       7
       7
       +
       import (

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	RepoPullCommentNSID = "sh.tangled.repo.pull.comment"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	//util.RegisterType("sh.tangled.repo.pull.comment", &RepoPullComment{})

     

       17
       17
       +
       } //

     

       18
       18
       +
       // RECORDTYPE: RepoPullComment

     

       19
       19
       +
       type RepoPullComment struct {

     

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

     

       21
       21
       +
       	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       +
       	CommentId     *int64  `json:"commentId,omitempty" cborgen:"commentId,omitempty"`

     

       23
       23
       +
       	CreatedAt     *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

       24
       24
       +
       	Owner         *string `json:"owner,omitempty" cborgen:"owner,omitempty"`

     

       25
       25
       +
       	Pull          string  `json:"pull" cborgen:"pull"`

     

       26
       26
       +
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

     

       27
       27
       +
       }

+28

api/tangled/pullpatch.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.repo.pull.patch

     

       6
       6
       +
       

     

       7
       7
       +
       import (

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	RepoPullPatchNSID = "sh.tangled.repo.pull.patch"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	util.RegisterType("sh.tangled.repo.pull.patch", &RepoPullPatch{})

     

       17
       17
       +
       } //

     

       18
       18
       +
       // RECORDTYPE: RepoPullPatch

     

       19
       19
       +
       type RepoPullPatch struct {

     

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

     

       21
       21
       +
       	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       +
       	CreatedAt     *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

       23
       23
       +
       	Patch         string  `json:"patch" cborgen:"patch"`

     

       24
       24
       +
       	PullId        int64   `json:"pullId" cborgen:"pullId"`

     

       25
       25
       +
       	SourceRepo    *string `json:"sourceRepo,omitempty" cborgen:"sourceRepo,omitempty"`

     

       26
       26
       +
       	TargetRepo    string  `json:"targetRepo" cborgen:"targetRepo"`

     

       27
       27
       +
       	Title         string  `json:"title" cborgen:"title"`

     

       28
       28
       +
       }

+24

api/tangled/pullstate.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.repo.pull.state

     

       6
       6
       +
       

     

       7
       7
       +
       import (

     

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

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	RepoPullStateNSID = "sh.tangled.repo.pull.state"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	//util.RegisterType("sh.tangled.repo.pull.state", &RepoPullState{})

     

       17
       17
       +
       } //

     

       18
       18
       +
       // RECORDTYPE: RepoPullState

     

       19
       19
       +
       type RepoPullState struct {

     

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

     

       21
       21
       +
       	Pull          string `json:"pull" cborgen:"pull"`

     

       22
       22
       +
       	// state: state of the pull request

     

       23
       23
       +
       	State *string `json:"state,omitempty" cborgen:"state,omitempty"`

     

       24
       24
       +
       }

+2 -2

api/tangled/stateclosed.go

···

       2
       2
        
       

     

       3
       3
        
       package tangled

     

       4
       4
        
       

     

       5
       5
       -
       // schema: sh.tangled.repo.issue.state.closed

     

       5
       5
       +
       // schema: sh.tangled.repo.pull.state.closed

     

       6
       6
        
       

     

       7
       7
        
       const ()

     

       8
       8
        
       

     

       9
       9
       -
       const RepoIssueStateClosed = "sh.tangled.repo.issue.state.closed"

     

       9
       9
       +
       const RepoPullStateClosed = "sh.tangled.repo.pull.state.closed"

api/tangled/statemerged.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.repo.pull.state.merged

     

       6
       6
       +
       

     

       7
       7
       +
       const ()

     

       8
       8
       +
       

     

       9
       9
       +
       const RepoPullStateMerged = "sh.tangled.repo.pull.state.merged"

+2 -2

api/tangled/stateopen.go

···

       2
       2
        
       

     

       3
       3
        
       package tangled

     

       4
       4
        
       

     

       5
       5
       -
       // schema: sh.tangled.repo.issue.state.open

     

       5
       5
       +
       // schema: sh.tangled.repo.pull.state.open

     

       6
       6
        
       

     

       7
       7
        
       const ()

     

       8
       8
        
       

     

       9
       9
       -
       const RepoIssueStateOpen = "sh.tangled.repo.issue.state.open"

     

       9
       9
       +
       const RepoPullStateOpen = "sh.tangled.repo.pull.state.open"

+30

appview/db/db.go

···

       103
       103
        
       			unique(issue_id, comment_id),

     

       104
       104
        
       			foreign key (repo_at, issue_id) references issues(repo_at, issue_id) on delete cascade

     

       105
       105
        
       		);

     

       106
       106
       +
       		create table if not exists pulls (

     

       107
       107
       +
       			id integer primary key autoincrement,

     

       108
       108
       +
       			owner_did text not null,

     

       109
       109
       +
       			repo_at text not null,

     

       110
       110
       +
       			pull_id integer not null,

     

       111
       111
       +
       			title text not null,

     

       112
       112
       +
       			patch text,

     

       113
       113
       +
       			patch_at text not null,

     

       114
       114
       +
       			open integer not null default 1,

     

       115
       115
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       116
       116
       +
       			unique(repo_at, pull_id),

     

       117
       117
       +
       			foreign key (repo_at) references repos(at_uri) on delete cascade

     

       118
       118
       +
       		);

     

       119
       119
       +
       		create table if not exists pull_comments (

     

       120
       120
       +
       			id integer primary key autoincrement,

     

       121
       121
       +
       			owner_did text not null,

     

       122
       122
       +
       			pull_id integer not null,

     

       123
       123
       +
       			repo_at text not null,

     

       124
       124
       +
       			comment_id integer not null,

     

       125
       125
       +
       			comment_at text not null,

     

       126
       126
       +
       			body text not null,

     

       127
       127
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       128
       128
       +
       			unique(pull_id, comment_id),

     

       129
       129
       +
       			foreign key (repo_at, pull_id) references pulls(repo_at, pull_id) on delete cascade

     

       130
       130
       +
       		);

     

       106
       131
        
       		create table if not exists _jetstream (

     

       107
       132
        
       			id integer primary key autoincrement,

     

       108
       133
        
       			last_time_us integer not null

     
···

       111
       136
        
       		create table if not exists repo_issue_seqs (

     

       112
       137
        
       			repo_at text primary key,

     

       113
       138
        
       			next_issue_id integer not null default 1

     

       139
       139
       +
       		);

     

       140
       140
       +
       

     

       141
       141
       +
       		create table if not exists repo_pull_seqs (

     

       142
       142
       +
       			repo_at text primary key,

     

       143
       143
       +
       			next_pull_id integer not null default 1

     

       114
       144
        
       		);

     

       115
       145
        
       

     

       116
       146
        
       		create table if not exists stars (

+254

appview/db/pulls.go

···

       1
       1
       +
       package db

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"database/sql"

     

       5
       5
       +
       	"time"

     

       6
       6
       +
       

     

       7
       7
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       type Pulls struct {

     

       11
       11
       +
       	ID       int       `json:"id"`

     

       12
       12
       +
       	OwnerDid string    `json:"owner_did"`

     

       13
       13
       +
       	RepoAt   string    `json:"repo_at"`

     

       14
       14
       +
       	PullId   int       `json:"pull_id"`

     

       15
       15
       +
       	Title    string    `json:"title"`

     

       16
       16
       +
       	Patch    string    `json:"patch,omitempty"`

     

       17
       17
       +
       	PatchAt  string    `json:"patch_at"`

     

       18
       18
       +
       	Open     int       `json:"open"`

     

       19
       19
       +
       	Created  time.Time `json:"created"`

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       type PullComments struct {

     

       23
       23
       +
       	ID        int       `json:"id"`

     

       24
       24
       +
       	OwnerDid  string    `json:"owner_did"`

     

       25
       25
       +
       	PullId    int       `json:"pull_id"`

     

       26
       26
       +
       	RepoAt    string    `json:"repo_at"`

     

       27
       27
       +
       	CommentId int       `json:"comment_id"`

     

       28
       28
       +
       	CommentAt string    `json:"comment_at"`

     

       29
       29
       +
       	Body      string    `json:"body"`

     

       30
       30
       +
       	Created   time.Time `json:"created"`

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       func NewPull(tx *sql.Tx, pull *Pulls) error {

     

       34
       34
       +
       	defer tx.Rollback()

     

       35
       35
       +
       

     

       36
       36
       +
       	_, err := tx.Exec(`

     

       37
       37
       +
       		insert or ignore into repo_pull_seqs (repo_at, next_pull_id)

     

       38
       38
       +
       		values (?, 1)

     

       39
       39
       +
       		`, pull.RepoAt)

     

       40
       40
       +
       	if err != nil {

     

       41
       41
       +
       		return err

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	var nextId int

     

       45
       45
       +
       	err = tx.QueryRow(`

     

       46
       46
       +
       		update repo_pull_seqs

     

       47
       47
       +
       		set next_pull_id = next_pull_id + 1

     

       48
       48
       +
       		where repo_at = ?

     

       49
       49
       +
       		returning next_pull_id - 1

     

       50
       50
       +
       		`, pull.RepoAt).Scan(&nextId)

     

       51
       51
       +
       	if err != nil {

     

       52
       52
       +
       		return err

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	pull.PullId = nextId

     

       56
       56
       +
       

     

       57
       57
       +
       	_, err = tx.Exec(`

     

       58
       58
       +
       		insert into pulls (repo_at, owner_did, pull_id, title, patch)

     

       59
       59
       +
       		values (?, ?, ?, ?, ?)

     

       60
       60
       +
       	`, pull.RepoAt, pull.OwnerDid, pull.PullId, pull.Title, pull.Patch)

     

       61
       61
       +
       	if err != nil {

     

       62
       62
       +
       		return err

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	if err := tx.Commit(); err != nil {

     

       66
       66
       +
       		return err

     

       67
       67
       +
       	}

     

       68
       68
       +
       

     

       69
       69
       +
       	return nil

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       func SetPullAt(e Execer, repoAt syntax.ATURI, pullId int, pullAt string) error {

     

       73
       73
       +
       	_, err := e.Exec(`update pulls set patch_at = ? where repo_at = ? and pull_id = ?`, pullAt, repoAt, pullId)

     

       74
       74
       +
       	return err

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       func GetPullAt(e Execer, repoAt syntax.ATURI, pullId int) (string, error) {

     

       78
       78
       +
       	var pullAt string

     

       79
       79
       +
       	err := e.QueryRow(`select patch_at from pulls where repo_at = ? and pull_id = ?`, repoAt, pullId).Scan(&pullAt)

     

       80
       80
       +
       	return pullAt, err

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       func GetPullId(e Execer, repoAt syntax.ATURI) (int, error) {

     

       84
       84
       +
       	var pullId int

     

       85
       85
       +
       	err := e.QueryRow(`select next_pull_id from repo_pull_seqs where repo_at = ?`, repoAt).Scan(&pullId)

     

       86
       86
       +
       	return pullId - 1, err

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       func GetPullOwnerDid(e Execer, repoAt syntax.ATURI, pullId int) (string, error) {

     

       90
       90
       +
       	var ownerDid string

     

       91
       91
       +
       	err := e.QueryRow(`select owner_did from pulls where repo_at = ? and pull_id = ?`, repoAt, pullId).Scan(&ownerDid)

     

       92
       92
       +
       	return ownerDid, err

     

       93
       93
       +
       }

     

       94
       94
       +
       

     

       95
       95
       +
       func GetPulls(e Execer, repoAt syntax.ATURI) ([]Pulls, error) {

     

       96
       96
       +
       	var pulls []Pulls

     

       97
       97
       +
       

     

       98
       98
       +
       	rows, err := e.Query(`select owner_did, pull_id, created, title, patch, open from pulls where repo_at = ? order by created desc`, repoAt)

     

       99
       99
       +
       	if err != nil {

     

       100
       100
       +
       		return nil, err

     

       101
       101
       +
       	}

     

       102
       102
       +
       	defer rows.Close()

     

       103
       103
       +
       

     

       104
       104
       +
       	for rows.Next() {

     

       105
       105
       +
       		var pull Pulls

     

       106
       106
       +
       		var createdAt string

     

       107
       107
       +
       		err := rows.Scan(&pull.OwnerDid, &pull.PullId, &createdAt, &pull.Title, &pull.Patch, &pull.Open)

     

       108
       108
       +
       		if err != nil {

     

       109
       109
       +
       			return nil, err

     

       110
       110
       +
       		}

     

       111
       111
       +
       

     

       112
       112
       +
       		createdTime, err := time.Parse(time.RFC3339, createdAt)

     

       113
       113
       +
       		if err != nil {

     

       114
       114
       +
       			return nil, err

     

       115
       115
       +
       		}

     

       116
       116
       +
       		pull.Created = createdTime

     

       117
       117
       +
       

     

       118
       118
       +
       		pulls = append(pulls, pull)

     

       119
       119
       +
       	}

     

       120
       120
       +
       

     

       121
       121
       +
       	if err := rows.Err(); err != nil {

     

       122
       122
       +
       		return nil, err

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

       125
       125
       +
       	return pulls, nil

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

       128
       128
       +
       func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*Pulls, error) {

     

       129
       129
       +
       	query := `select owner_did, created, title, patch, open from pulls where repo_at = ? and pull_id = ?`

     

       130
       130
       +
       	row := e.QueryRow(query, repoAt, pullId)

     

       131
       131
       +
       

     

       132
       132
       +
       	var pull Pulls

     

       133
       133
       +
       	var createdAt string

     

       134
       134
       +
       	err := row.Scan(&pull.OwnerDid, &createdAt, &pull.Title, &pull.Patch, &pull.Open)

     

       135
       135
       +
       	if err != nil {

     

       136
       136
       +
       		return nil, err

     

       137
       137
       +
       	}

     

       138
       138
       +
       

     

       139
       139
       +
       	createdTime, err := time.Parse(time.RFC3339, createdAt)

     

       140
       140
       +
       	if err != nil {

     

       141
       141
       +
       		return nil, err

     

       142
       142
       +
       	}

     

       143
       143
       +
       	pull.Created = createdTime

     

       144
       144
       +
       

     

       145
       145
       +
       	return &pull, nil

     

       146
       146
       +
       }

     

       147
       147
       +
       

     

       148
       148
       +
       func GetPullWithComments(e Execer, repoAt syntax.ATURI, pullId int) (*Pulls, []PullComments, error) {

     

       149
       149
       +
       	query := `select owner_did, pull_id, created, title, patch, open from pulls where repo_at = ? and pull_id = ?`

     

       150
       150
       +
       	row := e.QueryRow(query, repoAt, pullId)

     

       151
       151
       +
       

     

       152
       152
       +
       	var pull Pulls

     

       153
       153
       +
       	var createdAt string

     

       154
       154
       +
       	err := row.Scan(&pull.OwnerDid, &pull.PullId, &createdAt, &pull.Title, &pull.Patch, &pull.Open)

     

       155
       155
       +
       	if err != nil {

     

       156
       156
       +
       		return nil, nil, err

     

       157
       157
       +
       	}

     

       158
       158
       +
       

     

       159
       159
       +
       	createdTime, err := time.Parse(time.RFC3339, createdAt)

     

       160
       160
       +
       	if err != nil {

     

       161
       161
       +
       		return nil, nil, err

     

       162
       162
       +
       	}

     

       163
       163
       +
       	pull.Created = createdTime

     

       164
       164
       +
       

     

       165
       165
       +
       	comments, err := GetPullComments(e, repoAt, pullId)

     

       166
       166
       +
       	if err != nil {

     

       167
       167
       +
       		return nil, nil, err

     

       168
       168
       +
       	}

     

       169
       169
       +
       

     

       170
       170
       +
       	return &pull, comments, nil

     

       171
       171
       +
       }

     

       172
       172
       +
       

     

       173
       173
       +
       func NewPullComment(e Execer, comment *PullComments) error {

     

       174
       174
       +
       	query := `insert into pull_comments (owner_did, repo_at, comment_at, pull_id, comment_id, body) values (?, ?, ?, ?, ?, ?)`

     

       175
       175
       +
       	_, err := e.Exec(

     

       176
       176
       +
       		query,

     

       177
       177
       +
       		comment.OwnerDid,

     

       178
       178
       +
       		comment.RepoAt,

     

       179
       179
       +
       		comment.CommentAt,

     

       180
       180
       +
       		comment.PullId,

     

       181
       181
       +
       		comment.CommentId,

     

       182
       182
       +
       		comment.Body,

     

       183
       183
       +
       	)

     

       184
       184
       +
       	return err

     

       185
       185
       +
       }

     

       186
       186
       +
       

     

       187
       187
       +
       func GetPullComments(e Execer, repoAt syntax.ATURI, pullId int) ([]PullComments, error) {

     

       188
       188
       +
       	var comments []PullComments

     

       189
       189
       +
       

     

       190
       190
       +
       	rows, err := e.Query(`select owner_did, pull_id, comment_id, comment_at, body, created from pull_comments where repo_at = ? and pull_id = ? order by created asc`, repoAt, pullId)

     

       191
       191
       +
       	if err == sql.ErrNoRows {

     

       192
       192
       +
       		return []PullComments{}, nil

     

       193
       193
       +
       	}

     

       194
       194
       +
       	if err != nil {

     

       195
       195
       +
       		return nil, err

     

       196
       196
       +
       	}

     

       197
       197
       +
       	defer rows.Close()

     

       198
       198
       +
       

     

       199
       199
       +
       	for rows.Next() {

     

       200
       200
       +
       		var comment PullComments

     

       201
       201
       +
       		var createdAt string

     

       202
       202
       +
       		err := rows.Scan(&comment.OwnerDid, &comment.PullId, &comment.CommentId, &comment.CommentAt, &comment.Body, &createdAt)

     

       203
       203
       +
       		if err != nil {

     

       204
       204
       +
       			return nil, err

     

       205
       205
       +
       		}

     

       206
       206
       +
       

     

       207
       207
       +
       		createdAtTime, err := time.Parse(time.RFC3339, createdAt)

     

       208
       208
       +
       		if err != nil {

     

       209
       209
       +
       			return nil, err

     

       210
       210
       +
       		}

     

       211
       211
       +
       		comment.Created = createdAtTime

     

       212
       212
       +
       

     

       213
       213
       +
       		comments = append(comments, comment)

     

       214
       214
       +
       	}

     

       215
       215
       +
       

     

       216
       216
       +
       	if err := rows.Err(); err != nil {

     

       217
       217
       +
       		return nil, err

     

       218
       218
       +
       	}

     

       219
       219
       +
       

     

       220
       220
       +
       	return comments, nil

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       func ClosePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       224
       224
       +
       	_, err := e.Exec(`update pulls set open = 0 where repo_at = ? and pull_id = ?`, repoAt, pullId)

     

       225
       225
       +
       	return err

     

       226
       226
       +
       }

     

       227
       227
       +
       

     

       228
       228
       +
       func ReopenPull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       229
       229
       +
       	_, err := e.Exec(`update pulls set open = 1 where repo_at = ? and pull_id = ?`, repoAt, pullId)

     

       230
       230
       +
       	return err

     

       231
       231
       +
       }

     

       232
       232
       +
       

     

       233
       233
       +
       type PullCount struct {

     

       234
       234
       +
       	Open   int

     

       235
       235
       +
       	Closed int

     

       236
       236
       +
       }

     

       237
       237
       +
       

     

       238
       238
       +
       func GetPullCount(e Execer, repoAt syntax.ATURI) (PullCount, error) {

     

       239
       239
       +
       	row := e.QueryRow(`

     

       240
       240
       +
       		select

     

       241
       241
       +
       			count(case when open = 1 then 1 end) as open_count,

     

       242
       242
       +
       			count(case when open = 0 then 1 end) as closed_count

     

       243
       243
       +
       		from pulls

     

       244
       244
       +
       		where repo_at = ?`,

     

       245
       245
       +
       		repoAt,

     

       246
       246
       +
       	)

     

       247
       247
       +
       

     

       248
       248
       +
       	var count PullCount

     

       249
       249
       +
       	if err := row.Scan(&count.Open, &count.Closed); err != nil {

     

       250
       250
       +
       		return PullCount{0, 0}, err

     

       251
       251
       +
       	}

     

       252
       252
       +
       

     

       253
       253
       +
       	return count, nil

     

       254
       254
       +
       }

+19

appview/state/signer.go

···

       155
       155
        
       

     

       156
       156
        
       	return s.client.Do(req)

     

       157
       157
        
       }

     

       158
       158
       +
       

     

       159
       159
       +
       func (s *SignedClient) Merge(patch []byte, ownerDid, targetRepo, branch string) (*http.Response, error) {

     

       160
       160
       +
       	const (

     

       161
       161
       +
       		Method = "POST"

     

       162
       162
       +
       	)

     

       163
       163
       +
       	endpoint := fmt.Sprintf("/%s/%s/merge", ownerDid, targetRepo)

     

       164
       164
       +
       

     

       165
       165
       +
       	body, _ := json.Marshal(map[string]interface{}{

     

       166
       166
       +
       		"patch":  string(patch),

     

       167
       167
       +
       		"branch": branch,

     

       168
       168
       +
       	})

     

       169
       169
       +
       

     

       170
       170
       +
       	req, err := s.newRequest(Method, endpoint, body)

     

       171
       171
       +
       	if err != nil {

     

       172
       172
       +
       		return nil, err

     

       173
       173
       +
       	}

     

       174
       174
       +
       

     

       175
       175
       +
       	return s.client.Do(req)

     

       176
       176
       +
       }

cmd/gen.go

···

       22
       22
        
       		shtangled.RepoIssueState{},

     

       23
       23
        
       		shtangled.RepoIssue{},

     

       24
       24
        
       		shtangled.Repo{},

     

       25
       25
       +
       		shtangled.RepoPullPatch{},

     

       26
       26
       +
       		shtangled.RepoPullState{},

     

       27
       27
       +
       		shtangled.RepoPullComment{},

     

       25
       28
        
       	); err != nil {

     

       26
       29
        
       		panic(err)

     

       27
       30
        
       	}

+14 -14

go.mod

···

       1
       1
        
       module github.com/sotangled/tangled

     

       2
       2
        
       

     

       3
       3
       -
       go 1.23

     

       3
       3
       +
       go 1.23.0

     

       4
       4
        
       

     

       5
       5
       -
       toolchain go1.23.4

     

       5
       5
       +
       toolchain go1.23.6

     

       6
       6
        
       

     

       7
       7
        
       require (

     

       8
       8
        
       	github.com/Blank-Xu/sql-adapter v1.1.1

     

       9
       9
        
       	github.com/alecthomas/chroma/v2 v2.15.0

     

       10
       10
       -
       	github.com/bluekeyes/go-gitdiff v0.8.0

     

       10
       10
       +
       	github.com/bluekeyes/go-gitdiff v0.8.1

     

       11
       11
        
       	github.com/bluesky-social/indigo v0.0.0-20250123072624-9e3b84fdbb20

     

       12
       12
        
       	github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1

     

       13
       13
        
       	github.com/casbin/casbin/v2 v2.103.0

     

       14
       14
       -
       	github.com/cyphar/filepath-securejoin v0.3.3

     

       14
       14
       +
       	github.com/cyphar/filepath-securejoin v0.4.1

     

       15
       15
        
       	github.com/dgraph-io/ristretto v0.2.0

     

       16
       16
        
       	github.com/dustin/go-humanize v1.0.1

     

       17
       17
        
       	github.com/gliderlabs/ssh v0.3.5

     

       18
       18
        
       	github.com/go-chi/chi/v5 v5.2.0

     

       19
       19
       -
       	github.com/go-git/go-git/v5 v5.12.0

     

       19
       19
       +
       	github.com/go-git/go-git/v5 v5.14.0

     

       20
       20
        
       	github.com/gorilla/sessions v1.4.0

     

       21
       21
        
       	github.com/ipfs/go-cid v0.4.1

     

       22
       22
        
       	github.com/mattn/go-sqlite3 v1.14.24

     
···

       24
       24
        
       	github.com/sethvargo/go-envconfig v1.1.0

     

       25
       25
        
       	github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e

     

       26
       26
        
       	github.com/yuin/goldmark v1.4.13

     

       27
       27
       +
       	golang.org/x/crypto v0.36.0

     

       27
       28
        
       	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028

     

       28
       29
        
       )

     

       29
       30
        
       

     

       30
       31
        
       require (

     

       31
       32
        
       	github.com/Microsoft/go-winio v0.6.2 // indirect

     

       32
       32
       -
       	github.com/ProtonMail/go-crypto v1.0.0 // indirect

     

       33
       33
       +
       	github.com/ProtonMail/go-crypto v1.1.6 // indirect

     

       33
       34
        
       	github.com/acomagu/bufpipe v1.0.4 // indirect

     

       34
       35
        
       	github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect

     

       35
       36
        
       	github.com/aymerick/douceur v0.2.0 // indirect

     
···

       38
       39
        
       	github.com/carlmjohnson/versioninfo v0.22.5 // indirect

     

       39
       40
        
       	github.com/casbin/govaluate v1.3.0 // indirect

     

       40
       41
        
       	github.com/cespare/xxhash/v2 v2.3.0 // indirect

     

       41
       41
       -
       	github.com/cloudflare/circl v1.4.0 // indirect

     

       42
       42
       +
       	github.com/cloudflare/circl v1.6.0 // indirect

     

       42
       43
        
       	github.com/davecgh/go-spew v1.1.1 // indirect

     

       43
       44
        
       	github.com/dlclark/regexp2 v1.11.5 // indirect

     

       44
       45
        
       	github.com/emirpasic/gods v1.18.1 // indirect

     

       45
       46
        
       	github.com/felixge/httpsnoop v1.0.4 // indirect

     

       46
       47
        
       	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect

     

       47
       47
       -
       	github.com/go-git/go-billy/v5 v5.5.0 // indirect

     

       48
       48
       +
       	github.com/go-git/go-billy/v5 v5.6.2 // indirect

     

       48
       49
        
       	github.com/go-logr/logr v1.4.1 // indirect

     

       49
       50
        
       	github.com/go-logr/stdr v1.2.2 // indirect

     

       50
       51
        
       	github.com/goccy/go-json v0.10.2 // indirect

     
···

       83
       84
        
       	github.com/multiformats/go-multihash v0.2.3 // indirect

     

       84
       85
        
       	github.com/multiformats/go-varint v0.0.7 // indirect

     

       85
       86
        
       	github.com/opentracing/opentracing-go v1.2.0 // indirect

     

       86
       86
       -
       	github.com/pjbgf/sha1cd v0.3.0 // indirect

     

       87
       87
       +
       	github.com/pjbgf/sha1cd v0.3.2 // indirect

     

       87
       88
        
       	github.com/pkg/errors v0.9.1 // indirect

     

       88
       89
        
       	github.com/pmezard/go-difflib v1.0.0 // indirect

     

       89
       90
        
       	github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f // indirect

     
···

       92
       93
        
       	github.com/prometheus/common v0.54.0 // indirect

     

       93
       94
        
       	github.com/prometheus/procfs v0.15.1 // indirect

     

       94
       95
        
       	github.com/sergi/go-diff v1.3.1 // indirect

     

       95
       95
       -
       	github.com/skeema/knownhosts v1.3.0 // indirect

     

       96
       96
       +
       	github.com/skeema/knownhosts v1.3.1 // indirect

     

       96
       97
        
       	github.com/spaolacci/murmur3 v1.1.0 // indirect

     

       97
       97
       -
       	github.com/stretchr/testify v1.9.0 // indirect

     

       98
       98
       +
       	github.com/stretchr/testify v1.10.0 // indirect

     

       98
       99
        
       	github.com/xanzy/ssh-agent v0.3.3 // indirect

     

       99
       100
        
       	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect

     

       100
       101
        
       	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect

     
···

       105
       106
        
       	go.uber.org/atomic v1.11.0 // indirect

     

       106
       107
        
       	go.uber.org/multierr v1.11.0 // indirect

     

       107
       108
        
       	go.uber.org/zap v1.26.0 // indirect

     

       108
       108
       -
       	golang.org/x/crypto v0.32.0 // indirect

     

       109
       109
       -
       	golang.org/x/net v0.33.0 // indirect

     

       110
       110
       -
       	golang.org/x/sys v0.29.0 // indirect

     

       109
       109
       +
       	golang.org/x/net v0.37.0 // indirect

     

       110
       110
       +
       	golang.org/x/sys v0.31.0 // indirect

     

       111
       111
        
       	golang.org/x/time v0.5.0 // indirect

     

       112
       112
        
       	google.golang.org/protobuf v1.34.2 // indirect

     

       113
       113
        
       	gopkg.in/warnings.v0 v0.1.2 // indirect

+30 -40

go.sum

···

       5
       5
        
       github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=

     

       6
       6
        
       github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=

     

       7
       7
        
       github.com/ProtonMail/go-crypto v0.0.0-20230217124315-7d5c6f04bbb8/go.mod h1:I0gYDMZ6Z5GRU7l58bNFSkPTFN6Yl12dsUlAZ8xy98g=

     

       8
       8
       -
       github.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78=

     

       9
       9
       -
       github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=

     

       8
       8
       +
       github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=

     

       9
       9
       +
       github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=

     

       10
       10
        
       github.com/acomagu/bufpipe v1.0.4 h1:e3H4WUzM3npvo5uv95QuJM3cQspFNtFBzvJ2oNjKIDQ=

     

       11
       11
        
       github.com/acomagu/bufpipe v1.0.4/go.mod h1:mxdxdup/WdsKVreO5GpW4+M/1CE2sMG4jeGJ2sYmHc4=

     

       12
       12
        
       github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=

     
···

       24
       24
        
       github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=

     

       25
       25
        
       github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=

     

       26
       26
        
       github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=

     

       27
       27
       -
       github.com/bluekeyes/go-gitdiff v0.8.0 h1:Nn1wfw3/XeKoc3lWk+2bEXGUHIx36kj80FM1gVcBk+o=

     

       28
       28
       -
       github.com/bluekeyes/go-gitdiff v0.8.0/go.mod h1:WWAk1Mc6EgWarCrPFO+xeYlujPu98VuLW3Tu+B/85AE=

     

       27
       27
       +
       github.com/bluekeyes/go-gitdiff v0.8.1 h1:lL1GofKMywO17c0lgQmJYcKek5+s8X6tXVNOLxy4smI=

     

       28
       28
       +
       github.com/bluekeyes/go-gitdiff v0.8.1/go.mod h1:WWAk1Mc6EgWarCrPFO+xeYlujPu98VuLW3Tu+B/85AE=

     

       29
       29
        
       github.com/bluesky-social/indigo v0.0.0-20250123072624-9e3b84fdbb20 h1:yHusfYYi8odoCcsI6AurU+dRWb7itHAQNwt3/Rl9Vfs=

     

       30
       30
        
       github.com/bluesky-social/indigo v0.0.0-20250123072624-9e3b84fdbb20/go.mod h1:Qp4YqWf+AQ3TwQCxV5Ls8O2tXE55zVTGVs3zTmn7BOg=

     

       31
       31
        
       github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1 h1:CFvRtYNSnWRAi/98M3O466t9dYuwtesNbu6FVPymRrA=

     
···

       34
       34
        
       github.com/bmatcuk/doublestar/v4 v4.7.1 h1:fdDeAqgT47acgwd9bd9HxJRDmc9UAmPpc+2m0CXv75Q=

     

       35
       35
        
       github.com/bmatcuk/doublestar/v4 v4.7.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       36
       36
        
       github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=

     

       37
       37
       -
       github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=

     

       38
       37
        
       github.com/carlmjohnson/versioninfo v0.22.5 h1:O00sjOLUAFxYQjlN/bzYTuZiS0y6fWDQjMRvwtKgwwc=

     

       39
       38
        
       github.com/carlmjohnson/versioninfo v0.22.5/go.mod h1:QT9mph3wcVfISUKd0i9sZfVrPviHuSF+cUtLjm2WSf8=

     

       40
       39
        
       github.com/casbin/casbin/v2 v2.100.0/go.mod h1:LO7YPez4dX3LgoTCqSQAleQDo0S0BeZBDxYnPUl95Ng=

     
···

       46
       45
        
       github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=

     

       47
       46
        
       github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=

     

       48
       47
        
       github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I=

     

       49
       49
       -
       github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=

     

       50
       50
       -
       github.com/cloudflare/circl v1.4.0 h1:BV7h5MgrktNzytKmWjpOtdYrf0lkkbF8YMlBGPhJQrY=

     

       51
       51
       -
       github.com/cloudflare/circl v1.4.0/go.mod h1:PDRU+oXvdD7KCtgKxW95M5Z8BpSCJXQORiZFnBQS5QU=

     

       48
       48
       +
       github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk=

     

       49
       49
       +
       github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=

     

       52
       50
        
       github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=

     

       53
       51
        
       github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=

     

       54
       54
       -
       github.com/cyphar/filepath-securejoin v0.3.3 h1:lofZkCEVFIBe0KcdQOzFs8Soy9oaHOWl4gGtPI+gCFc=

     

       55
       55
       -
       github.com/cyphar/filepath-securejoin v0.3.3/go.mod h1:8s/MCNJREmFK0H02MF6Ihv1nakJe4L/w3WZLHNkvlYM=

     

       52
       52
       +
       github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=

     

       53
       53
       +
       github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=

     

       56
       54
        
       github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       57
       55
        
       github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       58
       56
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     
···

       77
       75
        
       github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=

     

       78
       76
        
       github.com/go-git/go-billy/v5 v5.3.1/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0=

     

       79
       77
        
       github.com/go-git/go-billy/v5 v5.4.1/go.mod h1:vjbugF6Fz7JIflbVpl1hJsGjSHNltrSw45YK/ukIvQg=

     

       80
       80
       -
       github.com/go-git/go-billy/v5 v5.5.0 h1:yEY4yhzCDuMGSv83oGxiBotRzhwhNr8VZyphhiu+mTU=

     

       81
       81
       -
       github.com/go-git/go-billy/v5 v5.5.0/go.mod h1:hmexnoNsr2SJU1Ju67OaNz5ASJY3+sHgFRpCtpDCKow=

     

       78
       78
       +
       github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=

     

       79
       79
       +
       github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=

     

       82
       80
        
       github.com/go-git/go-git-fixtures/v4 v4.3.1 h1:y5z6dd3qi8Hl+stezc8p3JxDkoTRqMAlKnXHuzrfjTQ=

     

       83
       81
        
       github.com/go-git/go-git-fixtures/v4 v4.3.1/go.mod h1:8LHG1a3SRW71ettAD/jW13h8c6AqjVSeL11RAdgaqpo=

     

       84
       82
        
       github.com/go-git/go-git/v5 v5.6.1 h1:q4ZRqQl4pR/ZJHc1L5CFjGA1a10u76aV1iC+nh+bHsk=

     
···

       204
       202
        
       github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=

     

       205
       203
        
       github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=

     

       206
       204
        
       github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=

     

       207
       207
       -
       github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=

     

       208
       208
       -
       github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=

     

       205
       205
       +
       github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=

     

       206
       206
       +
       github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=

     

       209
       207
        
       github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=

     

       210
       208
        
       github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=

     

       211
       211
       -
       github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=

     

       212
       209
        
       github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=

     

       210
       210
       +
       github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=

     

       211
       211
       +
       github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=

     

       213
       212
        
       github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

     

       214
       213
        
       github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=

     

       215
       214
        
       github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

     
···

       236
       235
        
       github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=

     

       237
       236
        
       github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=

     

       238
       237
        
       github.com/skeema/knownhosts v1.1.0/go.mod h1:sKFq3RD6/TKZkSWn8boUbDC7Qkgcv+8XXijpFO6roag=

     

       239
       239
       -
       github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=

     

       240
       240
       -
       github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=

     

       238
       238
       +
       github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=

     

       239
       239
       +
       github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=

     

       241
       240
        
       github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=

     

       242
       241
        
       github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=

     

       243
       242
        
       github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=

     
···

       249
       248
        
       github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

     

       250
       249
        
       github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=

     

       251
       250
        
       github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=

     

       252
       252
       -
       github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=

     

       253
       253
       -
       github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       251
       251
       +
       github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=

     

       252
       252
       +
       github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       254
       253
        
       github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=

     

       255
       254
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0 h1:GDDkbFiaK8jsSDJfjId/PEGEShv6ugrt4kYsC5UIDaQ=

     

       256
       255
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=

     
···

       301
       300
        
       golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

     

       302
       301
        
       golang.org/x/crypto v0.0.0-20220826181053-bd7e27e6170d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

     

       303
       302
        
       golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=

     

       304
       304
       -
       golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=

     

       305
       303
        
       golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=

     

       306
       306
       -
       golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=

     

       307
       307
       -
       golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=

     

       308
       308
       -
       golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=

     

       304
       304
       +
       golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=

     

       305
       305
       +
       golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=

     

       306
       306
       +
       golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=

     

       307
       307
       +
       golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=

     

       309
       308
        
       golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=

     

       310
       309
        
       golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=

     

       311
       310
        
       golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     
···

       313
       312
        
       golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       314
       313
        
       golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=

     

       315
       314
        
       golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI=

     

       316
       316
       -
       golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=

     

       317
       315
        
       golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       318
       316
        
       golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       319
       317
        
       golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     
···

       325
       323
        
       golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=

     

       326
       324
        
       golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=

     

       327
       325
        
       golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=

     

       328
       328
       -
       golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=

     

       329
       326
        
       golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=

     

       330
       327
        
       golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=

     

       331
       331
       -
       golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=

     

       332
       332
       -
       golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=

     

       333
       333
       -
       golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=

     

       328
       328
       +
       golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=

     

       329
       329
       +
       golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=

     

       334
       330
        
       golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       335
       331
        
       golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       336
       332
        
       golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       337
       333
        
       golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       338
       334
        
       golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       339
       339
       -
       golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       340
       335
        
       golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

     

       341
       336
        
       golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       342
       337
        
       golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     
···

       357
       352
        
       golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       358
       353
        
       golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       359
       354
        
       golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       360
       360
       -
       golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       361
       355
        
       golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       362
       356
        
       golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       363
       357
        
       golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       364
       364
       -
       golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=

     

       365
       365
       -
       golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

     

       358
       358
       +
       golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=

     

       359
       359
       +
       golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

     

       366
       360
        
       golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

     

       367
       361
        
       golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

     

       368
       362
        
       golang.org/x/term v0.0.0-20220722155259-a9ba230a4035/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

     

       369
       363
        
       golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

     

       370
       370
       -
       golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=

     

       371
       364
        
       golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=

     

       372
       372
       -
       golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=

     

       373
       373
       -
       golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=

     

       374
       374
       -
       golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=

     

       365
       365
       +
       golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=

     

       366
       366
       +
       golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=

     

       375
       367
        
       golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

     

       376
       368
        
       golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       377
       369
        
       golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       378
       370
        
       golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=

     

       379
       371
        
       golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=

     

       380
       372
        
       golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=

     

       381
       381
       -
       golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=

     

       382
       382
       -
       golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=

     

       383
       383
       -
       golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=

     

       373
       373
       +
       golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=

     

       374
       374
       +
       golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=

     

       384
       375
        
       golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=

     

       385
       376
        
       golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=

     

       386
       377
        
       golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

     
···

       396
       387
        
       golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=

     

       397
       388
        
       golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

     

       398
       389
        
       golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA=

     

       399
       399
       -
       golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=

     

       400
       390
        
       golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       401
       391
        
       golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       402
       392
        
       golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

+12

lexicons/pulls/closed.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.state.closed",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "token",

     

       9
       9
       +
             "description": "closed pull request"

     

       10
       10
       +
           }

     

       11
       11
       +
         }

     

       12
       12
       +
       }

+40

lexicons/pulls/comment.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.comment",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "record",

     

       9
       9
       +
             "key": "tid",

     

       10
       10
       +
             "record": {

     

       11
       11
       +
               "type": "object",

     

       12
       12
       +
               "required": ["pull"],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "pull": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "format": "at-uri"

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "repo": {

     

       19
       19
       +
                   "type": "string",

     

       20
       20
       +
                   "format": "at-uri"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "commentId": {

     

       23
       23
       +
                   "type": "integer"

     

       24
       24
       +
                 },

     

       25
       25
       +
                 "owner": {

     

       26
       26
       +
                   "type": "string",

     

       27
       27
       +
                   "format": "did"

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "body": {

     

       30
       30
       +
                   "type": "string"

     

       31
       31
       +
                 },

     

       32
       32
       +
                 "createdAt": {

     

       33
       33
       +
                   "type": "string",

     

       34
       34
       +
                   "format": "datetime"

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             }

     

       38
       38
       +
           }

     

       39
       39
       +
         }

     

       40
       40
       +
       }

+12

lexicons/pulls/merged.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.state.merged",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "token",

     

       9
       9
       +
             "description": "merged pull request"

     

       10
       10
       +
           }

     

       11
       11
       +
         }

     

       12
       12
       +
       }

+12

lexicons/pulls/open.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.state.open",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "token",

     

       9
       9
       +
             "description": "open pull request"

     

       10
       10
       +
           }

     

       11
       11
       +
         }

     

       12
       12
       +
       }

+42

lexicons/pulls/patch.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.patch",

     

       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": ["targetRepo", "pullId", "title", "patch"],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "targetRepo": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "format": "at-uri"

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "sourceRepo": {

     

       19
       19
       +
                   "type": "string",

     

       20
       20
       +
                   "format": "at-uri"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "pullId": {

     

       23
       23
       +
                   "type": "integer"

     

       24
       24
       +
                 },

     

       25
       25
       +
                 "title": {

     

       26
       26
       +
                   "type": "string"

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "body": {

     

       29
       29
       +
                   "type": "string"

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "createdAt": {

     

       32
       32
       +
                   "type": "string",

     

       33
       33
       +
                   "format": "datetime"

     

       34
       34
       +
                 },

     

       35
       35
       +
                 "patch": {

     

       36
       36
       +
                   "type": "string"

     

       37
       37
       +
                 }

     

       38
       38
       +
               }

     

       39
       39
       +
             }

     

       40
       40
       +
           }

     

       41
       41
       +
         }

     

       42
       42
       +
       }

+32

lexicons/pulls/state.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.state",

     

       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": ["pull"],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "pull": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "format": "at-uri"

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "state": {

     

       19
       19
       +
                   "type": "string",

     

       20
       20
       +
                   "description": "state of the pull request",

     

       21
       21
       +
                   "knownValues": [

     

       22
       22
       +
                     "sh.tangled.repo.pull.state.open",

     

       23
       23
       +
                     "sh.tangled.repo.pull.state.closed",

     

       24
       24
       +
                     "sh.tangled.repo.pull.state.merged"

     

       25
       25
       +
                   ],

     

       26
       26
       +
                   "default": "sh.tangled.repo.pull.state.open"

     

       27
       27
       +
                 }

     

       28
       28
       +
               }

     

       29
       29
       +
             }

     

       30
       30
       +
           }

     

       31
       31
       +
         }

     

       32
       32
       +
       }