+358 -136

api/tangled/cbor_gen.go

reviewed

··· 2460 2460 2461 2461 return nil 2462 2462 } 2463 2463 + func (t *GraphVouch) MarshalCBOR(w io.Writer) error { 2464 2464 + if t == nil { 2465 2465 + _, err := w.Write(cbg.CborNull) 2466 2466 + return err 2467 2467 + } 2468 2468 + 2469 2469 + cw := cbg.NewCborWriter(w) 2470 2470 + fieldCount := 4 2471 2471 + 2472 2472 + if t.Reason == nil { 2473 2473 + fieldCount-- 2474 2474 + } 2475 2475 + 2476 2476 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2477 2477 + return err 2478 2478 + } 2479 2479 + 2480 2480 + // t.Kind (string) (string) 2481 2481 + if len("kind") > 1000000 { 2482 2482 + return xerrors.Errorf("Value in field \"kind\" was too long") 2483 2483 + } 2484 2484 + 2485 2485 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil { 2486 2486 + return err 2487 2487 + } 2488 2488 + if _, err := cw.WriteString(string("kind")); err != nil { 2489 2489 + return err 2490 2490 + } 2491 2491 + 2492 2492 + if len(t.Kind) > 1000000 { 2493 2493 + return xerrors.Errorf("Value in field t.Kind was too long") 2494 2494 + } 2495 2495 + 2496 2496 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil { 2497 2497 + return err 2498 2498 + } 2499 2499 + if _, err := cw.WriteString(string(t.Kind)); err != nil { 2500 2500 + return err 2501 2501 + } 2502 2502 + 2503 2503 + // t.LexiconTypeID (string) (string) 2504 2504 + if len("$type") > 1000000 { 2505 2505 + return xerrors.Errorf("Value in field \"$type\" was too long") 2506 2506 + } 2507 2507 + 2508 2508 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2509 2509 + return err 2510 2510 + } 2511 2511 + if _, err := cw.WriteString(string("$type")); err != nil { 2512 2512 + return err 2513 2513 + } 2514 2514 + 2515 2515 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.vouch"))); err != nil { 2516 2516 + return err 2517 2517 + } 2518 2518 + if _, err := cw.WriteString(string("sh.tangled.graph.vouch")); err != nil { 2519 2519 + return err 2520 2520 + } 2521 2521 + 2522 2522 + // t.Reason (string) (string) 2523 2523 + if t.Reason != nil { 2524 2524 + 2525 2525 + if len("reason") > 1000000 { 2526 2526 + return xerrors.Errorf("Value in field \"reason\" was too long") 2527 2527 + } 2528 2528 + 2529 2529 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reason"))); err != nil { 2530 2530 + return err 2531 2531 + } 2532 2532 + if _, err := cw.WriteString(string("reason")); err != nil { 2533 2533 + return err 2534 2534 + } 2535 2535 + 2536 2536 + if t.Reason == nil { 2537 2537 + if _, err := cw.Write(cbg.CborNull); err != nil { 2538 2538 + return err 2539 2539 + } 2540 2540 + } else { 2541 2541 + if len(*t.Reason) > 1000000 { 2542 2542 + return xerrors.Errorf("Value in field t.Reason was too long") 2543 2543 + } 2544 2544 + 2545 2545 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Reason))); err != nil { 2546 2546 + return err 2547 2547 + } 2548 2548 + if _, err := cw.WriteString(string(*t.Reason)); err != nil { 2549 2549 + return err 2550 2550 + } 2551 2551 + } 2552 2552 + } 2553 2553 + 2554 2554 + // t.CreatedAt (string) (string) 2555 2555 + if len("createdAt") > 1000000 { 2556 2556 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2557 2557 + } 2558 2558 + 2559 2559 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2560 2560 + return err 2561 2561 + } 2562 2562 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2563 2563 + return err 2564 2564 + } 2565 2565 + 2566 2566 + if len(t.CreatedAt) > 1000000 { 2567 2567 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2568 2568 + } 2569 2569 + 2570 2570 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2571 2571 + return err 2572 2572 + } 2573 2573 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2574 2574 + return err 2575 2575 + } 2576 2576 + return nil 2577 2577 + } 2578 2578 + 2579 2579 + func (t *GraphVouch) UnmarshalCBOR(r io.Reader) (err error) { 2580 2580 + *t = GraphVouch{} 2581 2581 + 2582 2582 + cr := cbg.NewCborReader(r) 2583 2583 + 2584 2584 + maj, extra, err := cr.ReadHeader() 2585 2585 + if err != nil { 2586 2586 + return err 2587 2587 + } 2588 2588 + defer func() { 2589 2589 + if err == io.EOF { 2590 2590 + err = io.ErrUnexpectedEOF 2591 2591 + } 2592 2592 + }() 2593 2593 + 2594 2594 + if maj != cbg.MajMap { 2595 2595 + return fmt.Errorf("cbor input should be of type map") 2596 2596 + } 2597 2597 + 2598 2598 + if extra > cbg.MaxLength { 2599 2599 + return fmt.Errorf("GraphVouch: map struct too large (%d)", extra) 2600 2600 + } 2601 2601 + 2602 2602 + n := extra 2603 2603 + 2604 2604 + nameBuf := make([]byte, 9) 2605 2605 + for i := uint64(0); i < n; i++ { 2606 2606 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2607 2607 + if err != nil { 2608 2608 + return err 2609 2609 + } 2610 2610 + 2611 2611 + if !ok { 2612 2612 + // Field doesn't exist on this type, so ignore it 2613 2613 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2614 2614 + return err 2615 2615 + } 2616 2616 + continue 2617 2617 + } 2618 2618 + 2619 2619 + switch string(nameBuf[:nameLen]) { 2620 2620 + // t.Kind (string) (string) 2621 2621 + case "kind": 2622 2622 + 2623 2623 + { 2624 2624 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2625 2625 + if err != nil { 2626 2626 + return err 2627 2627 + } 2628 2628 + 2629 2629 + t.Kind = string(sval) 2630 2630 + } 2631 2631 + // t.LexiconTypeID (string) (string) 2632 2632 + case "$type": 2633 2633 + 2634 2634 + { 2635 2635 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2636 2636 + if err != nil { 2637 2637 + return err 2638 2638 + } 2639 2639 + 2640 2640 + t.LexiconTypeID = string(sval) 2641 2641 + } 2642 2642 + // t.Reason (string) (string) 2643 2643 + case "reason": 2644 2644 + 2645 2645 + { 2646 2646 + b, err := cr.ReadByte() 2647 2647 + if err != nil { 2648 2648 + return err 2649 2649 + } 2650 2650 + if b != cbg.CborNull[0] { 2651 2651 + if err := cr.UnreadByte(); err != nil { 2652 2652 + return err 2653 2653 + } 2654 2654 + 2655 2655 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2656 2656 + if err != nil { 2657 2657 + return err 2658 2658 + } 2659 2659 + 2660 2660 + t.Reason = (*string)(&sval) 2661 2661 + } 2662 2662 + } 2663 2663 + // t.CreatedAt (string) (string) 2664 2664 + case "createdAt": 2665 2665 + 2666 2666 + { 2667 2667 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2668 2668 + if err != nil { 2669 2669 + return err 2670 2670 + } 2671 2671 + 2672 2672 + t.CreatedAt = string(sval) 2673 2673 + } 2674 2674 + 2675 2675 + default: 2676 2676 + // Field doesn't exist on this type, so ignore it 2677 2677 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2678 2678 + return err 2679 2679 + } 2680 2680 + } 2681 2681 + } 2682 2682 + 2683 2683 + return nil 2684 2684 + } 2463 2685 func (t *Knot) MarshalCBOR(w io.Writer) error { 2464 2686 if t == nil { 2465 2687 _, err := w.Write(cbg.CborNull) ··· 9520 9742 9521 9743 return nil 9522 9744 } 9745 9745 + func (t *RepoPull_Round) MarshalCBOR(w io.Writer) error { 9746 9746 + if t == nil { 9747 9747 + _, err := w.Write(cbg.CborNull) 9748 9748 + return err 9749 9749 + } 9750 9750 + 9751 9751 + cw := cbg.NewCborWriter(w) 9752 9752 + 9753 9753 + if _, err := cw.Write([]byte{162}); err != nil { 9754 9754 + return err 9755 9755 + } 9756 9756 + 9757 9757 + // t.CreatedAt (string) (string) 9758 9758 + if len("createdAt") > 1000000 { 9759 9759 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 9760 9760 + } 9761 9761 + 9762 9762 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 9763 9763 + return err 9764 9764 + } 9765 9765 + if _, err := cw.WriteString(string("createdAt")); err != nil { 9766 9766 + return err 9767 9767 + } 9768 9768 + 9769 9769 + if len(t.CreatedAt) > 1000000 { 9770 9770 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 9771 9771 + } 9772 9772 + 9773 9773 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 9774 9774 + return err 9775 9775 + } 9776 9776 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 9777 9777 + return err 9778 9778 + } 9779 9779 + 9780 9780 + // t.PatchBlob (util.LexBlob) (struct) 9781 9781 + if len("patchBlob") > 1000000 { 9782 9782 + return xerrors.Errorf("Value in field \"patchBlob\" was too long") 9783 9783 + } 9784 9784 + 9785 9785 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil { 9786 9786 + return err 9787 9787 + } 9788 9788 + if _, err := cw.WriteString(string("patchBlob")); err != nil { 9789 9789 + return err 9790 9790 + } 9791 9791 + 9792 9792 + if err := t.PatchBlob.MarshalCBOR(cw); err != nil { 9793 9793 + return err 9794 9794 + } 9795 9795 + return nil 9796 9796 + } 9797 9797 + 9798 9798 + func (t *RepoPull_Round) UnmarshalCBOR(r io.Reader) (err error) { 9799 9799 + *t = RepoPull_Round{} 9800 9800 + 9801 9801 + cr := cbg.NewCborReader(r) 9802 9802 + 9803 9803 + maj, extra, err := cr.ReadHeader() 9804 9804 + if err != nil { 9805 9805 + return err 9806 9806 + } 9807 9807 + defer func() { 9808 9808 + if err == io.EOF { 9809 9809 + err = io.ErrUnexpectedEOF 9810 9810 + } 9811 9811 + }() 9812 9812 + 9813 9813 + if maj != cbg.MajMap { 9814 9814 + return fmt.Errorf("cbor input should be of type map") 9815 9815 + } 9816 9816 + 9817 9817 + if extra > cbg.MaxLength { 9818 9818 + return fmt.Errorf("RepoPull_Round: map struct too large (%d)", extra) 9819 9819 + } 9820 9820 + 9821 9821 + n := extra 9822 9822 + 9823 9823 + nameBuf := make([]byte, 9) 9824 9824 + for i := uint64(0); i < n; i++ { 9825 9825 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9826 9826 + if err != nil { 9827 9827 + return err 9828 9828 + } 9829 9829 + 9830 9830 + if !ok { 9831 9831 + // Field doesn't exist on this type, so ignore it 9832 9832 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 9833 9833 + return err 9834 9834 + } 9835 9835 + continue 9836 9836 + } 9837 9837 + 9838 9838 + switch string(nameBuf[:nameLen]) { 9839 9839 + // t.CreatedAt (string) (string) 9840 9840 + case "createdAt": 9841 9841 + 9842 9842 + { 9843 9843 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 9844 9844 + if err != nil { 9845 9845 + return err 9846 9846 + } 9847 9847 + 9848 9848 + t.CreatedAt = string(sval) 9849 9849 + } 9850 9850 + // t.PatchBlob (util.LexBlob) (struct) 9851 9851 + case "patchBlob": 9852 9852 + 9853 9853 + { 9854 9854 + 9855 9855 + b, err := cr.ReadByte() 9856 9856 + if err != nil { 9857 9857 + return err 9858 9858 + } 9859 9859 + if b != cbg.CborNull[0] { 9860 9860 + if err := cr.UnreadByte(); err != nil { 9861 9861 + return err 9862 9862 + } 9863 9863 + t.PatchBlob = new(util.LexBlob) 9864 9864 + if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil { 9865 9865 + return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err) 9866 9866 + } 9867 9867 + } 9868 9868 + 9869 9869 + } 9870 9870 + 9871 9871 + default: 9872 9872 + // Field doesn't exist on this type, so ignore it 9873 9873 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 9874 9874 + return err 9875 9875 + } 9876 9876 + } 9877 9877 + } 9878 9878 + 9879 9879 + return nil 9880 9880 + } 9523 9881 func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error { 9524 9882 if t == nil { 9525 9883 _, err := w.Write(cbg.CborNull) ··· 9723 10081 9724 10082 t.RepoDid = (*string)(&sval) 9725 10083 } 9726 9726 - } 9727 9727 - 9728 9728 - default: 9729 9729 - // Field doesn't exist on this type, so ignore it 9730 9730 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 9731 9731 - return err 9732 9732 - } 9733 9733 - } 9734 9734 - } 9735 9735 - 9736 9736 - return nil 9737 9737 - } 9738 9738 - func (t *RepoPull_Round) MarshalCBOR(w io.Writer) error { 9739 9739 - if t == nil { 9740 9740 - _, err := w.Write(cbg.CborNull) 9741 9741 - return err 9742 9742 - } 9743 9743 - 9744 9744 - cw := cbg.NewCborWriter(w) 9745 9745 - 9746 9746 - if _, err := cw.Write([]byte{162}); err != nil { 9747 9747 - return err 9748 9748 - } 9749 9749 - 9750 9750 - // t.CreatedAt (string) (string) 9751 9751 - if len("createdAt") > 1000000 { 9752 9752 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 9753 9753 - } 9754 9754 - 9755 9755 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 9756 9756 - return err 9757 9757 - } 9758 9758 - if _, err := cw.WriteString(string("createdAt")); err != nil { 9759 9759 - return err 9760 9760 - } 9761 9761 - 9762 9762 - if len(t.CreatedAt) > 1000000 { 9763 9763 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 9764 9764 - } 9765 9765 - 9766 9766 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 9767 9767 - return err 9768 9768 - } 9769 9769 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 9770 9770 - return err 9771 9771 - } 9772 9772 - 9773 9773 - // t.PatchBlob (util.LexBlob) (struct) 9774 9774 - if len("patchBlob") > 1000000 { 9775 9775 - return xerrors.Errorf("Value in field \"patchBlob\" was too long") 9776 9776 - } 9777 9777 - 9778 9778 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil { 9779 9779 - return err 9780 9780 - } 9781 9781 - if _, err := cw.WriteString(string("patchBlob")); err != nil { 9782 9782 - return err 9783 9783 - } 9784 9784 - 9785 9785 - if err := t.PatchBlob.MarshalCBOR(cw); err != nil { 9786 9786 - return err 9787 9787 - } 9788 9788 - return nil 9789 9789 - } 9790 9790 - 9791 9791 - func (t *RepoPull_Round) UnmarshalCBOR(r io.Reader) (err error) { 9792 9792 - *t = RepoPull_Round{} 9793 9793 - 9794 9794 - cr := cbg.NewCborReader(r) 9795 9795 - 9796 9796 - maj, extra, err := cr.ReadHeader() 9797 9797 - if err != nil { 9798 9798 - return err 9799 9799 - } 9800 9800 - defer func() { 9801 9801 - if err == io.EOF { 9802 9802 - err = io.ErrUnexpectedEOF 9803 9803 - } 9804 9804 - }() 9805 9805 - 9806 9806 - if maj != cbg.MajMap { 9807 9807 - return fmt.Errorf("cbor input should be of type map") 9808 9808 - } 9809 9809 - 9810 9810 - if extra > cbg.MaxLength { 9811 9811 - return fmt.Errorf("RepoPull_Round: map struct too large (%d)", extra) 9812 9812 - } 9813 9813 - 9814 9814 - n := extra 9815 9815 - 9816 9816 - nameBuf := make([]byte, 9) 9817 9817 - for i := uint64(0); i < n; i++ { 9818 9818 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9819 9819 - if err != nil { 9820 9820 - return err 9821 9821 - } 9822 9822 - 9823 9823 - if !ok { 9824 9824 - // Field doesn't exist on this type, so ignore it 9825 9825 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 9826 9826 - return err 9827 9827 - } 9828 9828 - continue 9829 9829 - } 9830 9830 - 9831 9831 - switch string(nameBuf[:nameLen]) { 9832 9832 - // t.CreatedAt (string) (string) 9833 9833 - case "createdAt": 9834 9834 - 9835 9835 - { 9836 9836 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 9837 9837 - if err != nil { 9838 9838 - return err 9839 9839 - } 9840 9840 - 9841 9841 - t.CreatedAt = string(sval) 9842 9842 - } 9843 9843 - // t.PatchBlob (util.LexBlob) (struct) 9844 9844 - case "patchBlob": 9845 9845 - 9846 9846 - { 9847 9847 - 9848 9848 - b, err := cr.ReadByte() 9849 9849 - if err != nil { 9850 9850 - return err 9851 9851 - } 9852 9852 - if b != cbg.CborNull[0] { 9853 9853 - if err := cr.UnreadByte(); err != nil { 9854 9854 - return err 9855 9855 - } 9856 9856 - t.PatchBlob = new(util.LexBlob) 9857 9857 - if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil { 9858 9858 - return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err) 9859 9859 - } 9860 9860 - } 9861 9861 - 9862 10084 } 9863 10085 9864 10086 default:

