+495 -20

api/tangled/cbor_gen.go

··· 561 561 562 562 return nil 563 563 } 564 564 + func (t *Comment) MarshalCBOR(w io.Writer) error { 565 565 + if t == nil { 566 566 + _, err := w.Write(cbg.CborNull) 567 567 + return err 568 568 + } 569 569 + 570 570 + cw := cbg.NewCborWriter(w) 571 571 + fieldCount := 7 572 572 + 573 573 + if t.Mentions == nil { 574 574 + fieldCount-- 575 575 + } 576 576 + 577 577 + if t.References == nil { 578 578 + fieldCount-- 579 579 + } 580 580 + 581 581 + if t.ReplyTo == nil { 582 582 + fieldCount-- 583 583 + } 584 584 + 585 585 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 586 586 + return err 587 587 + } 588 588 + 589 589 + // t.Body (string) (string) 590 590 + if len("body") > 1000000 { 591 591 + return xerrors.Errorf("Value in field \"body\" was too long") 592 592 + } 593 593 + 594 594 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 595 595 + return err 596 596 + } 597 597 + if _, err := cw.WriteString(string("body")); err != nil { 598 598 + return err 599 599 + } 600 600 + 601 601 + if len(t.Body) > 1000000 { 602 602 + return xerrors.Errorf("Value in field t.Body was too long") 603 603 + } 604 604 + 605 605 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 606 606 + return err 607 607 + } 608 608 + if _, err := cw.WriteString(string(t.Body)); err != nil { 609 609 + return err 610 610 + } 611 611 + 612 612 + // t.LexiconTypeID (string) (string) 613 613 + if len("$type") > 1000000 { 614 614 + return xerrors.Errorf("Value in field \"$type\" was too long") 615 615 + } 616 616 + 617 617 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 618 618 + return err 619 619 + } 620 620 + if _, err := cw.WriteString(string("$type")); err != nil { 621 621 + return err 622 622 + } 623 623 + 624 624 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.comment"))); err != nil { 625 625 + return err 626 626 + } 627 627 + if _, err := cw.WriteString(string("sh.tangled.comment")); err != nil { 628 628 + return err 629 629 + } 630 630 + 631 631 + // t.ReplyTo (string) (string) 632 632 + if t.ReplyTo != nil { 633 633 + 634 634 + if len("replyTo") > 1000000 { 635 635 + return xerrors.Errorf("Value in field \"replyTo\" was too long") 636 636 + } 637 637 + 638 638 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil { 639 639 + return err 640 640 + } 641 641 + if _, err := cw.WriteString(string("replyTo")); err != nil { 642 642 + return err 643 643 + } 644 644 + 645 645 + if t.ReplyTo == nil { 646 646 + if _, err := cw.Write(cbg.CborNull); err != nil { 647 647 + return err 648 648 + } 649 649 + } else { 650 650 + if len(*t.ReplyTo) > 1000000 { 651 651 + return xerrors.Errorf("Value in field t.ReplyTo was too long") 652 652 + } 653 653 + 654 654 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil { 655 655 + return err 656 656 + } 657 657 + if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil { 658 658 + return err 659 659 + } 660 660 + } 661 661 + } 662 662 + 663 663 + // t.Subject (string) (string) 664 664 + if len("subject") > 1000000 { 665 665 + return xerrors.Errorf("Value in field \"subject\" was too long") 666 666 + } 667 667 + 668 668 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 669 669 + return err 670 670 + } 671 671 + if _, err := cw.WriteString(string("subject")); err != nil { 672 672 + return err 673 673 + } 674 674 + 675 675 + if len(t.Subject) > 1000000 { 676 676 + return xerrors.Errorf("Value in field t.Subject was too long") 677 677 + } 678 678 + 679 679 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 680 680 + return err 681 681 + } 682 682 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 683 683 + return err 684 684 + } 685 685 + 686 686 + // t.Mentions ([]string) (slice) 687 687 + if t.Mentions != nil { 688 688 + 689 689 + if len("mentions") > 1000000 { 690 690 + return xerrors.Errorf("Value in field \"mentions\" was too long") 691 691 + } 692 692 + 693 693 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 694 694 + return err 695 695 + } 696 696 + if _, err := cw.WriteString(string("mentions")); err != nil { 697 697 + return err 698 698 + } 699 699 + 700 700 + if len(t.Mentions) > 8192 { 701 701 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 702 702 + } 703 703 + 704 704 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 705 705 + return err 706 706 + } 707 707 + for _, v := range t.Mentions { 708 708 + if len(v) > 1000000 { 709 709 + return xerrors.Errorf("Value in field v was too long") 710 710 + } 711 711 + 712 712 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 713 713 + return err 714 714 + } 715 715 + if _, err := cw.WriteString(string(v)); err != nil { 716 716 + return err 717 717 + } 718 718 + 719 719 + } 720 720 + } 721 721 + 722 722 + // t.CreatedAt (string) (string) 723 723 + if len("createdAt") > 1000000 { 724 724 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 725 725 + } 726 726 + 727 727 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 728 728 + return err 729 729 + } 730 730 + if _, err := cw.WriteString(string("createdAt")); err != nil { 731 731 + return err 732 732 + } 733 733 + 734 734 + if len(t.CreatedAt) > 1000000 { 735 735 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 736 736 + } 737 737 + 738 738 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 739 739 + return err 740 740 + } 741 741 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 742 742 + return err 743 743 + } 744 744 + 745 745 + // t.References ([]string) (slice) 746 746 + if t.References != nil { 747 747 + 748 748 + if len("references") > 1000000 { 749 749 + return xerrors.Errorf("Value in field \"references\" was too long") 750 750 + } 751 751 + 752 752 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 753 753 + return err 754 754 + } 755 755 + if _, err := cw.WriteString(string("references")); err != nil { 756 756 + return err 757 757 + } 758 758 + 759 759 + if len(t.References) > 8192 { 760 760 + return xerrors.Errorf("Slice value in field t.References was too long") 761 761 + } 762 762 + 763 763 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 764 764 + return err 765 765 + } 766 766 + for _, v := range t.References { 767 767 + if len(v) > 1000000 { 768 768 + return xerrors.Errorf("Value in field v was too long") 769 769 + } 770 770 + 771 771 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 772 772 + return err 773 773 + } 774 774 + if _, err := cw.WriteString(string(v)); err != nil { 775 775 + return err 776 776 + } 777 777 + 778 778 + } 779 779 + } 780 780 + return nil 781 781 + } 782 782 + 783 783 + func (t *Comment) UnmarshalCBOR(r io.Reader) (err error) { 784 784 + *t = Comment{} 785 785 + 786 786 + cr := cbg.NewCborReader(r) 787 787 + 788 788 + maj, extra, err := cr.ReadHeader() 789 789 + if err != nil { 790 790 + return err 791 791 + } 792 792 + defer func() { 793 793 + if err == io.EOF { 794 794 + err = io.ErrUnexpectedEOF 795 795 + } 796 796 + }() 797 797 + 798 798 + if maj != cbg.MajMap { 799 799 + return fmt.Errorf("cbor input should be of type map") 800 800 + } 801 801 + 802 802 + if extra > cbg.MaxLength { 803 803 + return fmt.Errorf("Comment: map struct too large (%d)", extra) 804 804 + } 805 805 + 806 806 + n := extra 807 807 + 808 808 + nameBuf := make([]byte, 10) 809 809 + for i := uint64(0); i < n; i++ { 810 810 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 811 811 + if err != nil { 812 812 + return err 813 813 + } 814 814 + 815 815 + if !ok { 816 816 + // Field doesn't exist on this type, so ignore it 817 817 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 818 818 + return err 819 819 + } 820 820 + continue 821 821 + } 822 822 + 823 823 + switch string(nameBuf[:nameLen]) { 824 824 + // t.Body (string) (string) 825 825 + case "body": 826 826 + 827 827 + { 828 828 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 829 829 + if err != nil { 830 830 + return err 831 831 + } 832 832 + 833 833 + t.Body = string(sval) 834 834 + } 835 835 + // t.LexiconTypeID (string) (string) 836 836 + case "$type": 837 837 + 838 838 + { 839 839 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 840 840 + if err != nil { 841 841 + return err 842 842 + } 843 843 + 844 844 + t.LexiconTypeID = string(sval) 845 845 + } 846 846 + // t.ReplyTo (string) (string) 847 847 + case "replyTo": 848 848 + 849 849 + { 850 850 + b, err := cr.ReadByte() 851 851 + if err != nil { 852 852 + return err 853 853 + } 854 854 + if b != cbg.CborNull[0] { 855 855 + if err := cr.UnreadByte(); err != nil { 856 856 + return err 857 857 + } 858 858 + 859 859 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 860 860 + if err != nil { 861 861 + return err 862 862 + } 863 863 + 864 864 + t.ReplyTo = (*string)(&sval) 865 865 + } 866 866 + } 867 867 + // t.Subject (string) (string) 868 868 + case "subject": 869 869 + 870 870 + { 871 871 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 872 872 + if err != nil { 873 873 + return err 874 874 + } 875 875 + 876 876 + t.Subject = string(sval) 877 877 + } 878 878 + // t.Mentions ([]string) (slice) 879 879 + case "mentions": 880 880 + 881 881 + maj, extra, err = cr.ReadHeader() 882 882 + if err != nil { 883 883 + return err 884 884 + } 885 885 + 886 886 + if extra > 8192 { 887 887 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 888 888 + } 889 889 + 890 890 + if maj != cbg.MajArray { 891 891 + return fmt.Errorf("expected cbor array") 892 892 + } 893 893 + 894 894 + if extra > 0 { 895 895 + t.Mentions = make([]string, extra) 896 896 + } 897 897 + 898 898 + for i := 0; i < int(extra); i++ { 899 899 + { 900 900 + var maj byte 901 901 + var extra uint64 902 902 + var err error 903 903 + _ = maj 904 904 + _ = extra 905 905 + _ = err 906 906 + 907 907 + { 908 908 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 909 909 + if err != nil { 910 910 + return err 911 911 + } 912 912 + 913 913 + t.Mentions[i] = string(sval) 914 914 + } 915 915 + 916 916 + } 917 917 + } 918 918 + // t.CreatedAt (string) (string) 919 919 + case "createdAt": 920 920 + 921 921 + { 922 922 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 923 923 + if err != nil { 924 924 + return err 925 925 + } 926 926 + 927 927 + t.CreatedAt = string(sval) 928 928 + } 929 929 + // t.References ([]string) (slice) 930 930 + case "references": 931 931 + 932 932 + maj, extra, err = cr.ReadHeader() 933 933 + if err != nil { 934 934 + return err 935 935 + } 936 936 + 937 937 + if extra > 8192 { 938 938 + return fmt.Errorf("t.References: array too large (%d)", extra) 939 939 + } 940 940 + 941 941 + if maj != cbg.MajArray { 942 942 + return fmt.Errorf("expected cbor array") 943 943 + } 944 944 + 945 945 + if extra > 0 { 946 946 + t.References = make([]string, extra) 947 947 + } 948 948 + 949 949 + for i := 0; i < int(extra); i++ { 950 950 + { 951 951 + var maj byte 952 952 + var extra uint64 953 953 + var err error 954 954 + _ = maj 955 955 + _ = extra 956 956 + _ = err 957 957 + 958 958 + { 959 959 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 960 960 + if err != nil { 961 961 + return err 962 962 + } 963 963 + 964 964 + t.References[i] = string(sval) 965 965 + } 966 966 + 967 967 + } 968 968 + } 969 969 + 970 970 + default: 971 971 + // Field doesn't exist on this type, so ignore it 972 972 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 973 973 + return err 974 974 + } 975 975 + } 976 976 + } 977 977 + 978 978 + return nil 979 979 + } 564 980 func (t *FeedReaction) MarshalCBOR(w io.Writer) error { 565 981 if t == nil { 566 982 _, err := w.Write(cbg.CborNull) ··· 7934 8350 } 7935 8351 7936 8352 cw := cbg.NewCborWriter(w) 7937 7937 - fieldCount := 9 8353 8353 + fieldCount := 10 7938 8354 7939 8355 if t.Body == nil { 7940 8356 fieldCount-- 7941 8357 } 7942 8358 7943 8359 if t.Mentions == nil { 8360 8360 + fieldCount-- 8361 8361 + } 8362 8362 + 8363 8363 + if t.Patch == nil { 7944 8364 fieldCount-- 7945 8365 } 7946 8366 ··· 8008 8428 } 8009 8429 8010 8430 // t.Patch (string) (string) 8011 8011 - if len("patch") > 1000000 { 8012 8012 - return xerrors.Errorf("Value in field \"patch\" was too long") 8013 8013 - } 8431 8431 + if t.Patch != nil { 8014 8432 8015 8015 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 8016 8016 - return err 8017 8017 - } 8018 8018 - if _, err := cw.WriteString(string("patch")); err != nil { 8019 8019 - return err 8020 8020 - } 8433 8433 + if len("patch") > 1000000 { 8434 8434 + return xerrors.Errorf("Value in field \"patch\" was too long") 8435 8435 + } 8021 8436 8022 8022 - if len(t.Patch) > 1000000 { 8023 8023 - return xerrors.Errorf("Value in field t.Patch was too long") 8024 8024 - } 8437 8437 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil { 8438 8438 + return err 8439 8439 + } 8440 8440 + if _, err := cw.WriteString(string("patch")); err != nil { 8441 8441 + return err 8442 8442 + } 8443 8443 + 8444 8444 + if t.Patch == nil { 8445 8445 + if _, err := cw.Write(cbg.CborNull); err != nil { 8446 8446 + return err 8447 8447 + } 8448 8448 + } else { 8449 8449 + if len(*t.Patch) > 1000000 { 8450 8450 + return xerrors.Errorf("Value in field t.Patch was too long") 8451 8451 + } 8025 8452 8026 8026 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil { 8027 8027 - return err 8028 8028 - } 8029 8029 - if _, err := cw.WriteString(string(t.Patch)); err != nil { 8030 8030 - return err 8453 8453 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Patch))); err != nil { 8454 8454 + return err 8455 8455 + } 8456 8456 + if _, err := cw.WriteString(string(*t.Patch)); err != nil { 8457 8457 + return err 8458 8458 + } 8459 8459 + } 8031 8460 } 8032 8461 8033 8462 // t.Title (string) (string) ··· 8147 8576 return err 8148 8577 } 8149 8578 8579 8579 + // t.PatchBlob (util.LexBlob) (struct) 8580 8580 + if len("patchBlob") > 1000000 { 8581 8581 + return xerrors.Errorf("Value in field \"patchBlob\" was too long") 8582 8582 + } 8583 8583 + 8584 8584 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil { 8585 8585 + return err 8586 8586 + } 8587 8587 + if _, err := cw.WriteString(string("patchBlob")); err != nil { 8588 8588 + return err 8589 8589 + } 8590 8590 + 8591 8591 + if err := t.PatchBlob.MarshalCBOR(cw); err != nil { 8592 8592 + return err 8593 8593 + } 8594 8594 + 8150 8595 // t.References ([]string) (slice) 8151 8596 if t.References != nil { 8152 8597 ··· 8262 8707 case "patch": 8263 8708 8264 8709 { 8265 8265 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 8710 8710 + b, err := cr.ReadByte() 8266 8711 if err != nil { 8267 8712 return err 8268 8713 } 8714 8714 + if b != cbg.CborNull[0] { 8715 8715 + if err := cr.UnreadByte(); err != nil { 8716 8716 + return err 8717 8717 + } 8269 8718 8270 8270 - t.Patch = string(sval) 8719 8719 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8720 8720 + if err != nil { 8721 8721 + return err 8722 8722 + } 8723 8723 + 8724 8724 + t.Patch = (*string)(&sval) 8725 8725 + } 8271 8726 } 8272 8727 // t.Title (string) (string) 8273 8728 case "title": ··· 8370 8825 } 8371 8826 8372 8827 t.CreatedAt = string(sval) 8828 8828 + } 8829 8829 + // t.PatchBlob (util.LexBlob) (struct) 8830 8830 + case "patchBlob": 8831 8831 + 8832 8832 + { 8833 8833 + 8834 8834 + b, err := cr.ReadByte() 8835 8835 + if err != nil { 8836 8836 + return err 8837 8837 + } 8838 8838 + if b != cbg.CborNull[0] { 8839 8839 + if err := cr.UnreadByte(); err != nil { 8840 8840 + return err 8841 8841 + } 8842 8842 + t.PatchBlob = new(util.LexBlob) 8843 8843 + if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil { 8844 8844 + return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err) 8845 8845 + } 8846 8846 + } 8847 8847 + 8373 8848 } 8374 8849 // t.References ([]string) (slice) 8375 8850 case "references":

+12 -9

api/tangled/repopull.go

··· 17 17 } // 18 18 // RECORDTYPE: RepoPull 19 19 type RepoPull struct { 20 20 - LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"` 21 21 - Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 - CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 - Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 - Patch string `json:"patch" cborgen:"patch"` 25 25 - References []string `json:"references,omitempty" cborgen:"references,omitempty"` 26 26 - Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 27 27 - Target *RepoPull_Target `json:"target" cborgen:"target"` 28 28 - Title string `json:"title" cborgen:"title"` 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"` 21 21 + Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 + // patch: (deprecated) use patchBlob instead 25 25 + Patch *string `json:"patch,omitempty" cborgen:"patch,omitempty"` 26 26 + // patchBlob: patch content 27 27 + PatchBlob *util.LexBlob `json:"patchBlob" cborgen:"patchBlob"` 28 28 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 29 29 + Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 30 30 + Target *RepoPull_Target `json:"target" cborgen:"target"` 31 31 + Title string `json:"title" cborgen:"title"` 29 32 } 30 33 31 34 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.

+27

api/tangled/tangledcomment.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.comment 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + CommentNSID = "sh.tangled.comment" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.comment", &Comment{}) 17 17 + } // 18 18 + // RECORDTYPE: Comment 19 19 + type Comment struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.comment" cborgen:"$type,const=sh.tangled.comment"` 21 21 + Body string `json:"body" cborgen:"body"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 25 25 + ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 26 26 + Subject string `json:"subject" cborgen:"subject"` 27 27 + }

+199

