+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"

+9

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 + }

+3

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 + }