+26

api/tangled/graphvouch.go

reviewed

··· 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.graph.vouch 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + GraphVouchNSID = "sh.tangled.graph.vouch" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.graph.vouch", &GraphVouch{}) 17 17 + } // 18 18 + // RECORDTYPE: GraphVouch 19 19 + type GraphVouch struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.graph.vouch" cborgen:"$type,const=sh.tangled.graph.vouch"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 + // kind: Whether this user is being vouched for or denounced 23 23 + Kind string `json:"kind" cborgen:"kind"` 24 24 + // reason: The reason for this vouch/denouncement 25 25 + Reason *string `json:"reason,omitempty" cborgen:"reason,omitempty"` 26 26 + }

+2 -1

cmd/cborgen/cborgen.go

reviewed

··· 24 24 tangled.GitRefUpdate_LangBreakdown{}, 25 25 tangled.GitRefUpdate_Meta{}, 26 26 tangled.GraphFollow{}, 27 27 + tangled.GraphVouch{}, 27 28 tangled.Knot{}, 28 29 tangled.KnotMember{}, 29 30 tangled.LabelDefinition{}, ··· 49 50 tangled.RepoIssueState{}, 50 51 tangled.RepoPull{}, 51 52 tangled.RepoPullComment{}, 52 52 - tangled.RepoPull_Source{}, 53 53 tangled.RepoPull_Round{}, 54 54 + tangled.RepoPull_Source{}, 54 55 tangled.RepoPullStatus{}, 55 56 tangled.RepoPull_Target{}, 56 57 tangled.Spindle{},

+38

lexicons/graph/vouch.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.graph.vouch", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "any", 10 10 + "record": { 11 11 + "type": "object", 12 12 + "required": [ 13 13 + "kind", 14 14 + "createdAt" 15 15 + ], 16 16 + "properties": { 17 17 + "kind": { 18 18 + "type": "string", 19 19 + "description": "Whether this user is being vouched for or denounced", 20 20 + "enum": ["vouch", "denounce"], 21 21 + "default": "vouch" 22 22 + }, 23 23 + "reason": { 24 24 + "type": "string", 25 25 + "description": "The reason for this vouch/denouncement", 26 26 + "maxGraphemes": 256, 27 27 + "maxLength": 2560 28 28 + }, 29 29 + "createdAt": { 30 30 + "type": "string", 31 31 + "format": "datetime" 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 +