appview/db/comments.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "fmt" 6 6 + "maps" 7 7 + "slices" 8 8 + "sort" 9 9 + "strings" 10 10 + "time" 11 11 + 12 12 + "github.com/bluesky-social/indigo/atproto/syntax" 13 13 + "tangled.org/core/appview/models" 14 14 + "tangled.org/core/orm" 15 15 + ) 16 16 + 17 17 + func PutComment(tx *sql.Tx, c *models.Comment) error { 18 18 + result, err := tx.Exec( 19 19 + `insert into comments ( 20 20 + did, 21 21 + rkey, 22 22 + subject_at, 23 23 + reply_to, 24 24 + body, 25 25 + pull_submission_id, 26 26 + created 27 27 + ) 28 28 + values (?, ?, ?, ?, ?, ?, ?) 29 29 + on conflict(did, rkey) do update set 30 30 + subject_at = excluded.subject_at, 31 31 + reply_to = excluded.reply_to, 32 32 + body = excluded.body, 33 33 + edited = case 34 34 + when 35 35 + comments.subject_at != excluded.subject_at 36 36 + or comments.body != excluded.body 37 37 + or comments.reply_to != excluded.reply_to 38 38 + then ? 39 39 + else comments.edited 40 40 + end`, 41 41 + c.Did, 42 42 + c.Rkey, 43 43 + c.Subject, 44 44 + c.ReplyTo, 45 45 + c.Body, 46 46 + c.PullSubmissionId, 47 47 + c.Created.Format(time.RFC3339), 48 48 + time.Now().Format(time.RFC3339), 49 49 + ) 50 50 + if err != nil { 51 51 + return err 52 52 + } 53 53 + 54 54 + c.Id, err = result.LastInsertId() 55 55 + if err != nil { 56 56 + return err 57 57 + } 58 58 + 59 59 + if err := putReferences(tx, c.AtUri(), c.References); err != nil { 60 60 + return fmt.Errorf("put reference_links: %w", err) 61 61 + } 62 62 + 63 63 + return nil 64 64 + } 65 65 + 66 66 + func DeleteComments(e Execer, filters ...orm.Filter) error { 67 67 + var conditions []string 68 68 + var args []any 69 69 + for _, filter := range filters { 70 70 + conditions = append(conditions, filter.Condition()) 71 71 + args = append(args, filter.Arg()...) 72 72 + } 73 73 + 74 74 + whereClause := "" 75 75 + if conditions != nil { 76 76 + whereClause = " where " + strings.Join(conditions, " and ") 77 77 + } 78 78 + 79 79 + query := fmt.Sprintf(`update comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 80 80 + 81 81 + _, err := e.Exec(query, args...) 82 82 + return err 83 83 + } 84 84 + 85 85 + func GetComments(e Execer, filters ...orm.Filter) ([]models.Comment, error) { 86 86 + commentMap := make(map[string]*models.Comment) 87 87 + 88 88 + var conditions []string 89 89 + var args []any 90 90 + for _, filter := range filters { 91 91 + conditions = append(conditions, filter.Condition()) 92 92 + args = append(args, filter.Arg()...) 93 93 + } 94 94 + 95 95 + whereClause := "" 96 96 + if conditions != nil { 97 97 + whereClause = " where " + strings.Join(conditions, " and ") 98 98 + } 99 99 + 100 100 + query := fmt.Sprintf(` 101 101 + select 102 102 + id, 103 103 + did, 104 104 + rkey, 105 105 + subject_at, 106 106 + reply_to, 107 107 + body, 108 108 + pull_submission_id, 109 109 + created, 110 110 + edited, 111 111 + deleted 112 112 + from 113 113 + comments 114 114 + %s 115 115 + `, whereClause) 116 116 + 117 117 + rows, err := e.Query(query, args...) 118 118 + if err != nil { 119 119 + return nil, err 120 120 + } 121 121 + 122 122 + for rows.Next() { 123 123 + var comment models.Comment 124 124 + var created string 125 125 + var rkey, edited, deleted, replyTo sql.Null[string] 126 126 + err := rows.Scan( 127 127 + &comment.Id, 128 128 + &comment.Did, 129 129 + &rkey, 130 130 + &comment.Subject, 131 131 + &replyTo, 132 132 + &comment.Body, 133 133 + &comment.PullSubmissionId, 134 134 + &created, 135 135 + &edited, 136 136 + &deleted, 137 137 + ) 138 138 + if err != nil { 139 139 + return nil, err 140 140 + } 141 141 + 142 142 + // this is a remnant from old times, newer comments always have rkey 143 143 + if rkey.Valid { 144 144 + comment.Rkey = rkey.V 145 145 + } 146 146 + 147 147 + if t, err := time.Parse(time.RFC3339, created); err == nil { 148 148 + comment.Created = t 149 149 + } 150 150 + 151 151 + if edited.Valid { 152 152 + if t, err := time.Parse(time.RFC3339, edited.V); err == nil { 153 153 + comment.Edited = &t 154 154 + } 155 155 + } 156 156 + 157 157 + if deleted.Valid { 158 158 + if t, err := time.Parse(time.RFC3339, deleted.V); err == nil { 159 159 + comment.Deleted = &t 160 160 + } 161 161 + } 162 162 + 163 163 + if replyTo.Valid { 164 164 + rt := syntax.ATURI(replyTo.V) 165 165 + comment.ReplyTo = &rt 166 166 + } 167 167 + 168 168 + atUri := comment.AtUri().String() 169 169 + commentMap[atUri] = &comment 170 170 + } 171 171 + 172 172 + if err := rows.Err(); err != nil { 173 173 + return nil, err 174 174 + } 175 175 + defer rows.Close() 176 176 + 177 177 + // collect references from each comments 178 178 + commentAts := slices.Collect(maps.Keys(commentMap)) 179 179 + allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts)) 180 180 + if err != nil { 181 181 + return nil, fmt.Errorf("failed to query reference_links: %w", err) 182 182 + } 183 183 + for commentAt, references := range allReferencs { 184 184 + if comment, ok := commentMap[commentAt.String()]; ok { 185 185 + comment.References = references 186 186 + } 187 187 + } 188 188 + 189 189 + var comments []models.Comment 190 190 + for _, c := range commentMap { 191 191 + comments = append(comments, *c) 192 192 + } 193 193 + 194 194 + sort.Slice(comments, func(i, j int) bool { 195 195 + return comments[i].Created.After(comments[j].Created) 196 196 + }) 197 197 + 198 198 + return comments, nil 199 199 + }

+81

appview/db/db.go

··· 1173 1173 return err 1174 1174 }) 1175 1175 1176 1176 + orm.RunMigration(conn, logger, "add-comments-table", func(tx *sql.Tx) error { 1177 1177 + _, err := tx.Exec(` 1178 1178 + drop table if exists comments; 1179 1179 + 1180 1180 + create table comments ( 1181 1181 + -- identifiers 1182 1182 + id integer primary key autoincrement, 1183 1183 + did text not null, 1184 1184 + collection text not null default 'sh.tangled.comment', 1185 1185 + rkey text not null, 1186 1186 + at_uri text generated always as ('at://' || did || '/' || collection || '/' || rkey) stored, 1187 1187 + 1188 1188 + -- at identifiers 1189 1189 + subject_at text not null, 1190 1190 + reply_to text, -- at_uri of parent comment 1191 1191 + 1192 1192 + pull_submission_id integer, -- dirty fix until we atprotate the pull-rounds 1193 1193 + 1194 1194 + -- content 1195 1195 + body text not null, 1196 1196 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1197 1197 + edited text, 1198 1198 + deleted text, 1199 1199 + 1200 1200 + -- constraints 1201 1201 + unique(did, rkey) 1202 1202 + ); 1203 1203 + 1204 1204 + insert into comments ( 1205 1205 + did, 1206 1206 + collection, 1207 1207 + rkey, 1208 1208 + subject_at, 1209 1209 + reply_to, 1210 1210 + body, 1211 1211 + created, 1212 1212 + edited, 1213 1213 + deleted 1214 1214 + ) 1215 1215 + select 1216 1216 + did, 1217 1217 + 'sh.tangled.repo.issue.comment', 1218 1218 + rkey, 1219 1219 + issue_at, 1220 1220 + reply_to, 1221 1221 + body, 1222 1222 + created, 1223 1223 + edited, 1224 1224 + deleted 1225 1225 + from issue_comments 1226 1226 + where rkey is not null; 1227 1227 + 1228 1228 + insert into comments ( 1229 1229 + did, 1230 1230 + collection, 1231 1231 + rkey, 1232 1232 + subject_at, 1233 1233 + pull_submission_id, 1234 1234 + body, 1235 1235 + created 1236 1236 + ) 1237 1237 + select 1238 1238 + c.owner_did, 1239 1239 + 'sh.tangled.repo.pull.comment', 1240 1240 + substr( 1241 1241 + substr(c.comment_at, 6 + instr(substr(c.comment_at, 6), '/')), -- nsid/rkey 1242 1242 + instr( 1243 1243 + substr(c.comment_at, 6 + instr(substr(c.comment_at, 6), '/')), -- nsid/rkey 1244 1244 + '/' 1245 1245 + ) + 1 1246 1246 + ), -- rkey 1247 1247 + p.at_uri, 1248 1248 + c.submission_id, 1249 1249 + c.body, 1250 1250 + c.created 1251 1251 + from pull_comments c 1252 1252 + join pulls p on c.repo_at = p.repo_at and c.pull_id = p.pull_id; 1253 1253 + `) 1254 1254 + return err 1255 1255 + }) 1256 1256 + 1176 1257 return &DB{ 1177 1258 db, 1178 1259 logger,

+6 -186

appview/db/issues.go

··· 100 100 } 101 101 102 102 func GetIssuesPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]models.Issue, error) { 103 103 - issueMap := make(map[string]*models.Issue) // at-uri -> issue 103 103 + issueMap := make(map[syntax.ATURI]*models.Issue) // at-uri -> issue 104 104 105 105 var conditions []string 106 106 var args []any ··· 196 196 } 197 197 } 198 198 199 199 - atUri := issue.AtUri().String() 200 200 - issueMap[atUri] = &issue 199 199 + issueMap[issue.AtUri()] = &issue 201 200 } 202 201 203 202 // collect reverse repos ··· 229 228 // collect comments 230 229 issueAts := slices.Collect(maps.Keys(issueMap)) 231 230 232 232 - comments, err := GetIssueComments(e, orm.FilterIn("issue_at", issueAts)) 231 231 + comments, err := GetComments(e, orm.FilterIn("subject_at", issueAts)) 233 232 if err != nil { 234 233 return nil, fmt.Errorf("failed to query comments: %w", err) 235 234 } 236 235 for i := range comments { 237 237 - issueAt := comments[i].IssueAt 236 236 + issueAt := comments[i].Subject 238 237 if issue, ok := issueMap[issueAt]; ok { 239 238 issue.Comments = append(issue.Comments, comments[i]) 240 239 } ··· 246 245 return nil, fmt.Errorf("failed to query labels: %w", err) 247 246 } 248 247 for issueAt, labels := range allLabels { 249 249 - if issue, ok := issueMap[issueAt.String()]; ok { 248 248 + if issue, ok := issueMap[issueAt]; ok { 250 249 issue.Labels = labels 251 250 } 252 251 } ··· 257 256 return nil, fmt.Errorf("failed to query reference_links: %w", err) 258 257 } 259 258 for issueAt, references := range allReferencs { 260 260 - if issue, ok := issueMap[issueAt.String()]; ok { 259 259 + if issue, ok := issueMap[issueAt]; ok { 261 260 issue.References = references 262 261 } 263 262 } ··· 349 348 } 350 349 351 350 return ids, nil 352 352 - } 353 353 - 354 354 - func AddIssueComment(tx *sql.Tx, c models.IssueComment) (int64, error) { 355 355 - result, err := tx.Exec( 356 356 - `insert into issue_comments ( 357 357 - did, 358 358 - rkey, 359 359 - issue_at, 360 360 - body, 361 361 - reply_to, 362 362 - created, 363 363 - edited 364 364 - ) 365 365 - values (?, ?, ?, ?, ?, ?, null) 366 366 - on conflict(did, rkey) do update set 367 367 - issue_at = excluded.issue_at, 368 368 - body = excluded.body, 369 369 - edited = case 370 370 - when 371 371 - issue_comments.issue_at != excluded.issue_at 372 372 - or issue_comments.body != excluded.body 373 373 - or issue_comments.reply_to != excluded.reply_to 374 374 - then ? 375 375 - else issue_comments.edited 376 376 - end`, 377 377 - c.Did, 378 378 - c.Rkey, 379 379 - c.IssueAt, 380 380 - c.Body, 381 381 - c.ReplyTo, 382 382 - c.Created.Format(time.RFC3339), 383 383 - time.Now().Format(time.RFC3339), 384 384 - ) 385 385 - if err != nil { 386 386 - return 0, err 387 387 - } 388 388 - 389 389 - id, err := result.LastInsertId() 390 390 - if err != nil { 391 391 - return 0, err 392 392 - } 393 393 - 394 394 - if err := putReferences(tx, c.AtUri(), c.References); err != nil { 395 395 - return 0, fmt.Errorf("put reference_links: %w", err) 396 396 - } 397 397 - 398 398 - return id, nil 399 399 - } 400 400 - 401 401 - func DeleteIssueComments(e Execer, filters ...orm.Filter) error { 402 402 - var conditions []string 403 403 - var args []any 404 404 - for _, filter := range filters { 405 405 - conditions = append(conditions, filter.Condition()) 406 406 - args = append(args, filter.Arg()...) 407 407 - } 408 408 - 409 409 - whereClause := "" 410 410 - if conditions != nil { 411 411 - whereClause = " where " + strings.Join(conditions, " and ") 412 412 - } 413 413 - 414 414 - query := fmt.Sprintf(`update issue_comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 415 415 - 416 416 - _, err := e.Exec(query, args...) 417 417 - return err 418 418 - } 419 419 - 420 420 - func GetIssueComments(e Execer, filters ...orm.Filter) ([]models.IssueComment, error) { 421 421 - commentMap := make(map[string]*models.IssueComment) 422 422 - 423 423 - var conditions []string 424 424 - var args []any 425 425 - for _, filter := range filters { 426 426 - conditions = append(conditions, filter.Condition()) 427 427 - args = append(args, filter.Arg()...) 428 428 - } 429 429 - 430 430 - whereClause := "" 431 431 - if conditions != nil { 432 432 - whereClause = " where " + strings.Join(conditions, " and ") 433 433 - } 434 434 - 435 435 - query := fmt.Sprintf(` 436 436 - select 437 437 - id, 438 438 - did, 439 439 - rkey, 440 440 - issue_at, 441 441 - reply_to, 442 442 - body, 443 443 - created, 444 444 - edited, 445 445 - deleted 446 446 - from 447 447 - issue_comments 448 448 - %s 449 449 - `, whereClause) 450 450 - 451 451 - rows, err := e.Query(query, args...) 452 452 - if err != nil { 453 453 - return nil, err 454 454 - } 455 455 - defer rows.Close() 456 456 - 457 457 - for rows.Next() { 458 458 - var comment models.IssueComment 459 459 - var created string 460 460 - var rkey, edited, deleted, replyTo sql.Null[string] 461 461 - err := rows.Scan( 462 462 - &comment.Id, 463 463 - &comment.Did, 464 464 - &rkey, 465 465 - &comment.IssueAt, 466 466 - &replyTo, 467 467 - &comment.Body, 468 468 - &created, 469 469 - &edited, 470 470 - &deleted, 471 471 - ) 472 472 - if err != nil { 473 473 - return nil, err 474 474 - } 475 475 - 476 476 - // this is a remnant from old times, newer comments always have rkey 477 477 - if rkey.Valid { 478 478 - comment.Rkey = rkey.V 479 479 - } 480 480 - 481 481 - if t, err := time.Parse(time.RFC3339, created); err == nil { 482 482 - comment.Created = t 483 483 - } 484 484 - 485 485 - if edited.Valid { 486 486 - if t, err := time.Parse(time.RFC3339, edited.V); err == nil { 487 487 - comment.Edited = &t 488 488 - } 489 489 - } 490 490 - 491 491 - if deleted.Valid { 492 492 - if t, err := time.Parse(time.RFC3339, deleted.V); err == nil { 493 493 - comment.Deleted = &t 494 494 - } 495 495 - } 496 496 - 497 497 - if replyTo.Valid { 498 498 - comment.ReplyTo = &replyTo.V 499 499 - } 500 500 - 501 501 - atUri := comment.AtUri().String() 502 502 - commentMap[atUri] = &comment 503 503 - } 504 504 - 505 505 - if err = rows.Err(); err != nil { 506 506 - return nil, err 507 507 - } 508 508 - 509 509 - // collect references for each comments 510 510 - commentAts := slices.Collect(maps.Keys(commentMap)) 511 511 - allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts)) 512 512 - if err != nil { 513 513 - return nil, fmt.Errorf("failed to query reference_links: %w", err) 514 514 - } 515 515 - for commentAt, references := range allReferencs { 516 516 - if comment, ok := commentMap[commentAt.String()]; ok { 517 517 - comment.References = references 518 518 - } 519 519 - } 520 520 - 521 521 - var comments []models.IssueComment 522 522 - for _, c := range commentMap { 523 523 - comments = append(comments, *c) 524 524 - } 525 525 - 526 526 - sort.Slice(comments, func(i, j int) bool { 527 527 - return comments[i].Created.After(comments[j].Created) 528 528 - }) 529 529 - 530 530 - return comments, nil 531 351 } 532 352 533 353 func DeleteIssues(tx *sql.Tx, did, rkey string) error {

+18 -11

appview/db/profile.go

··· 20 20 timeline := models.ProfileTimeline{ 21 21 ByMonth: make([]models.ByMonth, TimeframeMonths), 22 22 } 23 23 - currentMonth := time.Now().Month() 23 23 + now := time.Now() 24 24 timeframe := fmt.Sprintf("-%d months", TimeframeMonths) 25 25 26 26 pulls, err := GetPullsByOwnerDid(e, forDid, timeframe) ··· 30 30 31 31 // group pulls by month 32 32 for _, pull := range pulls { 33 33 - pullMonth := pull.Created.Month() 33 33 + monthsAgo := monthsBetween(pull.Created, now) 34 34 35 35 - if currentMonth-pullMonth >= TimeframeMonths { 35 35 + if monthsAgo >= TimeframeMonths { 36 36 // shouldn't happen; but times are weird 37 37 continue 38 38 } 39 39 40 40 - idx := currentMonth - pullMonth 40 40 + idx := monthsAgo 41 41 items := &timeline.ByMonth[idx].PullEvents.Items 42 42 43 43 *items = append(*items, &pull) ··· 53 53 } 54 54 55 55 for _, issue := range issues { 56 56 - issueMonth := issue.Created.Month() 56 56 + monthsAgo := monthsBetween(issue.Created, now) 57 57 58 58 - if currentMonth-issueMonth >= TimeframeMonths { 58 58 + if monthsAgo >= TimeframeMonths { 59 59 // shouldn't happen; but times are weird 60 60 continue 61 61 } 62 62 63 63 - idx := currentMonth - issueMonth 63 63 + idx := monthsAgo 64 64 items := &timeline.ByMonth[idx].IssueEvents.Items 65 65 66 66 *items = append(*items, &issue) ··· 77 77 if repo.Source != "" { 78 78 sourceRepo, err = GetRepoByAtUri(e, repo.Source) 79 79 if err != nil { 80 80 - return nil, err 80 80 + // the source repo was not found, skip this bit 81 81 + log.Println("profile", "err", err) 81 82 } 82 83 } 83 84 84 84 - repoMonth := repo.Created.Month() 85 85 + monthsAgo := monthsBetween(repo.Created, now) 85 86 86 86 - if currentMonth-repoMonth >= TimeframeMonths { 87 87 + if monthsAgo >= TimeframeMonths { 87 88 // shouldn't happen; but times are weird 88 89 continue 89 90 } 90 91 91 91 - idx := currentMonth - repoMonth 92 92 + idx := monthsAgo 92 93 93 94 items := &timeline.ByMonth[idx].RepoEvents 94 95 *items = append(*items, models.RepoEvent{ ··· 98 99 } 99 100 100 101 return &timeline, nil 102 102 + } 103 103 + 104 104 + func monthsBetween(from, to time.Time) int { 105 105 + years := to.Year() - from.Year() 106 106 + months := int(to.Month() - from.Month()) 107 107 + return years*12 + months 101 108 } 102 109 103 110 func UpsertProfile(tx *sql.Tx, profile *models.Profile) error {

+6 -121

appview/db/pulls.go

··· 447 447 return nil, err 448 448 } 449 449 450 450 - // Get comments for all submissions using GetPullComments 450 450 + // Get comments for all submissions using GetComments 451 451 submissionIds := slices.Collect(maps.Keys(submissionMap)) 452 452 - comments, err := GetPullComments(e, orm.FilterIn("submission_id", submissionIds)) 452 452 + comments, err := GetComments(e, orm.FilterIn("pull_submission_id", submissionIds)) 453 453 if err != nil { 454 454 return nil, fmt.Errorf("failed to get pull comments: %w", err) 455 455 } 456 456 for _, comment := range comments { 457 457 - if submission, ok := submissionMap[comment.SubmissionId]; ok { 458 458 - submission.Comments = append(submission.Comments, comment) 457 457 + if comment.PullSubmissionId != nil { 458 458 + if submission, ok := submissionMap[*comment.PullSubmissionId]; ok { 459 459 + submission.Comments = append(submission.Comments, comment) 460 460 + } 459 461 } 460 462 } 461 463 ··· 475 477 return m, nil 476 478 } 477 479 478 478 - func GetPullComments(e Execer, filters ...orm.Filter) ([]models.PullComment, error) { 479 479 - var conditions []string 480 480 - var args []any 481 481 - for _, filter := range filters { 482 482 - conditions = append(conditions, filter.Condition()) 483 483 - args = append(args, filter.Arg()...) 484 484 - } 485 485 - 486 486 - whereClause := "" 487 487 - if conditions != nil { 488 488 - whereClause = " where " + strings.Join(conditions, " and ") 489 489 - } 490 490 - 491 491 - query := fmt.Sprintf(` 492 492 - select 493 493 - id, 494 494 - pull_id, 495 495 - submission_id, 496 496 - repo_at, 497 497 - owner_did, 498 498 - comment_at, 499 499 - body, 500 500 - created 501 501 - from 502 502 - pull_comments 503 503 - %s 504 504 - order by 505 505 - created asc 506 506 - `, whereClause) 507 507 - 508 508 - rows, err := e.Query(query, args...) 509 509 - if err != nil { 510 510 - return nil, err 511 511 - } 512 512 - defer rows.Close() 513 513 - 514 514 - commentMap := make(map[string]*models.PullComment) 515 515 - for rows.Next() { 516 516 - var comment models.PullComment 517 517 - var createdAt string 518 518 - err := rows.Scan( 519 519 - &comment.ID, 520 520 - &comment.PullId, 521 521 - &comment.SubmissionId, 522 522 - &comment.RepoAt, 523 523 - &comment.OwnerDid, 524 524 - &comment.CommentAt, 525 525 - &comment.Body, 526 526 - &createdAt, 527 527 - ) 528 528 - if err != nil { 529 529 - return nil, err 530 530 - } 531 531 - 532 532 - if t, err := time.Parse(time.RFC3339, createdAt); err == nil { 533 533 - comment.Created = t 534 534 - } 535 535 - 536 536 - atUri := comment.AtUri().String() 537 537 - commentMap[atUri] = &comment 538 538 - } 539 539 - 540 540 - if err := rows.Err(); err != nil { 541 541 - return nil, err 542 542 - } 543 543 - 544 544 - // collect references for each comments 545 545 - commentAts := slices.Collect(maps.Keys(commentMap)) 546 546 - allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts)) 547 547 - if err != nil { 548 548 - return nil, fmt.Errorf("failed to query reference_links: %w", err) 549 549 - } 550 550 - for commentAt, references := range allReferencs { 551 551 - if comment, ok := commentMap[commentAt.String()]; ok { 552 552 - comment.References = references 553 553 - } 554 554 - } 555 555 - 556 556 - var comments []models.PullComment 557 557 - for _, c := range commentMap { 558 558 - comments = append(comments, *c) 559 559 - } 560 560 - 561 561 - sort.Slice(comments, func(i, j int) bool { 562 562 - return comments[i].Created.Before(comments[j].Created) 563 563 - }) 564 564 - 565 565 - return comments, nil 566 566 - } 567 567 - 568 480 // timeframe here is directly passed into the sql query filter, and any 569 481 // timeframe in the past should be negative; e.g.: "-3 months" 570 482 func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]models.Pull, error) { ··· 639 551 } 640 552 641 553 return pulls, nil 642 642 - } 643 643 - 644 644 - func NewPullComment(tx *sql.Tx, comment *models.PullComment) (int64, error) { 645 645 - query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)` 646 646 - res, err := tx.Exec( 647 647 - query, 648 648 - comment.OwnerDid, 649 649 - comment.RepoAt, 650 650 - comment.SubmissionId, 651 651 - comment.CommentAt, 652 652 - comment.PullId, 653 653 - comment.Body, 654 654 - ) 655 655 - if err != nil { 656 656 - return 0, err 657 657 - } 658 658 - 659 659 - i, err := res.LastInsertId() 660 660 - if err != nil { 661 661 - return 0, err 662 662 - } 663 663 - 664 664 - if err := putReferences(tx, comment.AtUri(), comment.References); err != nil { 665 665 - return 0, fmt.Errorf("put reference_links: %w", err) 666 666 - } 667 667 - 668 668 - return i, nil 669 554 } 670 555 671 556 func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState models.PullState) error {

+1 -1

appview/db/punchcard.go

··· 78 78 punch.Count = int(count.Int64) 79 79 } 80 80 81 81 - punchcard.Punches[punch.Date.YearDay()] = punch 81 81 + punchcard.Punches[punch.Date.YearDay()-1] = punch 82 82 punchcard.Total += punch.Count 83 83 } 84 84

+20 -32

appview/db/reference.go

··· 11 11 "tangled.org/core/orm" 12 12 ) 13 13 14 14 - // ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs. 14 14 + // ValidateReferenceLinks resolves refLinks to Issue/PR/Comment ATURIs. 15 15 // It will ignore missing refLinks. 16 16 func ValidateReferenceLinks(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) { 17 17 var ( ··· 53 53 values %s 54 54 ) 55 55 select 56 56 - i.did, i.rkey, 57 57 - c.did, c.rkey 56 56 + i.at_uri, c.at_uri 58 57 from input inp 59 58 join repos r 60 59 on r.did = inp.owner_did ··· 62 61 join issues i 63 62 on i.repo_at = r.at_uri 64 63 and i.issue_id = inp.issue_id 65 65 - left join issue_comments c 64 64 + left join comments c 66 65 on inp.comment_id is not null 67 67 - and c.issue_at = i.at_uri 66 66 + and c.subject_at = i.at_uri 68 67 and c.id = inp.comment_id 69 68 `, 70 69 strings.Join(vals, ","), ··· 79 78 80 79 for rows.Next() { 81 80 // Scan rows 82 82 - var issueOwner, issueRkey string 83 83 - var commentOwner, commentRkey sql.NullString 81 81 + var issueUri string 82 82 + var commentUri sql.NullString 84 83 var uri syntax.ATURI 85 85 - if err := rows.Scan(&issueOwner, &issueRkey, &commentOwner, &commentRkey); err != nil { 84 84 + if err := rows.Scan(&issueUri, &commentUri); err != nil { 86 85 return nil, err 87 86 } 88 88 - if commentOwner.Valid && commentRkey.Valid { 89 89 - uri = syntax.ATURI(fmt.Sprintf( 90 90 - "at://%s/%s/%s", 91 91 - commentOwner.String, 92 92 - tangled.RepoIssueCommentNSID, 93 93 - commentRkey.String, 94 94 - )) 87 87 + if commentUri.Valid { 88 88 + uri = syntax.ATURI(commentUri.String) 95 89 } else { 96 96 - uri = syntax.ATURI(fmt.Sprintf( 97 97 - "at://%s/%s/%s", 98 98 - issueOwner, 99 99 - tangled.RepoIssueNSID, 100 100 - issueRkey, 101 101 - )) 90 90 + uri = syntax.ATURI(issueUri) 102 91 } 103 92 uris = append(uris, uri) 104 93 } ··· 124 113 values %s 125 114 ) 126 115 select 127 127 - p.owner_did, p.rkey, 128 128 - c.comment_at 116 116 + p.owner_did, p.rkey, c.at_uri 129 117 from input inp 130 118 join repos r 131 119 on r.did = inp.owner_did ··· 133 121 join pulls p 134 122 on p.repo_at = r.at_uri 135 123 and p.pull_id = inp.pull_id 136 136 - left join pull_comments c 124 124 + left join comments c 137 125 on inp.comment_id is not null 138 138 - and c.repo_at = r.at_uri and c.pull_id = p.pull_id 126 126 + and c.subject_at = ('at://' || p.owner_did || '/' || 'sh.tangled.repo.pull' || '/' || p.rkey) 139 127 and c.id = inp.comment_id 140 128 `, 141 129 strings.Join(vals, ","), ··· 283 271 return nil, fmt.Errorf("get issue backlinks: %w", err) 284 272 } 285 273 backlinks = append(backlinks, ls...) 286 286 - ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.RepoIssueCommentNSID]) 274 274 + ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.CommentNSID]) 287 275 if err != nil { 288 276 return nil, fmt.Errorf("get issue_comment backlinks: %w", err) 289 277 } ··· 293 281 return nil, fmt.Errorf("get pull backlinks: %w", err) 294 282 } 295 283 backlinks = append(backlinks, ls...) 296 296 - ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.RepoPullCommentNSID]) 284 284 + ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.CommentNSID]) 297 285 if err != nil { 298 286 return nil, fmt.Errorf("get pull_comment backlinks: %w", err) 299 287 } ··· 352 340 rows, err := e.Query( 353 341 fmt.Sprintf( 354 342 `select r.did, r.name, i.issue_id, c.id, i.title, i.open 355 355 - from issue_comments c 343 343 + from comments c 356 344 join issues i 357 357 - on i.at_uri = c.issue_at 345 345 + on i.at_uri = c.subject_at 358 346 join repos r 359 347 on r.at_uri = i.repo_at 360 348 where %s`, ··· 428 416 if len(aturis) == 0 { 429 417 return nil, nil 430 418 } 431 431 - filter := orm.FilterIn("c.comment_at", aturis) 419 419 + filter := orm.FilterIn("c.at_uri", aturis) 432 420 rows, err := e.Query( 433 421 fmt.Sprintf( 434 422 `select r.did, r.name, p.pull_id, c.id, p.title, p.state 435 423 from repos r 436 424 join pulls p 437 425 on r.at_uri = p.repo_at 438 438 - join pull_comments c 439 439 - on r.at_uri = c.repo_at and p.pull_id = c.pull_id 426 426 + join comments c 427 427 + on ('at://' || p.owner_did || '/' || 'sh.tangled.repo.pull' || '/' || p.rkey) = c.subject_at 440 428 where %s`, 441 429 filter.Condition(), 442 430 ),

+19 -11

appview/ingester.go

··· 79 79 err = i.ingestString(e) 80 80 case tangled.RepoIssueNSID: 81 81 err = i.ingestIssue(ctx, e) 82 82 - case tangled.RepoIssueCommentNSID: 83 83 - err = i.ingestIssueComment(e) 82 82 + case tangled.CommentNSID: 83 83 + err = i.ingestComment(e) 84 84 case tangled.LabelDefinitionNSID: 85 85 err = i.ingestLabelDefinition(e) 86 86 case tangled.LabelOpNSID: ··· 868 868 return nil 869 869 } 870 870 871 871 - func (i *Ingester) ingestIssueComment(e *jmodels.Event) error { 871 871 + func (i *Ingester) ingestComment(e *jmodels.Event) error { 872 872 did := e.Did 873 873 rkey := e.Commit.RKey 874 874 875 875 var err error 876 876 877 877 - l := i.Logger.With("handler", "ingestIssueComment", "nsid", e.Commit.Collection, "did", did, "rkey", rkey) 877 877 + l := i.Logger.With("handler", "ingestComment", "nsid", e.Commit.Collection, "did", did, "rkey", rkey) 878 878 l.Info("ingesting record") 879 879 880 880 ddb, ok := i.Db.Execer.(*db.DB) ··· 885 885 switch e.Commit.Operation { 886 886 case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate: 887 887 raw := json.RawMessage(e.Commit.Record) 888 888 - record := tangled.RepoIssueComment{} 888 888 + record := tangled.Comment{} 889 889 err = json.Unmarshal(raw, &record) 890 890 if err != nil { 891 891 return fmt.Errorf("invalid record: %w", err) 892 892 } 893 893 894 894 - comment, err := models.IssueCommentFromRecord(did, rkey, record) 894 894 + comment, err := models.CommentFromRecord(did, rkey, record) 895 895 if err != nil { 896 896 return fmt.Errorf("failed to parse comment from record: %w", err) 897 897 } 898 898 899 899 - if err := i.Validator.ValidateIssueComment(comment); err != nil { 899 899 + // TODO: ingest pull comments 900 900 + // we aren't ingesting pull comments yet because pull itself isn't fully atprotated. 901 901 + // so we cannot know which round this comment is pointing to 902 902 + if comment.Subject.Collection().String() == tangled.RepoPullNSID { 903 903 + l.Info("skip ingesting pull comments") 904 904 + return nil 905 905 + } 906 906 + 907 907 + if err := comment.Validate(); err != nil { 900 908 return fmt.Errorf("failed to validate comment: %w", err) 901 909 } 902 910 ··· 906 914 } 907 915 defer tx.Rollback() 908 916 909 909 - _, err = db.AddIssueComment(tx, *comment) 917 917 + err = db.PutComment(tx, comment) 910 918 if err != nil { 911 911 - return fmt.Errorf("failed to create issue comment: %w", err) 919 919 + return fmt.Errorf("failed to create comment: %w", err) 912 920 } 913 921 914 922 return tx.Commit() 915 923 916 924 case jmodels.CommitOperationDelete: 917 917 - if err := db.DeleteIssueComments( 925 925 + if err := db.DeleteComments( 918 926 ddb, 919 927 orm.FilterEq("did", did), 920 928 orm.FilterEq("rkey", rkey), 921 929 ); err != nil { 922 922 - return fmt.Errorf("failed to delete issue comment record: %w", err) 930 930 + return fmt.Errorf("failed to delete comment record: %w", err) 923 931 } 924 932 925 933 return nil

+31 -29

appview/issues/issues.go

··· 403 403 404 404 body := r.FormValue("body") 405 405 if body == "" { 406 406 - rp.pages.Notice(w, "issue", "Body is required") 406 406 + rp.pages.Notice(w, "issue-comment", "Body is required") 407 407 return 408 408 } 409 409 410 410 - replyToUri := r.FormValue("reply-to") 411 411 - var replyTo *string 412 412 - if replyToUri != "" { 413 413 - replyTo = &replyToUri 410 410 + var replyTo *syntax.ATURI 411 411 + replyToRaw := r.FormValue("reply-to") 412 412 + if replyToRaw != "" { 413 413 + aturi, err := syntax.ParseATURI(r.FormValue("reply-to")) 414 414 + if err != nil { 415 415 + rp.pages.Notice(w, "issue-comment", "reply-to should be valid AT-URI") 416 416 + return 417 417 + } 418 418 + replyTo = &aturi 414 419 } 415 420 416 421 mentions, references := rp.mentionsResolver.Resolve(r.Context(), body) 417 422 418 418 - comment := models.IssueComment{ 419 419 - Did: user.Did, 423 423 + comment := models.Comment{ 424 424 + Did: syntax.DID(user.Did), 420 425 Rkey: tid.TID(), 421 421 - IssueAt: issue.AtUri().String(), 426 426 + Subject: issue.AtUri(), 422 427 ReplyTo: replyTo, 423 428 Body: body, 424 429 Created: time.Now(), 425 430 Mentions: mentions, 426 431 References: references, 427 432 } 428 428 - if err = rp.validator.ValidateIssueComment(&comment); err != nil { 433 433 + if err = comment.Validate(); err != nil { 429 434 l.Error("failed to validate comment", "err", err) 430 435 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 431 436 return ··· 441 446 442 447 // create a record first 443 448 resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 444 444 - Collection: tangled.RepoIssueCommentNSID, 445 445 - Repo: comment.Did, 449 449 + Collection: tangled.CommentNSID, 450 450 + Repo: user.Did, 446 451 Rkey: comment.Rkey, 447 452 Record: &lexutil.LexiconTypeDecoder{ 448 453 Val: &record, ··· 468 473 } 469 474 defer tx.Rollback() 470 475 471 471 - commentId, err := db.AddIssueComment(tx, comment) 476 476 + err = db.PutComment(tx, &comment) 472 477 if err != nil { 473 478 l.Error("failed to create comment", "err", err) 474 479 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") ··· 484 489 // reset atUri to make rollback a no-op 485 490 atUri = "" 486 491 487 487 - // notify about the new comment 488 488 - comment.Id = commentId 489 489 - 490 490 - rp.notifier.NewIssueComment(r.Context(), &comment, mentions) 492 492 + rp.notifier.NewComment(r.Context(), &comment) 491 493 492 494 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 493 493 - rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId)) 495 495 + rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, comment.Id)) 494 496 } 495 497 496 498 func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) { ··· 505 507 } 506 508 507 509 commentId := chi.URLParam(r, "commentId") 508 508 - comments, err := db.GetIssueComments( 510 510 + comments, err := db.GetComments( 509 511 rp.db, 510 512 orm.FilterEq("id", commentId), 511 513 ) ··· 541 543 } 542 544 543 545 commentId := chi.URLParam(r, "commentId") 544 544 - comments, err := db.GetIssueComments( 546 546 + comments, err := db.GetComments( 545 547 rp.db, 546 548 orm.FilterEq("id", commentId), 547 549 ) ··· 557 559 } 558 560 comment := comments[0] 559 561 560 560 - if comment.Did != user.Did { 562 562 + if comment.Did.String() != user.Did { 561 563 l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Did) 562 564 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 563 565 return ··· 597 599 } 598 600 defer tx.Rollback() 599 601 600 600 - _, err = db.AddIssueComment(tx, newComment) 602 602 + err = db.PutComment(tx, &newComment) 601 603 if err != nil { 602 604 l.Error("failed to perferom update-description query", "err", err) 603 605 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") ··· 608 610 // rkey is optional, it was introduced later 609 611 if newComment.Rkey != "" { 610 612 // update the record on pds 611 611 - ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey) 613 613 + ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.CommentNSID, user.Did, comment.Rkey) 612 614 if err != nil { 613 615 l.Error("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey) 614 616 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.") ··· 616 618 } 617 619 618 620 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 619 619 - Collection: tangled.RepoIssueCommentNSID, 621 621 + Collection: tangled.CommentNSID, 620 622 Repo: user.Did, 621 623 Rkey: newComment.Rkey, 622 624 SwapRecord: ex.Cid, ··· 651 653 } 652 654 653 655 commentId := chi.URLParam(r, "commentId") 654 654 - comments, err := db.GetIssueComments( 656 656 + comments, err := db.GetComments( 655 657 rp.db, 656 658 orm.FilterEq("id", commentId), 657 659 ) ··· 687 689 } 688 690 689 691 commentId := chi.URLParam(r, "commentId") 690 690 - comments, err := db.GetIssueComments( 692 692 + comments, err := db.GetComments( 691 693 rp.db, 692 694 orm.FilterEq("id", commentId), 693 695 ) ··· 723 725 } 724 726 725 727 commentId := chi.URLParam(r, "commentId") 726 726 - comments, err := db.GetIssueComments( 728 728 + comments, err := db.GetComments( 727 729 rp.db, 728 730 orm.FilterEq("id", commentId), 729 731 ) ··· 739 741 } 740 742 comment := comments[0] 741 743 742 742 - if comment.Did != user.Did { 744 744 + if comment.Did.String() != user.Did { 743 745 l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Did) 744 746 http.Error(w, "you are not the author of this comment", http.StatusUnauthorized) 745 747 return ··· 752 754 753 755 // optimistic deletion 754 756 deleted := time.Now() 755 755 - err = db.DeleteIssueComments(rp.db, orm.FilterEq("id", comment.Id)) 757 757 + err = db.DeleteComments(rp.db, orm.FilterEq("id", comment.Id)) 756 758 if err != nil { 757 759 l.Error("failed to delete comment", "err", err) 758 760 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment") ··· 768 770 return 769 771 } 770 772 _, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{ 771 771 - Collection: tangled.RepoIssueCommentNSID, 773 773 + Collection: tangled.CommentNSID, 772 774 Repo: user.Did, 773 775 Rkey: comment.Rkey, 774 776 })

-5

appview/knots/knots.go

··· 666 666 k.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.") 667 667 return 668 668 } 669 669 - if memberId.Handle.IsInvalidHandle() { 670 670 - l.Error("failed to resolve member identity to handle") 671 671 - k.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.") 672 672 - return 673 673 - } 674 669 675 670 // remove from enforcer 676 671 err = k.Enforcer.RemoveKnotMember(domain, memberId.DID.String())

+5 -1

appview/middleware/middleware.go

··· 176 176 } 177 177 178 178 func (mw Middleware) ResolveIdent() middlewareFunc { 179 179 - excluded := []string{"favicon.ico", "favicon.svg"} 179 179 + excluded := []string{"favicon.ico"} 180 180 181 181 return func(next http.Handler) http.Handler { 182 182 return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ··· 223 223 ) 224 224 if err != nil { 225 225 log.Println("failed to resolve repo", "err", err) 226 226 + w.WriteHeader(http.StatusNotFound) 226 227 mw.pages.ErrorKnot404(w) 227 228 return 228 229 } ··· 240 241 f, err := mw.repoResolver.Resolve(r) 241 242 if err != nil { 242 243 log.Println("failed to fully resolve repo", err) 244 244 + w.WriteHeader(http.StatusNotFound) 243 245 mw.pages.ErrorKnot404(w) 244 246 return 245 247 } ··· 288 290 f, err := mw.repoResolver.Resolve(r) 289 291 if err != nil { 290 292 log.Println("failed to fully resolve repo", err) 293 293 + w.WriteHeader(http.StatusNotFound) 291 294 mw.pages.ErrorKnot404(w) 292 295 return 293 296 } ··· 324 327 f, err := mw.repoResolver.Resolve(r) 325 328 if err != nil { 326 329 log.Println("failed to fully resolve repo", err) 330 330 + w.WriteHeader(http.StatusNotFound) 327 331 mw.pages.ErrorKnot404(w) 328 332 return 329 333 }

+117

appview/models/comment.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "strings" 6 6 + "time" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + "tangled.org/core/api/tangled" 10 10 + ) 11 11 + 12 12 + type Comment struct { 13 13 + Id int64 14 14 + Did syntax.DID 15 15 + Rkey string 16 16 + Subject syntax.ATURI 17 17 + ReplyTo *syntax.ATURI 18 18 + Body string 19 19 + Created time.Time 20 20 + Edited *time.Time 21 21 + Deleted *time.Time 22 22 + Mentions []syntax.DID 23 23 + References []syntax.ATURI 24 24 + PullSubmissionId *int 25 25 + } 26 26 + 27 27 + func (c *Comment) AtUri() syntax.ATURI { 28 28 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", c.Did, tangled.CommentNSID, c.Rkey)) 29 29 + } 30 30 + 31 31 + func (c *Comment) AsRecord() tangled.Comment { 32 32 + mentions := make([]string, len(c.Mentions)) 33 33 + for i, did := range c.Mentions { 34 34 + mentions[i] = string(did) 35 35 + } 36 36 + references := make([]string, len(c.References)) 37 37 + for i, uri := range c.References { 38 38 + references[i] = string(uri) 39 39 + } 40 40 + var replyTo *string 41 41 + if c.ReplyTo != nil { 42 42 + replyToStr := c.ReplyTo.String() 43 43 + replyTo = &replyToStr 44 44 + } 45 45 + return tangled.Comment{ 46 46 + Subject: c.Subject.String(), 47 47 + Body: c.Body, 48 48 + CreatedAt: c.Created.Format(time.RFC3339), 49 49 + ReplyTo: replyTo, 50 50 + Mentions: mentions, 51 51 + References: references, 52 52 + } 53 53 + } 54 54 + 55 55 + func (c *Comment) IsTopLevel() bool { 56 56 + return c.ReplyTo == nil 57 57 + } 58 58 + 59 59 + func (c *Comment) IsReply() bool { 60 60 + return c.ReplyTo != nil 61 61 + } 62 62 + 63 63 + func (c *Comment) Validate() error { 64 64 + // TODO: sanitize the body and then trim space 65 65 + if sb := strings.TrimSpace(c.Body); sb == "" { 66 66 + return fmt.Errorf("body is empty after HTML sanitization") 67 67 + } 68 68 + 69 69 + // if it's for PR, PullSubmissionId should not be nil 70 70 + if c.Subject.Collection().String() == tangled.RepoPullNSID { 71 71 + if c.PullSubmissionId == nil { 72 72 + return fmt.Errorf("PullSubmissionId should not be nil") 73 73 + } 74 74 + } 75 75 + return nil 76 76 + } 77 77 + 78 78 + func CommentFromRecord(did, rkey string, record tangled.Comment) (*Comment, error) { 79 79 + created, err := time.Parse(time.RFC3339, record.CreatedAt) 80 80 + if err != nil { 81 81 + created = time.Now() 82 82 + } 83 83 + 84 84 + ownerDid := did 85 85 + 86 86 + if _, err = syntax.ParseATURI(record.Subject); err != nil { 87 87 + return nil, err 88 88 + } 89 89 + 90 90 + i := record 91 91 + mentions := make([]syntax.DID, len(record.Mentions)) 92 92 + for i, did := range record.Mentions { 93 93 + mentions[i] = syntax.DID(did) 94 94 + } 95 95 + references := make([]syntax.ATURI, len(record.References)) 96 96 + for i, uri := range i.References { 97 97 + references[i] = syntax.ATURI(uri) 98 98 + } 99 99 + var replyTo *syntax.ATURI 100 100 + if record.ReplyTo != nil { 101 101 + replyToAtUri := syntax.ATURI(*record.ReplyTo) 102 102 + replyTo = &replyToAtUri 103 103 + } 104 104 + 105 105 + comment := Comment{ 106 106 + Did: syntax.DID(ownerDid), 107 107 + Rkey: rkey, 108 108 + Body: record.Body, 109 109 + Subject: syntax.ATURI(record.Subject), 110 110 + ReplyTo: replyTo, 111 111 + Created: created, 112 112 + Mentions: mentions, 113 113 + References: references, 114 114 + } 115 115 + 116 116 + return &comment, nil 117 117 + }

+8 -89

appview/models/issue.go

··· 26 26 27 27 // optionally, populate this when querying for reverse mappings 28 28 // like comment counts, parent repo etc. 29 29 - Comments []IssueComment 29 29 + Comments []Comment 30 30 Labels LabelState 31 31 Repo *Repo 32 32 } ··· 62 62 } 63 63 64 64 type CommentListItem struct { 65 65 - Self *IssueComment 66 66 - Replies []*IssueComment 65 65 + Self *Comment 66 66 + Replies []*Comment 67 67 } 68 68 69 69 func (it *CommentListItem) Participants() []syntax.DID { ··· 88 88 89 89 func (i *Issue) CommentList() []CommentListItem { 90 90 // Create a map to quickly find comments by their aturi 91 91 - toplevel := make(map[string]*CommentListItem) 92 92 - var replies []*IssueComment 91 91 + toplevel := make(map[syntax.ATURI]*CommentListItem) 92 92 + var replies []*Comment 93 93 94 94 // collect top level comments into the map 95 95 for _, comment := range i.Comments { 96 96 if comment.IsTopLevel() { 97 97 - toplevel[comment.AtUri().String()] = &CommentListItem{ 97 97 + toplevel[comment.AtUri()] = &CommentListItem{ 98 98 Self: &comment, 99 99 } 100 100 } else { ··· 115 115 } 116 116 117 117 // sort everything 118 118 - sortFunc := func(a, b *IssueComment) bool { 118 118 + sortFunc := func(a, b *Comment) bool { 119 119 return a.Created.Before(b.Created) 120 120 } 121 121 sort.Slice(listing, func(i, j int) bool { ··· 144 144 addParticipant(i.Did) 145 145 146 146 for _, c := range i.Comments { 147 147 - addParticipant(c.Did) 147 147 + addParticipant(c.Did.String()) 148 148 } 149 149 150 150 return participants ··· 171 171 Open: true, // new issues are open by default 172 172 } 173 173 } 174 174 - 175 175 - type IssueComment struct { 176 176 - Id int64 177 177 - Did string 178 178 - Rkey string 179 179 - IssueAt string 180 180 - ReplyTo *string 181 181 - Body string 182 182 - Created time.Time 183 183 - Edited *time.Time 184 184 - Deleted *time.Time 185 185 - Mentions []syntax.DID 186 186 - References []syntax.ATURI 187 187 - } 188 188 - 189 189 - func (i *IssueComment) AtUri() syntax.ATURI { 190 190 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueCommentNSID, i.Rkey)) 191 191 - } 192 192 - 193 193 - func (i *IssueComment) AsRecord() tangled.RepoIssueComment { 194 194 - mentions := make([]string, len(i.Mentions)) 195 195 - for i, did := range i.Mentions { 196 196 - mentions[i] = string(did) 197 197 - } 198 198 - references := make([]string, len(i.References)) 199 199 - for i, uri := range i.References { 200 200 - references[i] = string(uri) 201 201 - } 202 202 - return tangled.RepoIssueComment{ 203 203 - Body: i.Body, 204 204 - Issue: i.IssueAt, 205 205 - CreatedAt: i.Created.Format(time.RFC3339), 206 206 - ReplyTo: i.ReplyTo, 207 207 - Mentions: mentions, 208 208 - References: references, 209 209 - } 210 210 - } 211 211 - 212 212 - func (i *IssueComment) IsTopLevel() bool { 213 213 - return i.ReplyTo == nil 214 214 - } 215 215 - 216 216 - func (i *IssueComment) IsReply() bool { 217 217 - return i.ReplyTo != nil 218 218 - } 219 219 - 220 220 - func IssueCommentFromRecord(did, rkey string, record tangled.RepoIssueComment) (*IssueComment, error) { 221 221 - created, err := time.Parse(time.RFC3339, record.CreatedAt) 222 222 - if err != nil { 223 223 - created = time.Now() 224 224 - } 225 225 - 226 226 - ownerDid := did 227 227 - 228 228 - if _, err = syntax.ParseATURI(record.Issue); err != nil { 229 229 - return nil, err 230 230 - } 231 231 - 232 232 - i := record 233 233 - mentions := make([]syntax.DID, len(record.Mentions)) 234 234 - for i, did := range record.Mentions { 235 235 - mentions[i] = syntax.DID(did) 236 236 - } 237 237 - references := make([]syntax.ATURI, len(record.References)) 238 238 - for i, uri := range i.References { 239 239 - references[i] = syntax.ATURI(uri) 240 240 - } 241 241 - 242 242 - comment := IssueComment{ 243 243 - Did: ownerDid, 244 244 - Rkey: rkey, 245 245 - Body: record.Body, 246 246 - IssueAt: record.Issue, 247 247 - ReplyTo: record.ReplyTo, 248 248 - Created: created, 249 249 - Mentions: mentions, 250 250 - References: references, 251 251 - } 252 252 - 253 253 - return &comment, nil 254 254 - }

+3 -47

appview/models/pull.go

··· 83 83 Repo *Repo 84 84 } 85 85 86 86 + // NOTE: This method does not include patch blob in returned atproto record 86 87 func (p Pull) AsRecord() tangled.RepoPull { 87 88 var source *tangled.RepoPull_Source 88 89 if p.PullSource != nil { ··· 113 114 Repo: p.RepoAt.String(), 114 115 Branch: p.TargetBranch, 115 116 }, 116 116 - Patch: p.LatestPatch(), 117 117 Source: source, 118 118 } 119 119 return record ··· 138 138 RoundNumber int 139 139 Patch string 140 140 Combined string 141 141 - Comments []PullComment 141 141 + Comments []Comment 142 142 SourceRev string // include the rev that was used to create this submission: only for branch/fork PRs 143 143 144 144 // meta 145 145 Created time.Time 146 146 } 147 147 148 148 - type PullComment struct { 149 149 - // ids 150 150 - ID int 151 151 - PullId int 152 152 - SubmissionId int 153 153 - 154 154 - // at ids 155 155 - RepoAt string 156 156 - OwnerDid string 157 157 - CommentAt string 158 158 - 159 159 - // content 160 160 - Body string 161 161 - 162 162 - // meta 163 163 - Mentions []syntax.DID 164 164 - References []syntax.ATURI 165 165 - 166 166 - // meta 167 167 - Created time.Time 168 168 - } 169 169 - 170 170 - func (p *PullComment) AtUri() syntax.ATURI { 171 171 - return syntax.ATURI(p.CommentAt) 172 172 - } 173 173 - 174 174 - // func (p *PullComment) AsRecord() tangled.RepoPullComment { 175 175 - // mentions := make([]string, len(p.Mentions)) 176 176 - // for i, did := range p.Mentions { 177 177 - // mentions[i] = string(did) 178 178 - // } 179 179 - // references := make([]string, len(p.References)) 180 180 - // for i, uri := range p.References { 181 181 - // references[i] = string(uri) 182 182 - // } 183 183 - // return tangled.RepoPullComment{ 184 184 - // Pull: p.PullAt, 185 185 - // Body: p.Body, 186 186 - // Mentions: mentions, 187 187 - // References: references, 188 188 - // CreatedAt: p.Created.Format(time.RFC3339), 189 189 - // } 190 190 - // } 191 191 - 192 148 func (p *Pull) LastRoundNumber() int { 193 149 return len(p.Submissions) - 1 194 150 } ··· 289 245 addParticipant(s.PullAt.Authority().String()) 290 246 291 247 for _, c := range s.Comments { 292 292 - addParticipant(c.OwnerDid) 248 248 + addParticipant(c.Did.String()) 293 249 } 294 250 295 251 return participants

+111 -113

appview/notify/db/db.go

··· 74 74 // no-op 75 75 } 76 76 77 77 - func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) { 78 78 - collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt())) 77 77 + func (n *databaseNotifier) NewComment(ctx context.Context, comment *models.Comment) { 78 78 + var ( 79 79 + // built the recipients list: 80 80 + // - the owner of the repo 81 81 + // - | if the comment is a reply -> everybody on that thread 82 82 + // | if the comment is a top level -> just the issue owner 83 83 + // - remove mentioned users from the recipients list 84 84 + recipients = sets.New[syntax.DID]() 85 85 + entityType string 86 86 + entityId string 87 87 + repoId *int64 88 88 + issueId *int64 89 89 + pullId *int64 90 90 + ) 91 91 + 92 92 + subjectDid, err := comment.Subject.Authority().AsDID() 79 93 if err != nil { 80 80 - log.Printf("failed to fetch collaborators: %v", err) 94 94 + log.Printf("NewComment: expected did based at-uri for comment.subject") 81 95 return 82 96 } 97 97 + switch comment.Subject.Collection() { 98 98 + case tangled.RepoIssueNSID: 99 99 + issues, err := db.GetIssues( 100 100 + n.db, 101 101 + orm.FilterEq("did", subjectDid), 102 102 + orm.FilterEq("rkey", comment.Subject.RecordKey()), 103 103 + ) 104 104 + if err != nil { 105 105 + log.Printf("NewComment: failed to get issues: %v", err) 106 106 + return 107 107 + } 108 108 + if len(issues) == 0 { 109 109 + log.Printf("NewComment: no issue found for %s", comment.Subject) 110 110 + return 111 111 + } 112 112 + issue := issues[0] 83 113 84 84 - // build the recipients list 85 85 - // - owner of the repo 86 86 - // - collaborators in the repo 87 87 - // - remove users already mentioned 88 88 - recipients := sets.Singleton(syntax.DID(issue.Repo.Did)) 89 89 - for _, c := range collaborators { 90 90 - recipients.Insert(c.SubjectDid) 114 114 + recipients.Insert(syntax.DID(issue.Repo.Did)) 115 115 + if comment.IsReply() { 116 116 + // if this comment is a reply, then notify everybody in that thread 117 117 + parentAtUri := *comment.ReplyTo 118 118 + 119 119 + // find the parent thread, and add all DIDs from here to the recipient list 120 120 + for _, t := range issue.CommentList() { 121 121 + if t.Self.AtUri() == parentAtUri { 122 122 + for _, p := range t.Participants() { 123 123 + recipients.Insert(p) 124 124 + } 125 125 + } 126 126 + } 127 127 + } else { 128 128 + // not a reply, notify just the issue author 129 129 + recipients.Insert(syntax.DID(issue.Did)) 130 130 + } 131 131 + 132 132 + entityType = "issue" 133 133 + entityId = issue.AtUri().String() 134 134 + repoId = &issue.Repo.Id 135 135 + issueId = &issue.Id 136 136 + case tangled.RepoPullNSID: 137 137 + pulls, err := db.GetPullsWithLimit( 138 138 + n.db, 139 139 + 1, 140 140 + orm.FilterEq("owner_did", subjectDid), 141 141 + orm.FilterEq("rkey", comment.Subject.RecordKey()), 142 142 + ) 143 143 + if err != nil { 144 144 + log.Printf("NewComment: failed to get pulls: %v", err) 145 145 + return 146 146 + } 147 147 + if len(pulls) == 0 { 148 148 + log.Printf("NewComment: no pull found for %s", comment.Subject) 149 149 + return 150 150 + } 151 151 + pull := pulls[0] 152 152 + 153 153 + pull.Repo, err = db.GetRepo(n.db, orm.FilterEq("at_uri", pull.RepoAt)) 154 154 + if err != nil { 155 155 + log.Printf("NewComment: failed to get repos: %v", err) 156 156 + return 157 157 + } 158 158 + 159 159 + recipients.Insert(syntax.DID(pull.Repo.Did)) 160 160 + for _, p := range pull.Participants() { 161 161 + recipients.Insert(syntax.DID(p)) 162 162 + } 163 163 + 164 164 + entityType = "pull" 165 165 + entityId = pull.AtUri().String() 166 166 + repoId = &pull.Repo.Id 167 167 + p := int64(pull.ID) 168 168 + pullId = &p 169 169 + default: 170 170 + return // no-op 91 171 } 92 92 - for _, m := range mentions { 172 172 + 173 173 + for _, m := range comment.Mentions { 93 174 recipients.Remove(m) 94 175 } 95 176 96 96 - actorDid := syntax.DID(issue.Did) 97 97 - entityType := "issue" 98 98 - entityId := issue.AtUri().String() 99 99 - repoId := &issue.Repo.Id 100 100 - issueId := &issue.Id 101 101 - var pullId *int64 102 102 - 103 177 n.notifyEvent( 104 104 - actorDid, 178 178 + comment.Did, 105 179 recipients, 106 106 - models.NotificationTypeIssueCreated, 180 180 + models.NotificationTypeIssueCommented, 107 181 entityType, 108 182 entityId, 109 183 repoId, ··· 111 185 pullId, 112 186 ) 113 187 n.notifyEvent( 114 114 - actorDid, 115 115 - sets.Collect(slices.Values(mentions)), 188 188 + comment.Did, 189 189 + sets.Collect(slices.Values(comment.Mentions)), 116 190 models.NotificationTypeUserMentioned, 117 191 entityType, 118 192 entityId, ··· 122 196 ) 123 197 } 124 198 125 125 - func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) { 126 126 - issues, err := db.GetIssues(n.db, orm.FilterEq("at_uri", comment.IssueAt)) 199 199 + func (n *databaseNotifier) DeleteComment(ctx context.Context, comment *models.Comment) { 200 200 + // no-op 201 201 + } 202 202 + 203 203 + func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) { 204 204 + collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt())) 127 205 if err != nil { 128 128 - log.Printf("NewIssueComment: failed to get issues: %v", err) 206 206 + log.Printf("failed to fetch collaborators: %v", err) 129 207 return 130 208 } 131 131 - if len(issues) == 0 { 132 132 - log.Printf("NewIssueComment: no issue found for %s", comment.IssueAt) 133 133 - return 134 134 - } 135 135 - issue := issues[0] 136 209 137 137 - // built the recipients list: 138 138 - // - the owner of the repo 139 139 - // - | if the comment is a reply -> everybody on that thread 140 140 - // | if the comment is a top level -> just the issue owner 141 141 - // - remove mentioned users from the recipients list 210 210 + // build the recipients list 211 211 + // - owner of the repo 212 212 + // - collaborators in the repo 213 213 + // - remove users already mentioned 142 214 recipients := sets.Singleton(syntax.DID(issue.Repo.Did)) 143 143 - 144 144 - if comment.IsReply() { 145 145 - // if this comment is a reply, then notify everybody in that thread 146 146 - parentAtUri := *comment.ReplyTo 147 147 - 148 148 - // find the parent thread, and add all DIDs from here to the recipient list 149 149 - for _, t := range issue.CommentList() { 150 150 - if t.Self.AtUri().String() == parentAtUri { 151 151 - for _, p := range t.Participants() { 152 152 - recipients.Insert(p) 153 153 - } 154 154 - } 155 155 - } 156 156 - } else { 157 157 - // not a reply, notify just the issue author 158 158 - recipients.Insert(syntax.DID(issue.Did)) 215 215 + for _, c := range collaborators { 216 216 + recipients.Insert(c.SubjectDid) 159 217 } 160 160 - 161 218 for _, m := range mentions { 162 219 recipients.Remove(m) 163 220 } 164 221 165 165 - actorDid := syntax.DID(comment.Did) 222 222 + actorDid := syntax.DID(issue.Did) 166 223 entityType := "issue" 167 224 entityId := issue.AtUri().String() 168 225 repoId := &issue.Repo.Id ··· 172 229 n.notifyEvent( 173 230 actorDid, 174 231 recipients, 175 175 - models.NotificationTypeIssueCommented, 232 232 + models.NotificationTypeIssueCreated, 176 233 entityType, 177 234 entityId, 178 235 repoId, ··· 252 309 actorDid, 253 310 recipients, 254 311 eventType, 255 255 - entityType, 256 256 - entityId, 257 257 - repoId, 258 258 - issueId, 259 259 - pullId, 260 260 - ) 261 261 - } 262 262 - 263 263 - func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 264 264 - pull, err := db.GetPull(n.db, 265 265 - syntax.ATURI(comment.RepoAt), 266 266 - comment.PullId, 267 267 - ) 268 268 - if err != nil { 269 269 - log.Printf("NewPullComment: failed to get pulls: %v", err) 270 270 - return 271 271 - } 272 272 - 273 273 - repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", comment.RepoAt)) 274 274 - if err != nil { 275 275 - log.Printf("NewPullComment: failed to get repos: %v", err) 276 276 - return 277 277 - } 278 278 - 279 279 - // build up the recipients list: 280 280 - // - repo owner 281 281 - // - all pull participants 282 282 - // - remove those already mentioned 283 283 - recipients := sets.Singleton(syntax.DID(repo.Did)) 284 284 - for _, p := range pull.Participants() { 285 285 - recipients.Insert(syntax.DID(p)) 286 286 - } 287 287 - for _, m := range mentions { 288 288 - recipients.Remove(m) 289 289 - } 290 290 - 291 291 - actorDid := syntax.DID(comment.OwnerDid) 292 292 - eventType := models.NotificationTypePullCommented 293 293 - entityType := "pull" 294 294 - entityId := pull.AtUri().String() 295 295 - repoId := &repo.Id 296 296 - var issueId *int64 297 297 - p := int64(pull.ID) 298 298 - pullId := &p 299 299 - 300 300 - n.notifyEvent( 301 301 - actorDid, 302 302 - recipients, 303 303 - eventType, 304 304 - entityType, 305 305 - entityId, 306 306 - repoId, 307 307 - issueId, 308 308 - pullId, 309 309 - ) 310 310 - n.notifyEvent( 311 311 - actorDid, 312 312 - sets.Collect(slices.Values(mentions)), 313 313 - models.NotificationTypeUserMentioned, 314 312 entityType, 315 313 entityId, 316 314 repoId,

+8 -8

appview/notify/merged_notifier.go

··· 53 53 m.fanout("DeleteStar", ctx, star) 54 54 } 55 55 56 56 - func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) { 57 57 - m.fanout("NewIssue", ctx, issue, mentions) 56 56 + func (m *mergedNotifier) NewComment(ctx context.Context, comment *models.Comment) { 57 57 + m.fanout("NewComment", ctx, comment) 58 58 } 59 59 60 60 - func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) { 61 61 - m.fanout("NewIssueComment", ctx, comment, mentions) 60 60 + func (m *mergedNotifier) DeleteComment(ctx context.Context, comment *models.Comment) { 61 61 + m.fanout("DeleteComment", ctx, comment) 62 62 + } 63 63 + 64 64 + func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) { 65 65 + m.fanout("NewIssue", ctx, issue, mentions) 62 66 } 63 67 64 68 func (m *mergedNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) { ··· 79 83 80 84 func (m *mergedNotifier) NewPull(ctx context.Context, pull *models.Pull) { 81 85 m.fanout("NewPull", ctx, pull) 82 82 - } 83 83 - 84 84 - func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 85 85 - m.fanout("NewPullComment", ctx, comment, mentions) 86 86 } 87 87 88 88 func (m *mergedNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

+7 -7

appview/notify/notifier.go

··· 13 13 NewStar(ctx context.Context, star *models.Star) 14 14 DeleteStar(ctx context.Context, star *models.Star) 15 15 16 16 + NewComment(ctx context.Context, comment *models.Comment) 17 17 + DeleteComment(ctx context.Context, comment *models.Comment) 18 18 + 16 19 NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) 17 17 - NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) 18 20 NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) 19 21 DeleteIssue(ctx context.Context, issue *models.Issue) 20 22 ··· 22 24 DeleteFollow(ctx context.Context, follow *models.Follow) 23 25 24 26 NewPull(ctx context.Context, pull *models.Pull) 25 25 - NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) 26 27 NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) 27 28 28 29 UpdateProfile(ctx context.Context, profile *models.Profile) ··· 42 43 func (m *BaseNotifier) NewStar(ctx context.Context, star *models.Star) {} 43 44 func (m *BaseNotifier) DeleteStar(ctx context.Context, star *models.Star) {} 44 45 46 46 + func (m *BaseNotifier) NewComment(ctx context.Context, comment *models.Comment) {} 47 47 + func (m *BaseNotifier) DeleteComment(ctx context.Context, comment *models.Comment) {} 48 48 + 45 49 func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {} 46 46 - func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) { 47 47 - } 48 50 func (m *BaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {} 49 51 func (m *BaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue) {} 50 52 51 53 func (m *BaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) {} 52 54 func (m *BaseNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {} 53 55 54 54 - func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {} 55 55 - func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment, mentions []syntax.DID) { 56 56 - } 56 56 + func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {} 57 57 func (m *BaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {} 58 58 59 59 func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {}

+5 -20

appview/notify/posthog/notifier.go

··· 86 86 } 87 87 } 88 88 89 89 - func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 90 90 - err := n.client.Enqueue(posthog.Capture{ 91 91 - DistinctId: comment.OwnerDid, 92 92 - Event: "new_pull_comment", 93 93 - Properties: posthog.Properties{ 94 94 - "repo_at": comment.RepoAt, 95 95 - "pull_id": comment.PullId, 96 96 - "mentions": mentions, 97 97 - }, 98 98 - }) 99 99 - if err != nil { 100 100 - log.Println("failed to enqueue posthog event:", err) 101 101 - } 102 102 - } 103 103 - 104 89 func (n *posthogNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) { 105 90 err := n.client.Enqueue(posthog.Capture{ 106 91 DistinctId: pull.OwnerDid, ··· 180 165 } 181 166 } 182 167 183 183 - func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) { 168 168 + func (n *posthogNotifier) NewComment(ctx context.Context, comment *models.Comment) { 184 169 err := n.client.Enqueue(posthog.Capture{ 185 185 - DistinctId: comment.Did, 186 186 - Event: "new_issue_comment", 170 170 + DistinctId: comment.Did.String(), 171 171 + Event: "new_comment", 187 172 Properties: posthog.Properties{ 188 188 - "issue_at": comment.IssueAt, 189 189 - "mentions": mentions, 173 173 + "subject_at": comment.Subject, 174 174 + "mentions": comment.Mentions, 190 175 }, 191 176 }) 192 177 if err != nil {

appview/pages/assets/apple-touch-icon.png

This is a binary file and will not be displayed.

appview/pages/assets/favicon.ico

This is a binary file and will not be displayed.

-83

appview/pages/assets/favicon.svg

··· 1 1 - <svg 2 2 - version="1.1" 3 3 - id="svg1" 4 4 - width="25" 5 5 - height="25" 6 6 - color="#ffffff" 7 7 - viewBox="0 0 25 25" 8 8 - sodipodi:docname="tangled_dolly_face_only_black_on_trans.svg" 9 9 - inkscape:export-filename="tangled_dolly_silhouette_black_on_trans.svg" 10 10 - inkscape:export-xdpi="96" 11 11 - inkscape:export-ydpi="96" 12 12 - inkscape:version="1.4 (e7c3feb100, 2024-10-09)" 13 13 - xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" 14 14 - xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" 15 15 - xmlns="http://www.w3.org/2000/svg" 16 16 - xmlns:svg="http://www.w3.org/2000/svg" 17 17 - xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 18 18 - xmlns:cc="http://creativecommons.org/ns#"> 19 19 - <sodipodi:namedview 20 20 - id="namedview1" 21 21 - pagecolor="#ffffff" 22 22 - bordercolor="#000000" 23 23 - borderopacity="0.25" 24 24 - inkscape:showpageshadow="2" 25 25 - inkscape:pageopacity="0.0" 26 26 - inkscape:pagecheckerboard="true" 27 27 - inkscape:deskcolor="#d5d5d5" 28 28 - inkscape:zoom="64" 29 29 - inkscape:cx="4.96875" 30 30 - inkscape:cy="13.429688" 31 31 - inkscape:window-width="3840" 32 32 - inkscape:window-height="2160" 33 33 - inkscape:window-x="0" 34 34 - inkscape:window-y="0" 35 35 - inkscape:window-maximized="0" 36 36 - inkscape:current-layer="g1" 37 37 - borderlayer="true"> 38 38 - <inkscape:page 39 39 - x="0" 40 40 - y="0" 41 41 - width="25" 42 42 - height="25" 43 43 - id="page2" 44 44 - margin="0" 45 45 - bleed="0" /> 46 46 - </sodipodi:namedview> 47 47 - <g 48 48 - inkscape:groupmode="layer" 49 49 - inkscape:label="Image" 50 50 - id="g1" 51 51 - transform="translate(-0.42924038,-0.87777209)"> 52 52 - <path 53 53 - class="dolly" 54 54 - fill="currentColor" 55 55 - style="stroke-width:0.111183" 56 56 - d="m 16.775491,24.987061 c -0.78517,-0.0064 -1.384202,-0.234614 -2.033994,-0.631295 -0.931792,-0.490188 -1.643475,-1.31368 -2.152014,-2.221647 C 11.781409,23.136647 10.701392,23.744942 9.4922931,24.0886 8.9774725,24.238111 8.0757679,24.389777 6.5811304,23.84827 4.4270703,23.124679 2.8580086,20.883331 3.0363279,18.599583 3.0037061,17.652919 3.3488675,16.723769 3.8381157,15.925061 2.5329485,15.224503 1.4686756,14.048584 1.0611184,12.606459 0.81344502,11.816973 0.82385989,10.966486 0.91519098,10.154906 1.2422711,8.2387903 2.6795811,6.5725716 4.5299585,5.9732484 5.2685364,4.290122 6.8802592,3.0349975 8.706276,2.7794663 c 1.2124148,-0.1688264 2.46744,0.084987 3.52811,0.7011837 1.545426,-1.7139736 4.237779,-2.2205077 6.293579,-1.1676231 1.568222,0.7488935 2.689625,2.3113526 2.961888,4.0151464 1.492195,0.5977882 2.749007,1.8168898 3.242225,3.3644951 0.329805,0.9581836 0.340709,2.0135956 0.127128,2.9974286 -0.381606,1.535184 -1.465322,2.842146 -2.868035,3.556463 0.0034,0.273204 0.901506,2.243045 0.751284,3.729647 -0.03281,1.858525 -1.211631,3.619894 -2.846433,4.475452 -0.953967,0.556812 -2.084452,0.546309 -3.120531,0.535398 z m -4.470079,-5.349839 c 1.322246,-0.147248 2.189053,-1.300106 2.862307,-2.338363 0.318287,-0.472954 0.561404,-1.002348 0.803,-1.505815 0.313265,0.287151 0.578698,0.828085 1.074141,0.956909 0.521892,0.162542 1.133743,0.03052 1.45325,-0.443554 0.611414,-1.140449 0.31004,-2.516537 -0.04602,-3.698347 C 18.232844,11.92927 17.945151,11.232927 17.397785,10.751793 17.514522,9.9283111 17.026575,9.0919791 16.332883,8.6609491 15.741721,9.1323278 14.842258,9.1294949 14.271975,8.6252369 13.178927,9.7400102 12.177239,9.7029996 11.209704,8.8195135 10.992255,8.6209543 10.577326,10.031484 9.1211947,9.2324497 8.2846288,9.9333947 7.6359672,10.607693 7.0611981,11.578553 6.5026891,12.62523 5.9177873,13.554793 5.867393,14.69141 c -0.024234,0.66432 0.4948601,1.360337 1.1982269,1.306329 0.702996,0.06277 1.1815208,-0.629091 1.7138087,-0.916491 0.079382,0.927141 0.1688108,1.923227 0.4821259,2.828358 0.3596254,1.171275 1.6262605,1.915695 2.8251855,1.745211 0.08481,-0.0066 0.218672,-0.01769 0.218672,-0.0176 z" 57 57 - id="path7" 58 58 - sodipodi:nodetypes="sccccccccccccccccccsscccccccccscccccccsc" /> 59 59 - </g> 60 60 - <metadata 61 61 - id="metadata1"> 62 62 - <rdf:RDF> 63 63 - <cc:Work 64 64 - rdf:about=""> 65 65 - <cc:license 66 66 - rdf:resource="http://creativecommons.org/licenses/by/4.0/" /> 67 67 - </cc:Work> 68 68 - <cc:License 69 69 - rdf:about="http://creativecommons.org/licenses/by/4.0/"> 70 70 - <cc:permits 71 71 - rdf:resource="http://creativecommons.org/ns#Reproduction" /> 72 72 - <cc:permits 73 73 - rdf:resource="http://creativecommons.org/ns#Distribution" /> 74 74 - <cc:requires 75 75 - rdf:resource="http://creativecommons.org/ns#Notice" /> 76 76 - <cc:requires 77 77 - rdf:resource="http://creativecommons.org/ns#Attribution" /> 78 78 - <cc:permits 79 79 - rdf:resource="http://creativecommons.org/ns#DerivativeWorks" /> 80 80 - </cc:License> 81 81 - </rdf:RDF> 82 82 - </metadata> 83 83 - </svg>

+9 -12

appview/pages/pages.go

··· 210 210 return tpl.ExecuteTemplate(w, "layouts/base", params) 211 211 } 212 212 213 213 + func (p *Pages) Favicon(w io.Writer) error { 214 214 + return p.executePlain("fragments/dolly/silhouette", w, nil) 215 215 + } 216 216 + 213 217 type LoginParams struct { 214 218 ReturnUrl string 215 219 ErrorCode string ··· 984 988 LoggedInUser *oauth.User 985 989 RepoInfo repoinfo.RepoInfo 986 990 Issue *models.Issue 987 987 - Comment *models.IssueComment 991 991 + Comment *models.Comment 988 992 } 989 993 990 994 func (p *Pages) EditIssueCommentFragment(w io.Writer, params EditIssueCommentParams) error { ··· 995 999 LoggedInUser *oauth.User 996 1000 RepoInfo repoinfo.RepoInfo 997 1001 Issue *models.Issue 998 998 - Comment *models.IssueComment 1002 1002 + Comment *models.Comment 999 1003 } 1000 1004 1001 1005 func (p *Pages) ReplyIssueCommentPlaceholderFragment(w io.Writer, params ReplyIssueCommentPlaceholderParams) error { ··· 1006 1010 LoggedInUser *oauth.User 1007 1011 RepoInfo repoinfo.RepoInfo 1008 1012 Issue *models.Issue 1009 1009 - Comment *models.IssueComment 1013 1013 + Comment *models.Comment 1010 1014 } 1011 1015 1012 1016 func (p *Pages) ReplyIssueCommentFragment(w io.Writer, params ReplyIssueCommentParams) error { ··· 1017 1021 LoggedInUser *oauth.User 1018 1022 RepoInfo repoinfo.RepoInfo 1019 1023 Issue *models.Issue 1020 1020 - Comment *models.IssueComment 1024 1024 + Comment *models.Comment 1021 1025 } 1022 1026 1023 1027 func (p *Pages) IssueCommentBodyFragment(w io.Writer, params IssueCommentBodyParams) error { ··· 1410 1414 return Cache(http.StripPrefix("/static/", http.FileServer(http.FS(sub)))) 1411 1415 } 1412 1416 1413 1413 - func (p *Pages) StaticRedirect(target string) http.HandlerFunc { 1414 1414 - return func(w http.ResponseWriter, r *http.Request) { 1415 1415 - http.Redirect(w, r, target, http.StatusMovedPermanently) 1416 1416 - } 1417 1417 - } 1418 1418 - 1419 1417 func Cache(h http.Handler) http.Handler { 1420 1418 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 1421 1419 path := strings.Split(r.URL.Path, "?")[0] 1422 1420 1423 1421 if strings.HasSuffix(path, ".css") { 1424 1424 - // one day for css files 1422 1422 + // on day for css files 1425 1423 w.Header().Set("Cache-Control", "public, max-age=86400") 1426 1424 } else { 1427 1427 - // one year for others 1428 1425 w.Header().Set("Cache-Control", "public, max-age=31536000, immutable") 1429 1426 } 1430 1427 h.ServeHTTP(w, r)

+1 -1

appview/pages/templates/banner.html

··· 30 30 <div class="mx-6"> 31 31 These services may not be fully accessible until upgraded. 32 32 <a class="underline text-red-800 dark:text-red-200" 33 33 - href="https://tangled.org/@tangled.org/core/tree/master/docs/migrations.md"> 33 33 + href="https://docs.tangled.org/migrating-knots-spindles.html#migrating-knots-spindles"> 34 34 Click to read the upgrade guide</a>. 35 35 </div> 36 36 </details>

+1 -1

appview/pages/templates/knots/index.html

··· 105 105 {{ define "docsButton" }} 106 106 <a 107 107 class="btn flex items-center gap-2" 108 108 - href="https://tangled.org/@tangled.org/core/blob/master/docs/knot-hosting.md"> 108 108 + href="https://docs.tangled.org/knot-self-hosting-guide.html#knot-self-hosting-guide"> 109 109 {{ i "book" "size-4" }} 110 110 docs 111 111 </a>

-5

appview/pages/templates/layouts/base.html

··· 7 7 <meta name="description" content="Social coding, but for real this time!"/> 8 8 <meta name="htmx-config" content='{"includeIndicatorStyles": false}'> 9 9 10 10 - <!-- favicon/web manifest --> 11 11 - <link rel="icon" href="/favicon.ico" sizes="48x48"/> 12 12 - <link rel="icon" href="/favicon.svg" sizes="any" type="image/svg+xml"/> 13 13 - <link rel="apple-touch-icon" href="/static/apple-touch-icon.png"/> 14 14 - 15 10 <script defer src="/static/htmx.min.js"></script> 16 11 <script defer src="/static/htmx-ext-ws.min.js"></script> 17 12 <script defer src="/static/actor-typeahead.js" type="module"></script>

+2 -2

appview/pages/templates/layouts/fragments/footer.html

··· 26 26 <div class="flex flex-col gap-1"> 27 27 <div class="{{ $headerStyle }}">resources</div> 28 28 <a href="https://blog.tangled.org" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a> 29 29 - <a href="https://tangled.org/@tangled.org/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a> 29 29 + <a href="https://docs.tangled.org" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a> 30 30 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a> 31 31 <a href="https://tangled.org/brand" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a> 32 32 </div> ··· 73 73 <div class="flex flex-col gap-1"> 74 74 <div class="{{ $headerStyle }}">resources</div> 75 75 <a href="https://blog.tangled.org" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a> 76 76 - <a href="https://tangled.org/@tangled.org/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a> 76 76 + <a href="https://docs.tangled.org" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a> 77 77 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a> 78 78 <a href="https://tangled.org/brand" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a> 79 79 </div>

+1 -1

appview/pages/templates/repo/fragments/diff.html

··· 17 17 {{ else }} 18 18 {{ range $idx, $hunk := $diff }} 19 19 {{ with $hunk }} 20 20 - <details open id="file-{{ .Name.New }}" class="group border border-gray-200 dark:border-gray-700 w-full mx-auto rounded bg-white dark:bg-gray-800 drop-shadow-sm" tabindex="{{ add $idx 1 }}"> 20 20 + <details open id="file-{{ .Id }}" class="group border border-gray-200 dark:border-gray-700 w-full mx-auto rounded bg-white dark:bg-gray-800 drop-shadow-sm" tabindex="{{ add $idx 1 }}"> 21 21 <summary class="list-none cursor-pointer sticky top-0"> 22 22 <div id="diff-file-header" class="rounded cursor-pointer bg-white dark:bg-gray-800 flex justify-between"> 23 23 <div id="left-side-items" class="p-2 flex gap-2 items-center overflow-x-auto">

+35 -35

appview/pages/templates/repo/fragments/splitDiff.html

··· 3 3 {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800" -}} 4 4 {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}} 5 5 {{- $lineNrSepStyle := "pr-2 border-r border-gray-200 dark:border-gray-700" -}} 6 6 - {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}} 6 6 + {{- $containerStyle := "inline-flex w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}} 7 7 {{- $emptyStyle := "bg-gray-200/30 dark:bg-gray-700/30" -}} 8 8 {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400" -}} 9 9 {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}} 10 10 {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}} 11 11 {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}} 12 12 <div class="grid grid-cols-2 divide-x divide-gray-200 dark:divide-gray-700"> 13 13 - <pre class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div> 13 13 + <div class="overflow-x-auto col-span-1 font-mono leading-normal"><div class="overflow-x-auto"><div class="inline-flex flex-col min-w-full">{{- range .TextFragments -}}<span class="block bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</span> 14 14 {{- range .LeftLines -}} 15 15 {{- if .IsEmpty -}} 16 16 - <div class="{{ $emptyStyle }} {{ $containerStyle }}"> 17 17 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></div> 18 18 - <div class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></div> 19 19 - <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div> 20 20 - </div> 16 16 + <span class="{{ $emptyStyle }} {{ $containerStyle }}"> 17 17 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></span> 18 18 + <span class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></span> 19 19 + <span class="px-2 invisible" aria-hidden="true">{{ .Content }}</span> 20 20 + </span> 21 21 {{- else if eq .Op.String "-" -}} 22 22 - <div class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}"> 23 23 - <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></div> 24 24 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 25 25 - <div class="px-2">{{ .Content }}</div> 26 26 - </div> 22 22 + <span class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}"> 23 23 + <span class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></span> 24 24 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 25 25 + <span class="px-2 whitespace-pre">{{ .Content }}</span> 26 26 + </span> 27 27 {{- else if eq .Op.String " " -}} 28 28 - <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}"> 29 29 - <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></div> 30 30 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 31 31 - <div class="px-2">{{ .Content }}</div> 32 32 - </div> 28 28 + <span class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}"> 29 29 + <span class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></span> 30 30 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 31 31 + <span class="px-2 whitespace-pre">{{ .Content }}</span> 32 32 + </span> 33 33 {{- end -}} 34 34 {{- end -}} 35 35 - {{- end -}}</div></div></pre> 35 35 + {{- end -}}</div></div></div> 36 36 37 37 - <pre class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div> 37 37 + <div class="overflow-x-auto col-span-1 font-mono leading-normal"><div class="overflow-x-auto"><div class="inline-flex flex-col min-w-full">{{- range .TextFragments -}}<span class="block bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</span> 38 38 {{- range .RightLines -}} 39 39 {{- if .IsEmpty -}} 40 40 - <div class="{{ $emptyStyle }} {{ $containerStyle }}"> 41 41 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></div> 42 42 - <div class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></div> 43 43 - <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div> 44 44 - </div> 40 40 + <span class="{{ $emptyStyle }} {{ $containerStyle }}"> 41 41 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></span> 42 42 + <span class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></span> 43 43 + <span class="px-2 invisible" aria-hidden="true">{{ .Content }}</span> 44 44 + </span> 45 45 {{- else if eq .Op.String "+" -}} 46 46 - <div class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}"> 47 47 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a></div> 48 48 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 49 49 - <div class="px-2" >{{ .Content }}</div> 50 50 - </div> 46 46 + <span class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}"> 47 47 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a></span> 48 48 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 49 49 + <span class="px-2 whitespace-pre">{{ .Content }}</span> 50 50 + </span> 51 51 {{- else if eq .Op.String " " -}} 52 52 - <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}"> 53 53 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a></div> 54 54 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 55 55 - <div class="px-2">{{ .Content }}</div> 56 56 - </div> 52 52 + <span class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}"> 53 53 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a> </span> 54 54 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 55 55 + <span class="px-2 whitespace-pre">{{ .Content }}</span> 56 56 + </span> 57 57 {{- end -}} 58 58 {{- end -}} 59 59 - {{- end -}}</div></div></pre> 59 59 + {{- end -}}</div></div></div> 60 60 </div> 61 61 {{ end }}

+21 -22

appview/pages/templates/repo/fragments/unifiedDiff.html

··· 1 1 {{ define "repo/fragments/unifiedDiff" }} 2 2 {{ $name := .Id }} 3 3 - <pre class="overflow-x-auto"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div> 3 3 + <div class="overflow-x-auto font-mono leading-normal"><div class="overflow-x-auto"><div class="inline-flex flex-col min-w-full">{{- range .TextFragments -}}<span class="block bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</span> 4 4 {{- $oldStart := .OldPosition -}} 5 5 {{- $newStart := .NewPosition -}} 6 6 {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800 target:bg-yellow-200 target:dark:bg-yellow-600" -}} 7 7 {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}} 8 8 {{- $lineNrSepStyle1 := "" -}} 9 9 {{- $lineNrSepStyle2 := "pr-2 border-r border-gray-200 dark:border-gray-700" -}} 10 10 - {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}} 10 10 + {{- $containerStyle := "inline-flex w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}} 11 11 {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400 " -}} 12 12 {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}} 13 13 {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}} 14 14 {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}} 15 15 {{- range .Lines -}} 16 16 {{- if eq .Op.String "+" -}} 17 17 - <div class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{$newStart}}"> 18 18 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><span aria-hidden="true" class="invisible">{{$newStart}}</span></div> 19 19 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{$newStart}}">{{ $newStart }}</a></div> 20 20 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 21 21 - <div class="px-2">{{ .Line }}</div> 22 22 - </div> 17 17 + <span class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{$newStart}}"> 18 18 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><span aria-hidden="true" class="invisible">{{$newStart}}</span></span> 19 19 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{$newStart}}">{{ $newStart }}</a></span> 20 20 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 21 21 + <span class="px-2 whitespace-pre">{{ .Line }}</span> 22 22 + </span> 23 23 {{- $newStart = add64 $newStart 1 -}} 24 24 {{- end -}} 25 25 {{- if eq .Op.String "-" -}} 26 26 - <div class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}"> 27 27 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}">{{ $oldStart }}</a></div> 28 28 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><span aria-hidden="true" class="invisible">{{$oldStart}}</span></div> 29 29 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 30 30 - <div class="px-2">{{ .Line }}</div> 31 31 - </div> 26 26 + <span class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}"> 27 27 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}">{{ $oldStart }}</a></span> 28 28 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><span aria-hidden="true" class="invisible">{{$oldStart}}</span></span> 29 29 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 30 30 + <span class="px-2 whitespace-pre">{{ .Line }}</span> 31 31 + </span> 32 32 {{- $oldStart = add64 $oldStart 1 -}} 33 33 {{- end -}} 34 34 {{- if eq .Op.String " " -}} 35 35 - <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}-N{{$newStart}}"> 36 36 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $oldStart }}</a></div> 37 37 - <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $newStart }}</a></div> 38 38 - <div class="{{ $opStyle }}">{{ .Op.String }}</div> 39 39 - <div class="px-2">{{ .Line }}</div> 40 40 - </div> 35 35 + <span class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}-N{{$newStart}}"> 36 36 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $oldStart }}</a></span> 37 37 + <span class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $newStart }}</a></span> 38 38 + <span class="{{ $opStyle }}">{{ .Op.String }}</span> 39 39 + <span class="px-2 whitespace-pre">{{ .Line }}</span> 40 40 + </span> 41 41 {{- $newStart = add64 $newStart 1 -}} 42 42 {{- $oldStart = add64 $oldStart 1 -}} 43 43 {{- end -}} 44 44 {{- end -}} 45 45 - {{- end -}}</div></div></pre> 45 45 + {{- end -}}</div></div></div> 46 46 {{ end }} 47 47 -

+2 -2

appview/pages/templates/repo/issues/fragments/issueCommentHeader.html

··· 1 1 {{ define "repo/issues/fragments/issueCommentHeader" }} 2 2 <div class="flex flex-wrap items-center gap-2 text-sm text-gray-500 dark:text-gray-400 "> 3 3 - {{ template "user/fragments/picHandleLink" .Comment.Did }} 3 3 + {{ template "user/fragments/picHandleLink" .Comment.Did.String }} 4 4 {{ template "hats" $ }} 5 5 {{ template "timestamp" . }} 6 6 - {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did) }} 6 6 + {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did.String) }} 7 7 {{ if and $isCommentOwner (not .Comment.Deleted) }} 8 8 {{ template "editIssueComment" . }} 9 9 {{ template "deleteIssueComment" . }}

+1 -1

appview/pages/templates/repo/pipelines/pipelines.html

··· 23 23 </p> 24 24 <p> 25 25 <span class="{{ $bullet }}">2</span>Configure your CI/CD 26 26 - <a href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/pipeline.md" class="underline">pipeline</a>. 26 26 + <a href="https://docs.tangled.org/spindles.html#pipelines" class="underline">pipeline</a>. 27 27 </p> 28 28 <p><span class="{{ $bullet }}">3</span>Trigger a workflow with a push or a pull-request!</p> 29 29 </div>

+3 -3

appview/pages/templates/repo/pulls/pull.html

··· 165 165 166 166 <div class="md:pl-[3.5rem] flex flex-col gap-2 mt-2 relative"> 167 167 {{ range $cidx, $c := .Comments }} 168 168 - <div id="comment-{{$c.ID}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full"> 168 168 + <div id="comment-{{$c.Id}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full"> 169 169 {{ if gt $cidx 0 }} 170 170 <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 171 171 {{ end }} 172 172 <div class="text-sm text-gray-500 dark:text-gray-400 flex items-center gap-1"> 173 173 - {{ template "user/fragments/picHandleLink" $c.OwnerDid }} 173 173 + {{ template "user/fragments/picHandleLink" $c.Did.String }} 174 174 <span class="before:content-['·']"></span> 175 175 - <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-300" href="#comment-{{.ID}}">{{ template "repo/fragments/time" $c.Created }}</a> 175 175 + <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-300" href="#comment-{{.Id}}">{{ template "repo/fragments/time" $c.Created }}</a> 176 176 </div> 177 177 <div class="prose dark:prose-invert"> 178 178 {{ $c.Body | markdown }}

+1 -1

appview/pages/templates/repo/settings/pipelines.html

··· 22 22 <p class="text-gray-500 dark:text-gray-400"> 23 23 Choose a spindle to execute your workflows on. Only repository owners 24 24 can configure spindles. Spindles can be selfhosted, 25 25 - <a class="text-gray-500 dark:text-gray-400 underline" href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md"> 25 25 + <a class="text-gray-500 dark:text-gray-400 underline" href="https://docs.tangled.org/spindles.html#self-hosting-guide"> 26 26 click to learn more. 27 27 </a> 28 28 </p>

+1 -1

appview/pages/templates/spindles/index.html

··· 102 102 {{ define "docsButton" }} 103 103 <a 104 104 class="btn flex items-center gap-2" 105 105 - href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md"> 105 105 + href="https://docs.tangled.org/spindles.html#self-hosting-guide"> 106 106 {{ i "book" "size-4" }} 107 107 docs 108 108 </a>

+1 -1

appview/pulls/opengraph.go

··· 277 277 } 278 278 279 279 // Get comment count from database 280 280 - comments, err := db.GetPullComments(s.db, orm.FilterEq("pull_id", pull.ID)) 280 280 + comments, err := db.GetComments(s.db, orm.FilterEq("subject_at", pull.AtUri())) 281 281 if err != nil { 282 282 log.Printf("failed to get pull comments: %v", err) 283 283 }

+72 -59

appview/pulls/pulls.go

··· 741 741 } 742 742 defer tx.Rollback() 743 743 744 744 - createdAt := time.Now().Format(time.RFC3339) 744 744 + comment := models.Comment{ 745 745 + Did: syntax.DID(user.Did), 746 746 + Rkey: tid.TID(), 747 747 + Subject: pull.AtUri(), 748 748 + ReplyTo: nil, 749 749 + Body: body, 750 750 + Created: time.Now(), 751 751 + Mentions: mentions, 752 752 + References: references, 753 753 + PullSubmissionId: &pull.Submissions[roundNumber].ID, 754 754 + } 755 755 + if err = comment.Validate(); err != nil { 756 756 + log.Println("failed to validate comment", err) 757 757 + s.pages.Notice(w, "pull-comment", "Failed to create comment.") 758 758 + return 759 759 + } 760 760 + record := comment.AsRecord() 745 761 746 762 client, err := s.oauth.AuthorizedClient(r) 747 763 if err != nil { ··· 749 765 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 750 766 return 751 767 } 752 752 - atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 753 753 - Collection: tangled.RepoPullCommentNSID, 768 768 + _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 769 769 + Collection: tangled.CommentNSID, 754 770 Repo: user.Did, 755 755 - Rkey: tid.TID(), 771 771 + Rkey: comment.Rkey, 756 772 Record: &lexutil.LexiconTypeDecoder{ 757 757 - Val: &tangled.RepoPullComment{ 758 758 - Pull: pull.AtUri().String(), 759 759 - Body: body, 760 760 - CreatedAt: createdAt, 761 761 - }, 773 773 + Val: &record, 762 774 }, 763 775 }) 764 776 if err != nil { ··· 767 779 return 768 780 } 769 781 770 770 - comment := &models.PullComment{ 771 771 - OwnerDid: user.Did, 772 772 - RepoAt: f.RepoAt().String(), 773 773 - PullId: pull.PullId, 774 774 - Body: body, 775 775 - CommentAt: atResp.Uri, 776 776 - SubmissionId: pull.Submissions[roundNumber].ID, 777 777 - Mentions: mentions, 778 778 - References: references, 779 779 - } 780 780 - 781 782 // Create the pull comment in the database with the commentAt field 782 782 - commentId, err := db.NewPullComment(tx, comment) 783 783 + err = db.PutComment(tx, &comment) 783 784 if err != nil { 784 785 log.Println("failed to create pull comment", err) 785 786 s.pages.Notice(w, "pull-comment", "Failed to create comment.") ··· 793 794 return 794 795 } 795 796 796 796 - s.notifier.NewPullComment(r.Context(), comment, mentions) 797 797 + s.notifier.NewComment(r.Context(), &comment) 797 798 798 799 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 799 799 - s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId)) 800 800 + s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, comment.Id)) 800 801 return 801 802 } 802 803 } ··· 1241 1242 return 1242 1243 } 1243 1244 1245 1245 + blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch)) 1246 1246 + if err != nil { 1247 1247 + log.Println("failed to upload patch", err) 1248 1248 + s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1249 1249 + return 1250 1250 + } 1251 1251 + 1244 1252 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 1245 1253 Collection: tangled.RepoPullNSID, 1246 1254 Repo: user.Did, ··· 1252 1260 Repo: string(repo.RepoAt()), 1253 1261 Branch: targetBranch, 1254 1262 }, 1255 1255 - Patch: patch, 1263 1263 + PatchBlob: blob.Blob, 1256 1264 Source: recordPullSource, 1257 1265 CreatedAt: time.Now().Format(time.RFC3339), 1258 1266 }, ··· 1328 1336 // apply all record creations at once 1329 1337 var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem 1330 1338 for _, p := range stack { 1339 1339 + blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(p.LatestPatch())) 1340 1340 + if err != nil { 1341 1341 + log.Println("failed to upload patch blob", err) 1342 1342 + s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1343 1343 + return 1344 1344 + } 1345 1345 + 1331 1346 record := p.AsRecord() 1332 1332 - write := comatproto.RepoApplyWrites_Input_Writes_Elem{ 1347 1347 + record.PatchBlob = blob.Blob 1348 1348 + writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 1333 1349 RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{ 1334 1350 Collection: tangled.RepoPullNSID, 1335 1351 Rkey: &p.Rkey, ··· 1337 1353 Val: &record, 1338 1354 }, 1339 1355 }, 1340 1340 - } 1341 1341 - writes = append(writes, &write) 1356 1356 + }) 1342 1357 } 1343 1358 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 1344 1359 Repo: user.Did, ··· 1871 1886 return 1872 1887 } 1873 1888 1874 1874 - var recordPullSource *tangled.RepoPull_Source 1875 1875 - if pull.IsBranchBased() { 1876 1876 - recordPullSource = &tangled.RepoPull_Source{ 1877 1877 - Branch: pull.PullSource.Branch, 1878 1878 - Sha: sourceRev, 1879 1879 - } 1889 1889 + blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch)) 1890 1890 + if err != nil { 1891 1891 + log.Println("failed to upload patch blob", err) 1892 1892 + s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 1893 1893 + return 1880 1894 } 1881 1881 - if pull.IsForkBased() { 1882 1882 - repoAt := pull.PullSource.RepoAt.String() 1883 1883 - recordPullSource = &tangled.RepoPull_Source{ 1884 1884 - Branch: pull.PullSource.Branch, 1885 1885 - Repo: &repoAt, 1886 1886 - Sha: sourceRev, 1887 1887 - } 1888 1888 - } 1895 1895 + record := pull.AsRecord() 1896 1896 + record.PatchBlob = blob.Blob 1897 1897 + record.CreatedAt = time.Now().Format(time.RFC3339) 1889 1898 1890 1899 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 1891 1900 Collection: tangled.RepoPullNSID, ··· 1893 1902 Rkey: pull.Rkey, 1894 1903 SwapRecord: ex.Cid, 1895 1904 Record: &lexutil.LexiconTypeDecoder{ 1896 1896 - Val: &tangled.RepoPull{ 1897 1897 - Title: pull.Title, 1898 1898 - Target: &tangled.RepoPull_Target{ 1899 1899 - Repo: string(repo.RepoAt()), 1900 1900 - Branch: pull.TargetBranch, 1901 1901 - }, 1902 1902 - Patch: patch, // new patch 1903 1903 - Source: recordPullSource, 1904 1904 - CreatedAt: time.Now().Format(time.RFC3339), 1905 1905 - }, 1905 1905 + Val: &record, 1906 1906 }, 1907 1907 }) 1908 1908 if err != nil { ··· 1988 1988 } 1989 1989 defer tx.Rollback() 1990 1990 1991 1991 + client, err := s.oauth.AuthorizedClient(r) 1992 1992 + if err != nil { 1993 1993 + log.Println("failed to authorize client") 1994 1994 + s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1995 1995 + return 1996 1996 + } 1997 1997 + 1991 1998 // pds updates to make 1992 1999 var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem 1993 2000 ··· 2021 2028 return 2022 2029 } 2023 2030 2031 2031 + blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch)) 2032 2032 + if err != nil { 2033 2033 + log.Println("failed to upload patch blob", err) 2034 2034 + s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 2035 2035 + return 2036 2036 + } 2024 2037 record := p.AsRecord() 2038 2038 + record.PatchBlob = blob.Blob 2025 2039 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 2026 2040 RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{ 2027 2041 Collection: tangled.RepoPullNSID, ··· 2056 2070 return 2057 2071 } 2058 2072 2073 2073 + blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch)) 2074 2074 + if err != nil { 2075 2075 + log.Println("failed to upload patch blob", err) 2076 2076 + s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 2077 2077 + return 2078 2078 + } 2059 2079 record := np.AsRecord() 2060 2060 - 2080 2080 + record.PatchBlob = blob.Blob 2061 2081 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 2062 2082 RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{ 2063 2083 Collection: tangled.RepoPullNSID, ··· 2091 2111 if err != nil { 2092 2112 log.Println("failed to resubmit pull", err) 2093 2113 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2094 2094 - return 2095 2095 - } 2096 2096 - 2097 2097 - client, err := s.oauth.AuthorizedClient(r) 2098 2098 - if err != nil { 2099 2099 - log.Println("failed to authorize client") 2100 2100 - s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 2101 2114 return 2102 2115 } 2103 2116

+1

appview/repo/archive.go

··· 18 18 l := rp.logger.With("handler", "DownloadArchive") 19 19 ref := chi.URLParam(r, "ref") 20 20 ref, _ = url.PathUnescape(ref) 21 21 + ref = strings.TrimSuffix(ref, ".tar.gz") 21 22 f, err := rp.repoResolver.Resolve(r) 22 23 if err != nil { 23 24 l.Error("failed to get repo and knot", "err", err)

+26 -1

appview/reporesolver/resolver.go

··· 63 63 } 64 64 65 65 // get dir/ref 66 66 - currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath())) 66 66 + currentDir := extractCurrentDir(r.URL.EscapedPath()) 67 67 ref := chi.URLParam(r, "ref") 68 68 69 69 repoAt := repo.RepoAt() ··· 130 130 } 131 131 132 132 return repoInfo 133 133 + } 134 134 + 135 135 + // extractCurrentDir gets the current directory for markdown link resolution. 136 136 + // for blob paths, returns the parent dir. for tree paths, returns the path itself. 137 137 + // 138 138 + // /@user/repo/blob/main/docs/README.md => docs 139 139 + // /@user/repo/tree/main/docs => docs 140 140 + func extractCurrentDir(fullPath string) string { 141 141 + fullPath = strings.TrimPrefix(fullPath, "/") 142 142 + 143 143 + blobPattern := regexp.MustCompile(`blob/[^/]+/(.*)$`) 144 144 + if matches := blobPattern.FindStringSubmatch(fullPath); len(matches) > 1 { 145 145 + return path.Dir(matches[1]) 146 146 + } 147 147 + 148 148 + treePattern := regexp.MustCompile(`tree/[^/]+/(.*)$`) 149 149 + if matches := treePattern.FindStringSubmatch(fullPath); len(matches) > 1 { 150 150 + dir := strings.TrimSuffix(matches[1], "/") 151 151 + if dir == "" { 152 152 + return "." 153 153 + } 154 154 + return dir 155 155 + } 156 156 + 157 157 + return "." 133 158 } 134 159 135 160 // extractPathAfterRef gets the actual repository path

+22

appview/reporesolver/resolver_test.go

··· 1 1 + package reporesolver 2 2 + 3 3 + import "testing" 4 4 + 5 5 + func TestExtractCurrentDir(t *testing.T) { 6 6 + tests := []struct { 7 7 + path string 8 8 + want string 9 9 + }{ 10 10 + {"/@user/repo/blob/main/docs/README.md", "docs"}, 11 11 + {"/@user/repo/blob/main/README.md", "."}, 12 12 + {"/@user/repo/tree/main/docs", "docs"}, 13 13 + {"/@user/repo/tree/main/docs/", "docs"}, 14 14 + {"/@user/repo/tree/main", "."}, 15 15 + } 16 16 + 17 17 + for _, tt := range tests { 18 18 + if got := extractCurrentDir(tt.path); got != tt.want { 19 19 + t.Errorf("extractCurrentDir(%q) = %q, want %q", tt.path, got, tt.want) 20 20 + } 21 21 + } 22 22 + }

-5

appview/spindles/spindles.go

··· 653 653 s.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.") 654 654 return 655 655 } 656 656 - if memberId.Handle.IsInvalidHandle() { 657 657 - l.Error("failed to resolve member identity to handle") 658 658 - s.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.") 659 659 - return 660 660 - } 661 656 662 657 tx, err := s.Db.Begin() 663 658 if err != nil {

+6 -4

appview/state/profile.go

··· 163 163 } 164 164 165 165 // populate commit counts in the timeline, using the punchcard 166 166 - currentMonth := time.Now().Month() 166 166 + now := time.Now() 167 167 for _, p := range profile.Punchcard.Punches { 168 168 - idx := currentMonth - p.Date.Month() 169 169 - if int(idx) < len(timeline.ByMonth) { 170 170 - timeline.ByMonth[idx].Commits += p.Count 168 168 + years := now.Year() - p.Date.Year() 169 169 + months := int(now.Month() - p.Date.Month()) 170 170 + monthsAgo := years*12 + months 171 171 + if monthsAgo >= 0 && monthsAgo < len(timeline.ByMonth) { 172 172 + timeline.ByMonth[monthsAgo].Commits += p.Count 171 173 } 172 174 } 173 175

+4 -2

appview/state/router.go

··· 32 32 s.pages, 33 33 ) 34 34 35 35 - router.Get("/favicon.ico", s.pages.StaticRedirect("/static/favicon.ico")) 36 36 - router.Get("/favicon.svg", s.pages.StaticRedirect("/static/favicon.svg")) 35 35 + router.Get("/favicon.svg", s.Favicon) 36 36 + router.Get("/favicon.ico", s.Favicon) 37 37 router.Get("/pwa-manifest.json", s.PWAManifest) 38 38 router.Get("/robots.txt", s.RobotsTxt) 39 39 ··· 109 109 }) 110 110 111 111 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 112 112 + w.WriteHeader(http.StatusNotFound) 112 113 s.pages.Error404(w) 113 114 }) 114 115 ··· 182 183 r.Get("/brand", s.Brand) 183 184 184 185 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 186 186 + w.WriteHeader(http.StatusNotFound) 185 187 s.pages.Error404(w) 186 188 }) 187 189 return r

+14 -1

appview/state/state.go

··· 117 117 tangled.SpindleNSID, 118 118 tangled.StringNSID, 119 119 tangled.RepoIssueNSID, 120 120 - tangled.RepoIssueCommentNSID, 120 120 + tangled.CommentNSID, 121 121 tangled.LabelDefinitionNSID, 122 122 tangled.LabelOpNSID, 123 123 }, ··· 200 200 func (s *State) Close() error { 201 201 // other close up logic goes here 202 202 return s.db.Close() 203 203 + } 204 204 + 205 205 + func (s *State) Favicon(w http.ResponseWriter, r *http.Request) { 206 206 + w.Header().Set("Content-Type", "image/svg+xml") 207 207 + w.Header().Set("Cache-Control", "public, max-age=31536000") // one year 208 208 + w.Header().Set("ETag", `"favicon-svg-v1"`) 209 209 + 210 210 + if match := r.Header.Get("If-None-Match"); match == `"favicon-svg-v1"` { 211 211 + w.WriteHeader(http.StatusNotModified) 212 212 + return 213 213 + } 214 214 + 215 215 + s.pages.Favicon(w) 203 216 } 204 217 205 218 func (s *State) RobotsTxt(w http.ResponseWriter, r *http.Request) {

-27

appview/validator/issue.go

··· 4 4 "fmt" 5 5 "strings" 6 6 7 7 - "tangled.org/core/appview/db" 8 7 "tangled.org/core/appview/models" 9 9 - "tangled.org/core/orm" 10 8 ) 11 11 - 12 12 - func (v *Validator) ValidateIssueComment(comment *models.IssueComment) error { 13 13 - // if comments have parents, only ingest ones that are 1 level deep 14 14 - if comment.ReplyTo != nil { 15 15 - parents, err := db.GetIssueComments(v.db, orm.FilterEq("at_uri", *comment.ReplyTo)) 16 16 - if err != nil { 17 17 - return fmt.Errorf("failed to fetch parent comment: %w", err) 18 18 - } 19 19 - if len(parents) != 1 { 20 20 - return fmt.Errorf("incorrect number of parent comments returned: %d", len(parents)) 21 21 - } 22 22 - 23 23 - // depth check 24 24 - parent := parents[0] 25 25 - if parent.ReplyTo != nil { 26 26 - return fmt.Errorf("incorrect depth, this comment is replying at depth >1") 27 27 - } 28 28 - } 29 29 - 30 30 - if sb := strings.TrimSpace(v.sanitizer.SanitizeDefault(comment.Body)); sb == "" { 31 31 - return fmt.Errorf("body is empty after HTML sanitization") 32 32 - } 33 33 - 34 34 - return nil 35 35 - } 36 9 37 10 func (v *Validator) ValidateIssue(issue *models.Issue) error { 38 11 if issue.Title == "" {

+1

cmd/cborgen/cborgen.go

··· 15 15 "api/tangled/cbor_gen.go", 16 16 "tangled", 17 17 tangled.ActorProfile{}, 18 18 + tangled.Comment{}, 18 19 tangled.FeedReaction{}, 19 20 tangled.FeedStar{}, 20 21 tangled.GitRefUpdate{},

+86 -89

docs/DOCS.md

··· 1 1 --- 2 2 - title: Tangled Documentation 2 2 + title: Tangled docs 3 3 author: The Tangled Contributors 4 4 date: 21 Sun, Dec 2025 5 5 - --- 6 6 - 7 7 - # Introduction 8 8 - 9 9 - Tangled is a decentralized code hosting and collaboration 10 10 - platform. Every component of Tangled is open-source and 11 11 - selfhostable. [tangled.org](https://tangled.org) also 12 12 - provides hosting and CI services that are free to use. 5 5 + abstract: | 6 6 + Tangled is a decentralized code hosting and collaboration 7 7 + platform. Every component of Tangled is open-source and 8 8 + self-hostable. [tangled.org](https://tangled.org) also 9 9 + provides hosting and CI services that are free to use. 13 10 14 14 - There are several models for decentralized code 15 15 - collaboration platforms, ranging from ActivityPub’s 16 16 - (Forgejo) federated model, to Radicle’s entirely P2P model. 17 17 - Our approach attempts to be the best of both worlds by 18 18 - adopting atproto—a protocol for building decentralized 19 19 - social applications with a central identity 11 11 + There are several models for decentralized code 12 12 + collaboration platforms, ranging from ActivityPub’s 13 13 + (Forgejo) federated model, to Radicle’s entirely P2P model. 14 14 + Our approach attempts to be the best of both worlds by 15 15 + adopting the AT Protocol—a protocol for building decentralized 16 16 + social applications with a central identity 20 17 21 21 - Our approach to this is the idea of “knots”. Knots are 22 22 - lightweight, headless servers that enable users to host Git 23 23 - repositories with ease. Knots are designed for either single 24 24 - or multi-tenant use which is perfect for self-hosting on a 25 25 - Raspberry Pi at home, or larger “community” servers. By 26 26 - default, Tangled provides managed knots where you can host 27 27 - your repositories for free. 18 18 + Our approach to this is the idea of “knots”. Knots are 19 19 + lightweight, headless servers that enable users to host Git 20 20 + repositories with ease. Knots are designed for either single 21 21 + or multi-tenant use which is perfect for self-hosting on a 22 22 + Raspberry Pi at home, or larger “community” servers. By 23 23 + default, Tangled provides managed knots where you can host 24 24 + your repositories for free. 28 25 29 29 - The "appview" at tangled.org acts as a consolidated “view” 30 30 - into the whole network, allowing users to access, clone and 31 31 - contribute to repositories hosted across different knots 32 32 - seamlessly. 26 26 + The appview at tangled.org acts as a consolidated "view" 27 27 + into the whole network, allowing users to access, clone and 28 28 + contribute to repositories hosted across different knots 29 29 + seamlessly. 30 30 + --- 33 31 34 34 - # Quick Start Guide 32 32 + # Quick start guide 35 33 36 36 - ## Login or Sign up 34 34 + ## Login or sign up 37 35 38 38 - You can [login](https://tangled.org) by using your AT 36 36 + You can [login](https://tangled.org) by using your AT Protocol 39 37 account. If you are unclear on what that means, simply head 40 38 to the [signup](https://tangled.org/signup) page and create 41 39 an account. By doing so, you will be choosing Tangled as 42 40 your account provider (you will be granted a handle of the 43 41 form `user.tngl.sh`). 44 42 45 45 - In the AT network, users are free to choose their account 43 43 + In the AT Protocol network, users are free to choose their account 46 44 provider (known as a "Personal Data Service", or PDS), and 47 45 login to applications that support AT accounts. 48 46 49 49 - You can think of it as "one account for all of the 50 50 - atmosphere"! 47 47 + You can think of it as "one account for all of the atmosphere"! 51 48 52 49 If you already have an AT account (you may have one if you 53 50 signed up to Bluesky, for example), you can login with the 54 51 same handle on Tangled (so just use `user.bsky.social` on 55 52 the login page). 56 53 57 57 - ## Add an SSH Key 54 54 + ## Add an SSH key 58 55 59 56 Once you are logged in, you can start creating repositories 60 57 and pushing code. Tangled supports pushing git repositories ··· 87 84 paste your public key, give it a descriptive name, and hit 88 85 save. 89 86 90 90 - ## Create a Repository 87 87 + ## Create a repository 91 88 92 89 Once your SSH key is added, create your first repository: 93 90 ··· 98 95 4. Choose a knotserver to host this repository on 99 96 5. Hit create 100 97 101 101 - "Knots" are selfhostable, lightweight git servers that can 98 98 + Knots are self-hostable, lightweight Git servers that can 102 99 host your repository. Unlike traditional code forges, your 103 100 code can live on any server. Read the [Knots](TODO) section 104 101 for more. ··· 125 122 are hosted by tangled.org. If you use a custom knot, refer 126 123 to the [Knots](TODO) section. 127 124 128 128 - ## Push Your First Repository 125 125 + ## Push your first repository 129 126 130 130 - Initialize a new git repository: 127 127 + Initialize a new Git repository: 131 128 132 129 ```bash 133 130 mkdir my-project ··· 165 162 cd /path/to/your/existing/repo 166 163 ``` 167 164 168 168 - You can inspect your existing git remote like so: 165 165 + You can inspect your existing Git remote like so: 169 166 170 167 ```bash 171 168 git remote -v ··· 197 194 origin git@tangled.org:user.tngl.sh/my-project (push) 198 195 ``` 199 196 200 200 - Push all your branches and tags to tangled: 197 197 + Push all your branches and tags to Tangled: 201 198 202 199 ```bash 203 200 git push -u origin --all ··· 232 229 ``` 233 230 234 231 You also need to re-add the original URL as a push 235 235 - destination (git replaces the push URL when you use `--add` 232 232 + destination (Git replaces the push URL when you use `--add` 236 233 the first time): 237 234 238 235 ```bash ··· 249 246 ``` 250 247 251 248 Notice that there's one fetch URL (the primary remote) and 252 252 - two push URLs. Now, whenever you push, git will 249 249 + two push URLs. Now, whenever you push, Git will 253 250 automatically push to both remotes: 254 251 255 252 ```bash ··· 301 298 ## Docker 302 299 303 300 Refer to 304 304 - [@tangled.org/knot-docker](https://tangled.sh/@tangled.sh/knot-docker). 301 301 + [@tangled.org/knot-docker](https://tangled.org/@tangled.org/knot-docker). 305 302 Note that this is community maintained. 306 303 307 304 ## Manual setup ··· 372 369 ``` 373 370 KNOT_REPO_SCAN_PATH=/home/git 374 371 KNOT_SERVER_HOSTNAME=knot.example.com 375 375 - APPVIEW_ENDPOINT=https://tangled.sh 372 372 + APPVIEW_ENDPOINT=https://tangled.org 376 373 KNOT_SERVER_OWNER=did:plc:foobar 377 374 KNOT_SERVER_INTERNAL_LISTEN_ADDR=127.0.0.1:5444 378 375 KNOT_SERVER_LISTEN_ADDR=127.0.0.1:5555 ··· 603 600 - `nixery`: This uses an instance of 604 601 [Nixery](https://nixery.dev) to run steps, which allows 605 602 you to add [dependencies](#dependencies) from 606 606 - [Nixpkgs](https://github.com/NixOS/nixpkgs). You can 603 603 + Nixpkgs (https://github.com/NixOS/nixpkgs). You can 607 604 search for packages on https://search.nixos.org, and 608 605 there's a pretty good chance the package(s) you're looking 609 606 for will be there. ··· 630 627 default, the depth is set to 1, meaning only the most 631 628 recent commit will be fetched, which is the commit that 632 629 triggered the workflow. 633 633 - - `submodules`: If you use [git 634 634 - submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules) 630 630 + - `submodules`: If you use Git submodules 631 631 + (https://git-scm.com/book/en/v2/Git-Tools-Submodules) 635 632 in your repository, setting this field to `true` will 636 633 recursively fetch all submodules. This is `false` by 637 634 default. ··· 657 654 Say you want to fetch Node.js and Go from `nixpkgs`, and a 658 655 package called `my_pkg` you've made from your own registry 659 656 at your repository at 660 660 - `https://tangled.sh/@example.com/my_pkg`. You can define 657 657 + `https://tangled.org/@example.com/my_pkg`. You can define 661 658 those dependencies like so: 662 659 663 660 ```yaml ··· 779 776 780 777 If you want another example of a workflow, you can look at 781 778 the one [Tangled uses to build the 782 782 - project](https://tangled.sh/@tangled.sh/core/blob/master/.tangled/workflows/build.yml). 779 779 + project](https://tangled.org/@tangled.org/core/blob/master/.tangled/workflows/build.yml). 783 780 784 781 ## Self-hosting guide 785 782 ··· 836 833 837 834 ## Architecture 838 835 839 839 - Spindle is a small CI runner service. Here's a high level overview of how it operates: 836 836 + Spindle is a small CI runner service. Here's a high-level overview of how it operates: 840 837 841 841 - * listens for [`sh.tangled.spindle.member`](/lexicons/spindle/member.json) and 838 838 + * Listens for [`sh.tangled.spindle.member`](/lexicons/spindle/member.json) and 842 839 [`sh.tangled.repo`](/lexicons/repo.json) records on the Jetstream. 843 843 - * when a new repo record comes through (typically when you add a spindle to a 840 840 + * When a new repo record comes through (typically when you add a spindle to a 844 841 repo from the settings), spindle then resolves the underlying knot and 845 842 subscribes to repo events (see: 846 843 [`sh.tangled.pipeline`](/lexicons/pipeline.json)). 847 847 - * the spindle engine then handles execution of the pipeline, with results and 848 848 - logs beamed on the spindle event stream over wss 844 844 + * The spindle engine then handles execution of the pipeline, with results and 845 845 + logs beamed on the spindle event stream over WebSocket 849 846 850 847 ### The engine 851 848 852 849 At present, the only supported backend is Docker (and Podman, if Docker 853 853 - compatibility is enabled, so that `/run/docker.sock` is created). Spindle 850 850 + compatibility is enabled, so that `/run/docker.sock` is created). spindle 854 851 executes each step in the pipeline in a fresh container, with state persisted 855 852 across steps within the `/tangled/workspace` directory. 856 853 ··· 858 855 [Nixery](https://nixery.dev), which is handy for caching layers for frequently 859 856 used packages. 860 857 861 861 - The pipeline manifest is [specified here](/docs/spindle/pipeline.md). 858 858 + The pipeline manifest is [specified here](https://docs.tangled.org/spindles.html#pipelines). 862 859 863 860 ## Secrets with openbao 864 861 865 865 - This document covers setting up Spindle to use OpenBao for secrets 862 862 + This document covers setting up spindle to use OpenBao for secrets 866 863 management via OpenBao Proxy instead of the default SQLite backend. 867 864 868 865 ### Overview 869 866 870 867 Spindle now uses OpenBao Proxy for secrets management. The proxy handles 871 871 - authentication automatically using AppRole credentials, while Spindle 868 868 + authentication automatically using AppRole credentials, while spindle 872 869 connects to the local proxy instead of directly to the OpenBao server. 873 870 874 871 This approach provides better security, automatic token renewal, and ··· 876 873 877 874 ### Installation 878 875 879 879 - Install OpenBao from nixpkgs: 876 876 + Install OpenBao from Nixpkgs: 880 877 881 878 ```bash 882 879 nix shell nixpkgs#openbao # for a local server ··· 1029 1026 } 1030 1027 } 1031 1028 1032 1032 - # Proxy listener for Spindle 1029 1029 + # Proxy listener for spindle 1033 1030 listener "tcp" { 1034 1031 address = "127.0.0.1:8201" 1035 1032 tls_disable = true ··· 1062 1059 1063 1060 #### Configure spindle 1064 1061 1065 1065 - Set these environment variables for Spindle: 1062 1062 + Set these environment variables for spindle: 1066 1063 1067 1064 ```bash 1068 1065 export SPINDLE_SERVER_SECRETS_PROVIDER=openbao ··· 1070 1067 export SPINDLE_SERVER_SECRETS_OPENBAO_MOUNT=spindle 1071 1068 ``` 1072 1069 1073 1073 - On startup, the spindle will now connect to the local proxy, 1070 1070 + On startup, spindle will now connect to the local proxy, 1074 1071 which handles all authentication automatically. 1075 1072 1076 1073 ### Production setup for proxy ··· 1099 1096 # List all secrets 1100 1097 bao kv list spindle/ 1101 1098 1102 1102 - # Add a test secret via Spindle API, then check it exists 1099 1099 + # Add a test secret via the spindle API, then check it exists 1103 1100 bao kv list spindle/repos/ 1104 1101 1105 1102 # Get a specific secret ··· 1112 1109 port 8200 or 8201) 1113 1110 - The proxy authenticates with OpenBao using AppRole 1114 1111 credentials 1115 1115 - - All Spindle requests go through the proxy, which injects 1112 1112 + - All spindle requests go through the proxy, which injects 1116 1113 authentication tokens 1117 1114 - Secrets are stored at 1118 1115 `spindle/repos/{sanitized_repo_path}/{secret_key}` ··· 1131 1128 and the policy has the necessary permissions. 1132 1129 1133 1130 **404 route errors**: The spindle KV mount probably doesn't 1134 1134 - exist - run the mount creation step again. 1131 1131 + exist—run the mount creation step again. 1135 1132 1136 1133 **Proxy authentication failures**: Check the proxy logs and 1137 1134 verify the role-id and secret-id files are readable and ··· 1159 1156 secret_id="$(cat /tmp/openbao/secret-id)" 1160 1157 ``` 1161 1158 1162 1162 - # Migrating knots & spindles 1159 1159 + # Migrating knots and spindles 1163 1160 1164 1161 Sometimes, non-backwards compatible changes are made to the 1165 1162 knot/spindle XRPC APIs. If you host a knot or a spindle, you ··· 1172 1169 1173 1170 ## Upgrading from v1.8.x 1174 1171 1175 1175 - After v1.8.2, the HTTP API for knot and spindles have been 1172 1172 + After v1.8.2, the HTTP API for knots and spindles has been 1176 1173 deprecated and replaced with XRPC. Repositories on outdated 1177 1174 knots will not be viewable from the appview. Upgrading is 1178 1175 straightforward however. 1179 1176 1180 1177 For knots: 1181 1178 1182 1182 - - Upgrade to latest tag (v1.9.0 or above) 1179 1179 + - Upgrade to the latest tag (v1.9.0 or above) 1183 1180 - Head to the [knot dashboard](https://tangled.org/settings/knots) and 1184 1181 hit the "retry" button to verify your knot 1185 1182 1186 1183 For spindles: 1187 1184 1188 1188 - - Upgrade to latest tag (v1.9.0 or above) 1185 1185 + - Upgrade to the latest tag (v1.9.0 or above) 1189 1186 - Head to the [spindle 1190 1187 dashboard](https://tangled.org/settings/spindles) and hit the 1191 1188 "retry" button to verify your spindle ··· 1227 1224 # Hacking on Tangled 1228 1225 1229 1226 We highly recommend [installing 1230 1230 - nix](https://nixos.org/download/) (the package manager) 1231 1231 - before working on the codebase. The nix flake provides a lot 1227 1227 + Nix](https://nixos.org/download/) (the package manager) 1228 1228 + before working on the codebase. The Nix flake provides a lot 1232 1229 of helpers to get started and most importantly, builds and 1233 1230 dev shells are entirely deterministic. 1234 1231 ··· 1238 1235 nix develop 1239 1236 ``` 1240 1237 1241 1241 - Non-nix users can look at the `devShell` attribute in the 1238 1238 + Non-Nix users can look at the `devShell` attribute in the 1242 1239 `flake.nix` file to determine necessary dependencies. 1243 1240 1244 1241 ## Running the appview 1245 1242 1246 1246 - The nix flake also exposes a few `app` attributes (run `nix 1243 1243 + The Nix flake also exposes a few `app` attributes (run `nix 1247 1244 flake show` to see a full list of what the flake provides), 1248 1245 one of the apps runs the appview with the `air` 1249 1246 live-reloader: ··· 1258 1255 nix run .#watch-tailwind 1259 1256 ``` 1260 1257 1261 1261 - To authenticate with the appview, you will need redis and 1262 1262 - OAUTH JWKs to be setup: 1258 1258 + To authenticate with the appview, you will need Redis and 1259 1259 + OAuth JWKs to be set up: 1263 1260 1264 1261 ``` 1265 1265 - # oauth jwks should already be setup by the nix devshell: 1262 1262 + # OAuth JWKs should already be set up by the Nix devshell: 1266 1263 echo $TANGLED_OAUTH_CLIENT_SECRET 1267 1264 z42ty4RT1ovnTopY8B8ekz9NuziF2CuMkZ7rbRFpAR9jBqMc 1268 1265 ··· 1280 1277 # the secret key from above 1281 1278 export TANGLED_OAUTH_CLIENT_SECRET="z42tuP..." 1282 1279 1283 1283 - # run redis in at a new shell to store oauth sessions 1280 1280 + # Run Redis in a new shell to store OAuth sessions 1284 1281 redis-server 1285 1282 ``` 1286 1283 1287 1284 ## Running knots and spindles 1288 1285 1289 1286 An end-to-end knot setup requires setting up a machine with 1290 1290 - `sshd`, `AuthorizedKeysCommand`, and git user, which is 1291 1291 - quite cumbersome. So the nix flake provides a 1287 1287 + `sshd`, `AuthorizedKeysCommand`, and a Git user, which is 1288 1288 + quite cumbersome. So the Nix flake provides a 1292 1289 `nixosConfiguration` to do so. 1293 1290 1294 1291 <details> 1295 1295 - <summary><strong>MacOS users will have to setup a Nix Builder first</strong></summary> 1292 1292 + <summary><strong>macOS users will have to set up a Nix Builder first</strong></summary> 1296 1293 1297 1294 In order to build Tangled's dev VM on macOS, you will 1298 1295 first need to set up a Linux Nix builder. The recommended ··· 1303 1300 you are using Apple Silicon). 1304 1301 1305 1302 > IMPORTANT: You must build `darwin.linux-builder` somewhere other than inside 1306 1306 - > the tangled repo so that it doesn't conflict with the other VM. For example, 1303 1303 + > the Tangled repo so that it doesn't conflict with the other VM. For example, 1307 1304 > you can do 1308 1305 > 1309 1306 > ```shell ··· 1316 1313 > avoid subtle problems. 1317 1314 1318 1315 Alternatively, you can use any other method to set up a 1319 1319 - Linux machine with `nix` installed that you can `sudo ssh` 1316 1316 + Linux machine with Nix installed that you can `sudo ssh` 1320 1317 into (in other words, root user on your Mac has to be able 1321 1318 to ssh into the Linux machine without entering a password) 1322 1319 and that has the same architecture as your Mac. See ··· 1347 1344 with `ssh` exposed on port 2222. 1348 1345 1349 1346 Once the services are running, head to 1350 1350 - http://localhost:3000/settings/knots and hit verify. It should 1347 1347 + http://localhost:3000/settings/knots and hit "Verify". It should 1351 1348 verify the ownership of the services instantly if everything 1352 1349 went smoothly. 1353 1350 ··· 1371 1368 1372 1369 The above VM should already be running a spindle on 1373 1370 `localhost:6555`. Head to http://localhost:3000/settings/spindles and 1374 1374 - hit verify. You can then configure each repository to use 1371 1371 + hit "Verify". You can then configure each repository to use 1375 1372 this spindle and run CI jobs. 1376 1373 1377 1374 Of interest when debugging spindles: 1378 1375 1379 1376 ``` 1380 1380 - # service logs from journald: 1377 1377 + # Service logs from journald: 1381 1378 journalctl -xeu spindle 1382 1379 1383 1380 # CI job logs from disk: 1384 1381 ls /var/log/spindle 1385 1382 1386 1386 - # debugging spindle db: 1383 1383 + # Debugging spindle database: 1387 1384 sqlite3 /var/lib/spindle/spindle.db 1388 1385 1389 1386 # litecli has a nicer REPL interface: ··· 1432 1429 1433 1430 ### General notes 1434 1431 1435 1435 - - PRs get merged "as-is" (fast-forward) -- like applying a patch-series 1436 1436 - using `git am`. At present, there is no squashing -- so please author 1432 1432 + - PRs get merged "as-is" (fast-forward)—like applying a patch-series 1433 1433 + using `git am`. At present, there is no squashing—so please author 1437 1434 your commits as they would appear on `master`, following the above 1438 1435 guidelines. 1439 1436 - If there is a lot of nesting, for example "appview: ··· 1454 1451 ## Code formatting 1455 1452 1456 1453 We use a variety of tools to format our code, and multiplex them with 1457 1457 - [`treefmt`](https://treefmt.com): all you need to do to format your changes 1454 1454 + [`treefmt`](https://treefmt.com). All you need to do to format your changes 1458 1455 is run `nix run .#fmt` (or just `treefmt` if you're in the devshell). 1459 1456 1460 1457 ## Proposals for bigger changes ··· 1482 1479 We'll use the issue thread to discuss and refine the idea before moving 1483 1480 forward. 1484 1481 1485 1485 - ## Developer certificate of origin (DCO) 1482 1482 + ## Developer Certificate of Origin (DCO) 1486 1483 1487 1484 We require all contributors to certify that they have the right to 1488 1485 submit the code they're contributing. To do this, we follow the

+3

docs/mode.html

··· 1 1 + <a class="px-4 py-2 mt-8 block text-center w-full rounded-sm shadow-sm border border-gray-200 dark:border-gray-700 no-underline hover:no-underline" href="$if(single-page)$/$else$/single-page.html$endif$"> 2 2 + $if(single-page)$View as multi-page$else$View as single-page$endif$ 3 3 + </a>

+7

docs/search.html

··· 1 1 + <form action="https://google.com/search" role="search" aria-label="Sitewide" class="w-full"> 2 2 + <input type="hidden" name="q" value="+[inurl:https://docs.tangled.org]"> 3 3 + <label> 4 4 + <span style="display:none;">Search</span> 5 5 + <input type="text" name="q" placeholder="Search docs ..." class="w-full font-normal"> 6 6 + </label> 7 7 + </form>

+75 -36

docs/template.html

··· 20 20 <meta name="description" content="$description-meta$" /> 21 21 $endif$ 22 22 23 23 - <title>$pagetitle$ - Tangled docs</title> 23 23 + <title>$pagetitle$</title> 24 24 25 25 <style> 26 26 $styles.css()$ ··· 37 37 <link rel="preload" href="/static/fonts/InterVariable.woff2" as="font" type="font/woff2" crossorigin /> 38 38 39 39 </head> 40 40 - <body class="bg-white dark:bg-gray-900 min-h-screen flex flex-col min-h-screen"> 40 40 + <body class="bg-white dark:bg-gray-900 flex flex-col min-h-svh"> 41 41 $for(include-before)$ 42 42 $include-before$ 43 43 $endfor$ 44 44 45 45 $if(toc)$ 46 46 - <!-- mobile topbar toc --> 47 47 - <details id="mobile-$idprefix$TOC" role="doc-toc" class="md:hidden bg-gray-50 dark:bg-gray-800 border-b border-gray-200 dark:border-gray-700 z-50 space-y-4 group px-6 py-4"> 48 48 - <summary class="cursor-pointer list-none text-sm font-semibold select-none flex gap-2 justify-between items-center dark:text-white"> 46 46 + <!-- mobile TOC trigger --> 47 47 + <div class="md:hidden px-6 py-4 border-b border-gray-200 dark:border-gray-700"> 48 48 + <button 49 49 + type="button" 50 50 + popovertarget="mobile-toc-popover" 51 51 + popovertargetaction="toggle" 52 52 + class="w-full flex gap-2 items-center text-sm font-semibold dark:text-white" 53 53 + > 54 54 + ${ menu.svg() } 49 55 $if(toc-title)$$toc-title$$else$Table of Contents$endif$ 50 50 - <span class="group-open:hidden inline">${ menu.svg() }</span> 51 51 - <span class="hidden group-open:inline">${ x.svg() }</span> 52 52 - </summary> 53 53 - ${ table-of-contents:toc.html() } 54 54 - </details> 56 56 + </button> 57 57 + </div> 58 58 + 59 59 + <div 60 60 + id="mobile-toc-popover" 61 61 + popover 62 62 + class="mobile-toc-popover 63 63 + bg-gray-50 dark:bg-gray-800 border-r border-gray-200 dark:border-gray-700 64 64 + h-full overflow-y-auto shadow-sm 65 65 + px-6 py-4 fixed inset-x-0 top-0 w-fit max-w-4/5 m-0" 66 66 + > 67 67 + <div class="flex flex-col min-h-full"> 68 68 + <div class="flex-1 space-y-4"> 69 69 + <button 70 70 + type="button" 71 71 + popovertarget="mobile-toc-popover" 72 72 + popovertargetaction="toggle" 73 73 + class="w-full flex gap-2 items-center text-sm font-semibold dark:text-white mb-4"> 74 74 + ${ x.svg() } 75 75 + $if(toc-title)$$toc-title$$else$Table of Contents$endif$ 76 76 + </button> 77 77 + ${ search.html() } 78 78 + ${ table-of-contents:toc.html() } 79 79 + </div> 80 80 + ${ single-page:mode.html() } 81 81 + </div> 82 82 + </div> 83 83 + 55 84 <!-- desktop sidebar toc --> 56 56 - <nav id="$idprefix$TOC" role="doc-toc" class="hidden md:block fixed left-0 top-0 w-80 h-screen bg-gray-50 dark:bg-gray-800 border-r border-gray-200 dark:border-gray-700 overflow-y-auto p-4 z-50"> 57 57 - $if(toc-title)$ 58 58 - <h2 id="$idprefix$toc-title" class="text-lg font-semibold mb-4 text-gray-900">$toc-title$</h2> 59 59 - $endif$ 60 60 - ${ table-of-contents:toc.html() } 85 85 + <nav 86 86 + id="$idprefix$TOC" 87 87 + role="doc-toc" 88 88 + class="hidden md:flex md:flex-col gap-4 fixed left-0 top-0 w-80 h-screen 89 89 + bg-gray-50 dark:bg-gray-800 border-r border-gray-200 dark:border-gray-700 90 90 + p-4 z-50 overflow-y-auto"> 91 91 + ${ search.html() } 92 92 + <div class="flex-1"> 93 93 + $if(toc-title)$ 94 94 + <h2 id="$idprefix$toc-title" class="text-lg font-semibold mb-4 text-gray-900">$toc-title$</h2> 95 95 + $endif$ 96 96 + ${ table-of-contents:toc.html() } 97 97 + </div> 98 98 + ${ single-page:mode.html() } 61 99 </nav> 62 100 $endif$ 63 101 64 102 <div class="$if(toc)$md:ml-80$endif$ flex-1 flex flex-col"> 65 103 <main class="max-w-4xl w-full mx-auto p-6 flex-1"> 66 104 $if(top)$ 67 67 - $-- only print title block if this is NOT the top page 105 105 + $-- only print title block if this is NOT the top page 68 106 $else$ 69 107 $if(title)$ 70 70 - <header id="title-block-header" class="mb-8 pb-8 border-b border-gray-200 dark:border-gray-700"> 71 71 - <h1 class="text-4xl font-bold mb-2 text-black dark:text-white">$title$</h1> 72 72 - $if(subtitle)$ 73 73 - <p class="text-xl text-gray-500 dark:text-gray-400 mb-2">$subtitle$</p> 74 74 - $endif$ 75 75 - $for(author)$ 76 76 - <p class="text-sm text-gray-500 dark:text-gray-400">$author$</p> 77 77 - $endfor$ 78 78 - $if(date)$ 79 79 - <p class="text-sm text-gray-500 dark:text-gray-400">Updated on $date$</p> 80 80 - $endif$ 81 81 - $if(abstract)$ 82 82 - <div class="mt-6 p-4 bg-gray-50 rounded-lg"> 83 83 - <div class="text-sm font-semibold text-gray-700 uppercase mb-2">$abstract-title$</div> 84 84 - <div class="text-gray-700">$abstract$</div> 85 85 - </div> 86 86 - $endif$ 87 87 - $endif$ 88 88 - </header> 108 108 + <header id="title-block-header" class="mb-8 pb-8 border-b border-gray-200 dark:border-gray-700"> 109 109 + <h1 class="text-4xl font-bold mb-2 text-black dark:text-white">$title$</h1> 110 110 + $if(subtitle)$ 111 111 + <p class="text-xl text-gray-500 dark:text-gray-400 mb-2">$subtitle$</p> 112 112 + $endif$ 113 113 + $for(author)$ 114 114 + <p class="text-sm text-gray-500 dark:text-gray-400">$author$</p> 115 115 + $endfor$ 116 116 + $if(date)$ 117 117 + <p class="text-sm text-gray-500 dark:text-gray-400">Updated on $date$</p> 118 118 + $endif$ 119 119 + $endif$ 120 120 + </header> 121 121 + $endif$ 122 122 + 123 123 + $if(abstract)$ 124 124 + <article class="prose dark:prose-invert max-w-none"> 125 125 + $abstract$ 126 126 + </article> 89 127 $endif$ 128 128 + 90 129 <article class="prose dark:prose-invert max-w-none"> 91 130 $body$ 92 131 </article> 93 132 </main> 94 94 - <nav id="sitenav" class="border-t border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-800 "> 133 133 + <nav id="sitenav" class="border-t border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-800"> 95 134 <div class="max-w-4xl mx-auto px-8 py-4"> 96 135 <div class="flex justify-between gap-4"> 97 136 <span class="flex-1">

+1 -1

flake.nix

··· 76 76 }; 77 77 buildGoApplication = 78 78 (self.callPackage "${gomod2nix}/builder" { 79 79 - gomod2nix = gomod2nix.legacyPackages.${pkgs.system}.gomod2nix; 79 79 + gomod2nix = gomod2nix.legacyPackages.${pkgs.stdenv.hostPlatform.system}.gomod2nix; 80 80 }).buildGoApplication; 81 81 modules = ./nix/gomod2nix.toml; 82 82 sqlite-lib = self.callPackage ./nix/pkgs/sqlite-lib.nix {

+1

input.css

··· 255 255 @apply py-1 text-gray-900 dark:text-gray-100; 256 256 } 257 257 } 258 258 + 258 259 } 259 260 260 261 /* Background */

+51

lexicons/comment/comment.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.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": [ 13 13 + "subject", 14 14 + "body", 15 15 + "createdAt" 16 16 + ], 17 17 + "properties": { 18 18 + "subject": { 19 19 + "type": "string", 20 20 + "format": "at-uri" 21 21 + }, 22 22 + "body": { 23 23 + "type": "string" 24 24 + }, 25 25 + "createdAt": { 26 26 + "type": "string", 27 27 + "format": "datetime" 28 28 + }, 29 29 + "replyTo": { 30 30 + "type": "string", 31 31 + "format": "at-uri" 32 32 + }, 33 33 + "mentions": { 34 34 + "type": "array", 35 35 + "items": { 36 36 + "type": "string", 37 37 + "format": "did" 38 38 + } 39 39 + }, 40 40 + "references": { 41 41 + "type": "array", 42 42 + "items": { 43 43 + "type": "string", 44 44 + "format": "at-uri" 45 45 + } 46 46 + } 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + }

+10 -2

lexicons/pulls/pull.json

··· 12 12 "required": [ 13 13 "target", 14 14 "title", 15 15 - "patch", 15 15 + "patchBlob", 16 16 "createdAt" 17 17 ], 18 18 "properties": { ··· 27 27 "type": "string" 28 28 }, 29 29 "patch": { 30 30 - "type": "string" 30 30 + "type": "string", 31 31 + "description": "(deprecated) use patchBlob instead" 32 32 + }, 33 33 + "patchBlob": { 34 34 + "type": "blob", 35 35 + "accept": [ 36 36 + "text/x-patch" 37 37 + ], 38 38 + "description": "patch content" 31 39 }, 32 40 "source": { 33 41 "type": "ref",

-1

nix/pkgs/appview-static-files.nix

··· 26 26 cp -f ${inter-fonts-src}/InterVariable*.ttf fonts/ 27 27 cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono*.woff2 fonts/ 28 28 cp -f ${actor-typeahead-src}/actor-typeahead.js . 29 29 - cp -f ${src}/appview/pages/assets/* . 30 29 # tailwindcss -c $src/tailwind.config.js -i $src/input.css -o tw.css won't work 31 30 # for whatever reason (produces broken css), so we are doing this instead 32 31 cd ${src} && ${tailwindcss}/bin/tailwindcss -i input.css -o $out/tw.css

+13 -1

nix/pkgs/docs.nix

··· 18 18 # icons 19 19 cp -rf ${lucide-src}/*.svg working/ 20 20 21 21 - # content 21 21 + # content - chunked 22 22 ${pandoc}/bin/pandoc ${src}/docs/DOCS.md \ 23 23 -o $out/ \ 24 24 -t chunkedhtml \ 25 25 --variable toc \ 26 26 + --variable-json single-page=false \ 26 27 --toc-depth=2 \ 27 28 --css=stylesheet.css \ 28 29 --chunk-template="%i.html" \ 30 30 + --highlight-style=working/highlight.theme \ 31 31 + --template=working/template.html 32 32 + 33 33 + # content - single page 34 34 + ${pandoc}/bin/pandoc ${src}/docs/DOCS.md \ 35 35 + -o $out/single-page.html \ 36 36 + --toc \ 37 37 + --variable toc \ 38 38 + --variable single-page \ 39 39 + --toc-depth=2 \ 40 40 + --css=stylesheet.css \ 29 41 --highlight-style=working/highlight.theme \ 30 42 --template=working/template.html 31 43

+1 -1

nix/vm.nix

··· 8 8 var = builtins.getEnv name; 9 9 in 10 10 if var == "" 11 11 - then throw "\$${name} must be defined, see docs/hacking.md for more details" 11 11 + then throw "\$${name} must be defined, see https://docs.tangled.org/hacking-on-tangled.html#hacking-on-tangled for more details" 12 12 else var; 13 13 envVarOr = name: default: let 14 14 var = builtins.getEnv name;

+3 -3

readme.md

··· 10 10 11 11 ## docs 12 12 13 13 - * [knot hosting guide](/docs/knot-hosting.md) 14 14 - * [contributing guide](/docs/contributing.md) **please read before opening a PR!** 15 15 - * [hacking on tangled](/docs/hacking.md) 13 13 + - [knot hosting guide](https://docs.tangled.org/knot-self-hosting-guide.html#knot-self-hosting-guide) 14 14 + - [contributing guide](https://docs.tangled.org/contribution-guide.html#contribution-guide) **please read before opening a PR!** 15 15 + - [hacking on tangled](https://docs.tangled.org/hacking-on-tangled.html#hacking-on-tangled) 16 16 17 17 ## security 18 18

+1 -1

spindle/motd

··· 20 20 ** 21 21 ******** 22 22 23 23 - This is a spindle server. More info at https://tangled.sh/@tangled.sh/core/tree/master/docs/spindle 23 23 + This is a spindle server. More info at https://docs.tangled.org/spindles.html#spindles 24 24 25 25 Most API routes are under /xrpc/

+31 -13

spindle/server.go

··· 8 8 "log/slog" 9 9 "maps" 10 10 "net/http" 11 11 + "sync" 11 12 12 13 "github.com/go-chi/chi/v5" 13 14 "tangled.org/core/api/tangled" ··· 30 31 ) 31 32 32 33 //go:embed motd 33 33 - var motd []byte 34 34 + var defaultMotd []byte 34 35 35 36 const ( 36 37 rbacDomain = "thisserver" 37 38 ) 38 39 39 40 type Spindle struct { 40 40 - jc *jetstream.JetstreamClient 41 41 - db *db.DB 42 42 - e *rbac.Enforcer 43 43 - l *slog.Logger 44 44 - n *notifier.Notifier 45 45 - engs map[string]models.Engine 46 46 - jq *queue.Queue 47 47 - cfg *config.Config 48 48 - ks *eventconsumer.Consumer 49 49 - res *idresolver.Resolver 50 50 - vault secrets.Manager 41 41 + jc *jetstream.JetstreamClient 42 42 + db *db.DB 43 43 + e *rbac.Enforcer 44 44 + l *slog.Logger 45 45 + n *notifier.Notifier 46 46 + engs map[string]models.Engine 47 47 + jq *queue.Queue 48 48 + cfg *config.Config 49 49 + ks *eventconsumer.Consumer 50 50 + res *idresolver.Resolver 51 51 + vault secrets.Manager 52 52 + motd []byte 53 53 + motdMu sync.RWMutex 51 54 } 52 55 53 56 // New creates a new Spindle server with the provided configuration and engines. ··· 128 131 cfg: cfg, 129 132 res: resolver, 130 133 vault: vault, 134 134 + motd: defaultMotd, 131 135 } 132 136 133 137 err = e.AddSpindle(rbacDomain) ··· 201 205 return s.e 202 206 } 203 207 208 208 + // SetMotdContent sets custom MOTD content, replacing the embedded default. 209 209 + func (s *Spindle) SetMotdContent(content []byte) { 210 210 + s.motdMu.Lock() 211 211 + defer s.motdMu.Unlock() 212 212 + s.motd = content 213 213 + } 214 214 + 215 215 + // GetMotdContent returns the current MOTD content. 216 216 + func (s *Spindle) GetMotdContent() []byte { 217 217 + s.motdMu.RLock() 218 218 + defer s.motdMu.RUnlock() 219 219 + return s.motd 220 220 + } 221 221 + 204 222 // Start starts the Spindle server (blocking). 205 223 func (s *Spindle) Start(ctx context.Context) error { 206 224 // starts a job queue runner in the background ··· 246 264 mux := chi.NewRouter() 247 265 248 266 mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { 249 249 - w.Write(motd) 267 267 + w.Write(s.GetMotdContent()) 250 268 }) 251 269 mux.HandleFunc("/events", s.Events) 252 270 mux.HandleFunc("/logs/{knot}/{rkey}/{name}", s.Logs)

+3

types/diff.go

··· 74 74 75 75 // used by html elements as a unique ID for hrefs 76 76 func (d *Diff) Id() string { 77 77 + if d.IsDelete { 78 78 + return d.Name.Old 79 79 + } 77 80 return d.Name.New 78 81 } 79 82

+112

types/diff_test.go

··· 1 1 + package types 2 2 + 3 3 + import "testing" 4 4 + 5 5 + func TestDiffId(t *testing.T) { 6 6 + tests := []struct { 7 7 + name string 8 8 + diff Diff 9 9 + expected string 10 10 + }{ 11 11 + { 12 12 + name: "regular file uses new name", 13 13 + diff: Diff{ 14 14 + Name: struct { 15 15 + Old string `json:"old"` 16 16 + New string `json:"new"` 17 17 + }{Old: "", New: "src/main.go"}, 18 18 + }, 19 19 + expected: "src/main.go", 20 20 + }, 21 21 + { 22 22 + name: "new file uses new name", 23 23 + diff: Diff{ 24 24 + Name: struct { 25 25 + Old string `json:"old"` 26 26 + New string `json:"new"` 27 27 + }{Old: "", New: "src/new.go"}, 28 28 + IsNew: true, 29 29 + }, 30 30 + expected: "src/new.go", 31 31 + }, 32 32 + { 33 33 + name: "deleted file uses old name", 34 34 + diff: Diff{ 35 35 + Name: struct { 36 36 + Old string `json:"old"` 37 37 + New string `json:"new"` 38 38 + }{Old: "src/deleted.go", New: ""}, 39 39 + IsDelete: true, 40 40 + }, 41 41 + expected: "src/deleted.go", 42 42 + }, 43 43 + { 44 44 + name: "renamed file uses new name", 45 45 + diff: Diff{ 46 46 + Name: struct { 47 47 + Old string `json:"old"` 48 48 + New string `json:"new"` 49 49 + }{Old: "src/old.go", New: "src/renamed.go"}, 50 50 + IsRename: true, 51 51 + }, 52 52 + expected: "src/renamed.go", 53 53 + }, 54 54 + } 55 55 + 56 56 + for _, tt := range tests { 57 57 + t.Run(tt.name, func(t *testing.T) { 58 58 + if got := tt.diff.Id(); got != tt.expected { 59 59 + t.Errorf("Diff.Id() = %q, want %q", got, tt.expected) 60 60 + } 61 61 + }) 62 62 + } 63 63 + } 64 64 + 65 65 + func TestChangedFilesMatchesDiffId(t *testing.T) { 66 66 + // ChangedFiles() must return values matching each Diff's Id() 67 67 + // so that sidebar links point to the correct anchors. 68 68 + // Tests existing, deleted, new, and renamed files. 69 69 + nd := NiceDiff{ 70 70 + Diff: []Diff{ 71 71 + { 72 72 + Name: struct { 73 73 + Old string `json:"old"` 74 74 + New string `json:"new"` 75 75 + }{Old: "", New: "src/modified.go"}, 76 76 + }, 77 77 + { 78 78 + Name: struct { 79 79 + Old string `json:"old"` 80 80 + New string `json:"new"` 81 81 + }{Old: "src/deleted.go", New: ""}, 82 82 + IsDelete: true, 83 83 + }, 84 84 + { 85 85 + Name: struct { 86 86 + Old string `json:"old"` 87 87 + New string `json:"new"` 88 88 + }{Old: "", New: "src/new.go"}, 89 89 + IsNew: true, 90 90 + }, 91 91 + { 92 92 + Name: struct { 93 93 + Old string `json:"old"` 94 94 + New string `json:"new"` 95 95 + }{Old: "src/old.go", New: "src/renamed.go"}, 96 96 + IsRename: true, 97 97 + }, 98 98 + }, 99 99 + } 100 100 + 101 101 + changedFiles := nd.ChangedFiles() 102 102 + 103 103 + if len(changedFiles) != len(nd.Diff) { 104 104 + t.Fatalf("ChangedFiles() returned %d items, want %d", len(changedFiles), len(nd.Diff)) 105 105 + } 106 106 + 107 107 + for i, diff := range nd.Diff { 108 108 + if changedFiles[i] != diff.Id() { 109 109 + t.Errorf("ChangedFiles()[%d] = %q, but Diff.Id() = %q", i, changedFiles[i], diff.Id()) 110 110 + } 111 111 + } 112 112 + }