patch of appview: parse reference links from markdown body · round #3 · pull #760 · tangled.org/core

+172

appview/db/reference.go

···

       1
       1
       +
       package db

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"database/sql"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"strings"

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       10
       +
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       // FindReferences resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     

       14
       14
       +
       // It will ignore missing refLinks.

     

       15
       15
       +
       func FindReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       16
       16
       +
       	var (

     

       17
       17
       +
       		issueRefs []models.ReferenceLink

     

       18
       18
       +
       		pullRefs  []models.ReferenceLink

     

       19
       19
       +
       	)

     

       20
       20
       +
       	for _, ref := range refLinks {

     

       21
       21
       +
       		switch ref.Kind {

     

       22
       22
       +
       		case models.RefKindIssue:

     

       23
       23
       +
       			issueRefs = append(issueRefs, ref)

     

       24
       24
       +
       		case models.RefKindPull:

     

       25
       25
       +
       			pullRefs = append(pullRefs, ref)

     

       26
       26
       +
       		}

     

       27
       27
       +
       	}

     

       28
       28
       +
       	issueUris, err := findIssueReferences(e, issueRefs)

     

       29
       29
       +
       	if err != nil {

     

       30
       30
       +
       		return nil, err

     

       31
       31
       +
       	}

     

       32
       32
       +
       	pullUris, err := findPullReferences(e, pullRefs)

     

       33
       33
       +
       	if err != nil {

     

       34
       34
       +
       		return nil, err

     

       35
       35
       +
       	}

     

       36
       36
       +
       

     

       37
       37
       +
       	return append(issueUris, pullUris...), nil

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func findIssueReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       41
       41
       +
       	if len(refLinks) == 0 {

     

       42
       42
       +
       		return nil, nil

     

       43
       43
       +
       	}

     

       44
       44
       +
       	vals := make([]string, len(refLinks))

     

       45
       45
       +
       	args := make([]any, 0, len(refLinks)*4)

     

       46
       46
       +
       	for i, ref := range refLinks {

     

       47
       47
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       48
       48
       +
       		args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId)

     

       49
       49
       +
       	}

     

       50
       50
       +
       	query := fmt.Sprintf(

     

       51
       51
       +
       		`with input(owner_did, name, issue_id, comment_id) as (

     

       52
       52
       +
       			values %s

     

       53
       53
       +
       		)

     

       54
       54
       +
       		select

     

       55
       55
       +
       			i.did, i.rkey,

     

       56
       56
       +
       			c.did, c.rkey

     

       57
       57
       +
       		from input inp

     

       58
       58
       +
       		join repos r

     

       59
       59
       +
       			on r.did = inp.owner_did

     

       60
       60
       +
       				and r.name = inp.name

     

       61
       61
       +
       		join issues i

     

       62
       62
       +
       			on i.repo_at = r.at_uri

     

       63
       63
       +
       				and i.issue_id = inp.issue_id

     

       64
       64
       +
       		left join issue_comments c

     

       65
       65
       +
       			on inp.comment_id is not null

     

       66
       66
       +
       				and c.issue_at = i.at_uri

     

       67
       67
       +
       				and c.id = inp.comment_id

     

       68
       68
       +
       		`,

     

       69
       69
       +
       		strings.Join(vals, ","),

     

       70
       70
       +
       	)

     

       71
       71
       +
       	rows, err := e.Query(query, args...)

     

       72
       72
       +
       	if err != nil {

     

       73
       73
       +
       		return nil, err

     

       74
       74
       +
       	}

     

       75
       75
       +
       	defer rows.Close()

     

       76
       76
       +
       

     

       77
       77
       +
       	var uris []syntax.ATURI

     

       78
       78
       +
       

     

       79
       79
       +
       	for rows.Next() {

     

       80
       80
       +
       		// Scan rows

     

       81
       81
       +
       		var issueOwner, issueRkey string

     

       82
       82
       +
       		var commentOwner, commentRkey sql.NullString

     

       83
       83
       +
       		var uri syntax.ATURI

     

       84
       84
       +
       		if err := rows.Scan(&issueOwner, &issueRkey, &commentOwner, &commentRkey); err != nil {

     

       85
       85
       +
       			return nil, err

     

       86
       86
       +
       		}

     

       87
       87
       +
       		if commentOwner.Valid && commentRkey.Valid {

     

       88
       88
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       89
       89
       +
       				"at://%s/%s/%s",

     

       90
       90
       +
       				commentOwner.String,

     

       91
       91
       +
       				tangled.RepoIssueCommentNSID,

     

       92
       92
       +
       				commentRkey.String,

     

       93
       93
       +
       			))

     

       94
       94
       +
       		} else {

     

       95
       95
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       96
       96
       +
       				"at://%s/%s/%s",

     

       97
       97
       +
       				issueOwner,

     

       98
       98
       +
       				tangled.RepoIssueNSID,

     

       99
       99
       +
       				issueRkey,

     

       100
       100
       +
       			))

     

       101
       101
       +
       		}

     

       102
       102
       +
       		uris = append(uris, uri)

     

       103
       103
       +
       	}

     

       104
       104
       +
       	return uris, nil

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       func findPullReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       108
       108
       +
       	if len(refLinks) == 0 {

     

       109
       109
       +
       		return nil, nil

     

       110
       110
       +
       	}

     

       111
       111
       +
       	vals := make([]string, len(refLinks))

     

       112
       112
       +
       	args := make([]any, 0, len(refLinks)*4)

     

       113
       113
       +
       	for i, ref := range refLinks {

     

       114
       114
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       115
       115
       +
       		args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId)

     

       116
       116
       +
       	}

     

       117
       117
       +
       	query := fmt.Sprintf(

     

       118
       118
       +
       		`with input(owner_did, name, pull_id, comment_id) as (

     

       119
       119
       +
       			values %s

     

       120
       120
       +
       		)

     

       121
       121
       +
       		select

     

       122
       122
       +
       			p.owner_did, p.rkey,

     

       123
       123
       +
       			c.owner_did, c.rkey

     

       124
       124
       +
       		from input inp

     

       125
       125
       +
       		join repos r

     

       126
       126
       +
       			on r.did = inp.owner_did

     

       127
       127
       +
       				and r.name = inp.name

     

       128
       128
       +
       		join pulls p

     

       129
       129
       +
       			on p.repo_at = r.at_uri

     

       130
       130
       +
       				and p.pull_id = inp.pull_id

     

       131
       131
       +
       		left join pull_comments c

     

       132
       132
       +
       			on inp.comment_id is not null

     

       133
       133
       +
       				and c.repo_at = r.at_uri and c.pull_id = p.pull_id

     

       134
       134
       +
       				and c.id = inp.comment_id

     

       135
       135
       +
       		`,

     

       136
       136
       +
       		strings.Join(vals, ","),

     

       137
       137
       +
       	)

     

       138
       138
       +
       	rows, err := e.Query(query, args...)

     

       139
       139
       +
       	if err != nil {

     

       140
       140
       +
       		return nil, err

     

       141
       141
       +
       	}

     

       142
       142
       +
       	defer rows.Close()

     

       143
       143
       +
       

     

       144
       144
       +
       	var uris []syntax.ATURI

     

       145
       145
       +
       

     

       146
       146
       +
       	for rows.Next() {

     

       147
       147
       +
       		// Scan rows

     

       148
       148
       +
       		var pullOwner, pullRkey string

     

       149
       149
       +
       		var commentOwner, commentRkey sql.NullString

     

       150
       150
       +
       		var uri syntax.ATURI

     

       151
       151
       +
       		if err := rows.Scan(&pullOwner, &pullRkey, &commentOwner, &commentRkey); err != nil {

     

       152
       152
       +
       			return nil, err

     

       153
       153
       +
       		}

     

       154
       154
       +
       		if commentOwner.Valid && commentRkey.Valid {

     

       155
       155
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       156
       156
       +
       				"at://%s/%s/%s",

     

       157
       157
       +
       				commentOwner.String,

     

       158
       158
       +
       				tangled.RepoPullCommentNSID,

     

       159
       159
       +
       				commentRkey.String,

     

       160
       160
       +
       			))

     

       161
       161
       +
       		} else {

     

       162
       162
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       163
       163
       +
       				"at://%s/%s/%s",

     

       164
       164
       +
       				pullOwner,

     

       165
       165
       +
       				tangled.RepoPullNSID,

     

       166
       166
       +
       				pullRkey,

     

       167
       167
       +
       			))

     

       168
       168
       +
       		}

     

       169
       169
       +
       		uris = append(uris, uri)

     

       170
       170
       +
       	}

     

       171
       171
       +
       	return uris, nil

     

       172
       172
       +
       }

+10 -20

appview/issues/issues.go

···

       24
       24
        
       	"tangled.org/core/appview/notify"

     

       25
       25
        
       	"tangled.org/core/appview/oauth"

     

       26
       26
        
       	"tangled.org/core/appview/pages"

     

       27
       27
       -
       	"tangled.org/core/appview/pages/markup"

     

       28
       27
        
       	"tangled.org/core/appview/pagination"

     

       28
       28
       +
       	"tangled.org/core/appview/refresolver"

     

       29
       29
        
       	"tangled.org/core/appview/reporesolver"

     

       30
       30
        
       	"tangled.org/core/appview/validator"

     

       31
       31
        
       	"tangled.org/core/idresolver"

     
···

       37
       37
        
       	repoResolver *reporesolver.RepoResolver

     

       38
       38
        
       	pages        *pages.Pages

     

       39
       39
        
       	idResolver   *idresolver.Resolver

     

       40
       40
       +
       	refResolver  *refresolver.Resolver

     

       40
       41
        
       	db           *db.DB

     

       41
       42
        
       	config       *config.Config

     

       42
       43
        
       	notifier     notify.Notifier

     
···

       50
       51
        
       	repoResolver *reporesolver.RepoResolver,

     

       51
       52
        
       	pages *pages.Pages,

     

       52
       53
        
       	idResolver *idresolver.Resolver,

     

       54
       54
       +
       	refResolver *refresolver.Resolver,

     

       53
       55
        
       	db *db.DB,

     

       54
       56
        
       	config *config.Config,

     

       55
       57
        
       	notifier notify.Notifier,

     
···

       62
       64
        
       		repoResolver: repoResolver,

     

       63
       65
        
       		pages:        pages,

     

       64
       66
        
       		idResolver:   idResolver,

     

       67
       67
       +
       		refResolver:  refResolver,

     

       65
       68
        
       		db:           db,

     

       66
       69
        
       		config:       config,

     

       67
       70
        
       		notifier:     notifier,

     
···

       399
       402
        
       		replyTo = &replyToUri

     

       400
       403
        
       	}

     

       401
       404
        
       

     

       405
       405
       +
       	mentions, _ := rp.refResolver.Resolve(r.Context(), body)

     

       406
       406
       +
       

     

       402
       407
        
       	comment := models.IssueComment{

     

       403
       408
        
       		Did:     user.Did,

     

       404
       409
        
       		Rkey:    tid.TID(),

     
···

       455
       460
        
       	// notify about the new comment

     

       456
       461
        
       	comment.Id = commentId

     

       457
       462
        
       

     

       458
       458
       -
       	rawMentions := markup.FindUserMentions(comment.Body)

     

       459
       459
       -
       	idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions)

     

       460
       460
       -
       	l.Debug("parsed mentions", "raw", rawMentions, "idents", idents)

     

       461
       461
       -
       	var mentions []syntax.DID

     

       462
       462
       -
       	for _, ident := range idents {

     

       463
       463
       -
       		if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       464
       464
       -
       			mentions = append(mentions, ident.DID)

     

       465
       465
       -
       		}

     

       466
       466
       -
       	}

     

       467
       463
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       468
       464
        
       

     

       469
       465
        
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId))

     
···

       884
       880
        
       			RepoInfo:     f.RepoInfo(user),

     

       885
       881
        
       		})

     

       886
       882
        
       	case http.MethodPost:

     

       883
       883
       +
       		body := r.FormValue("body")

     

       884
       884
       +
       		mentions, _ := rp.refResolver.Resolve(r.Context(), body)

     

       885
       885
       +
       

     

       887
       886
        
       		issue := &models.Issue{

     

       888
       887
        
       			RepoAt:  f.RepoAt(),

     

       889
       888
        
       			Rkey:    tid.TID(),

     

       890
       889
        
       			Title:   r.FormValue("title"),

     

       891
       891
       -
       			Body:    r.FormValue("body"),

     

       890
       890
       +
       			Body:    body,

     

       892
       891
        
       			Open:    true,

     

       893
       892
        
       			Did:     user.Did,

     

       894
       893
        
       			Created: time.Now(),

     
···

       960
       959
        
       		// everything is successful, do not rollback the atproto record

     

       961
       960
        
       		atUri = ""

     

       962
       961
        
       

     

       963
       963
       -
       		rawMentions := markup.FindUserMentions(issue.Body)

     

       964
       964
       -
       		idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions)

     

       965
       965
       -
       		l.Debug("parsed mentions", "raw", rawMentions, "idents", idents)

     

       966
       966
       -
       		var mentions []syntax.DID

     

       967
       967
       -
       		for _, ident := range idents {

     

       968
       968
       -
       			if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       969
       969
       -
       				mentions = append(mentions, ident.DID)

     

       970
       970
       -
       			}

     

       971
       971
       -
       		}

     

       972
       962
        
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       973
       963
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       974
       964
        
       		return

+18

appview/models/reference.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       type RefKind int

     

       4
       4
       +
       

     

       5
       5
       +
       const (

     

       6
       6
       +
       	RefKindIssue RefKind = iota

     

       7
       7
       +
       	RefKindPull

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // /@alice.com/cool-proj/issues/123

     

       11
       11
       +
       // /@alice.com/cool-proj/issues/123#comment-321

     

       12
       12
       +
       type ReferenceLink struct {

     

       13
       13
       +
       	Handle    string

     

       14
       14
       +
       	Repo      string

     

       15
       15
       +
       	Kind      RefKind

     

       16
       16
       +
       	SubjectId int

     

       17
       17
       +
       	CommentId *int

     

       18
       18
       +
       }

+3 -3

appview/pages/markup/extension/atlink.go

···

       16
       16
        
       

     

       17
       17
        
       // An AtNode struct represents an AtNode

     

       18
       18
        
       type AtNode struct {

     

       19
       19
       -
       	handle string

     

       19
       19
       +
       	Handle string

     

       20
       20
        
       	ast.BaseInline

     

       21
       21
        
       }

     

       22
       22
        
       

     
···

       59
       59
        
       	block.Advance(m[1])

     

       60
       60
        
       	node := &AtNode{}

     

       61
       61
        
       	node.AppendChild(node, ast.NewTextSegment(atSegment))

     

       62
       62
       -
       	node.handle = string(atSegment.Value(block.Source())[1:])

     

       62
       62
       +
       	node.Handle = string(atSegment.Value(block.Source())[1:])

     

       63
       63
        
       	return node

     

       64
       64
        
       }

     

       65
       65
        
       

     
···

       88
       88
        
       func (r *atHtmlRenderer) renderAt(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       89
       89
        
       	if entering {

     

       90
       90
        
       		w.WriteString(`<a href="/@`)

     

       91
       91
       -
       		w.WriteString(n.(*AtNode).handle)

     

       91
       91
       +
       		w.WriteString(n.(*AtNode).Handle)

     

       92
       92
        
       		w.WriteString(`" class="mention">`)

     

       93
       93
        
       	} else {

     

       94
       94
        
       		w.WriteString("</a>")

+24

appview/pages/markup/markdown.go

···

       77
       77
        
       	return md

     

       78
       78
        
       }

     

       79
       79
        
       

     

       80
       80
       +
       // FindUserMentions returns Set of user handles from given markup soruce.

     

       81
       81
       +
       // It doesn't guarntee unique DIDs

     

       82
       82
       +
       func FindUserMentions(source string) []string {

     

       83
       83
       +
       	var (

     

       84
       84
       +
       		mentions    []string

     

       85
       85
       +
       		mentionsSet = make(map[string]struct{})

     

       86
       86
       +
       		md          = NewMarkdown()

     

       87
       87
       +
       		sourceBytes = []byte(source)

     

       88
       88
       +
       		root        = md.Parser().Parse(text.NewReader(sourceBytes))

     

       89
       89
       +
       	)

     

       90
       90
       +
       	ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       91
       91
       +
       		if entering && n.Kind() == textension.KindAt {

     

       92
       92
       +
       			handle := n.(*textension.AtNode).Handle

     

       93
       93
       +
       			mentionsSet[handle] = struct{}{}

     

       94
       94
       +
       			return ast.WalkSkipChildren, nil

     

       95
       95
       +
       		}

     

       96
       96
       +
       		return ast.WalkContinue, nil

     

       97
       97
       +
       	})

     

       98
       98
       +
       	for handle := range mentionsSet {

     

       99
       99
       +
       		mentions = append(mentions, handle)

     

       100
       100
       +
       	}

     

       101
       101
       +
       	return mentions

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       80
       104
        
       func (rctx *RenderContext) RenderMarkdown(source string) string {

     

       81
       105
        
       	md := NewMarkdown()

     

       82
       106

+123

appview/pages/markup/reference_link.go

···

       1
       1
       +
       package markup

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"maps"

     

       5
       5
       +
       	"net/url"

     

       6
       6
       +
       	"path"

     

       7
       7
       +
       	"slices"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

       11
       11
       +
       	"github.com/yuin/goldmark/ast"

     

       12
       12
       +
       	"github.com/yuin/goldmark/text"

     

       13
       13
       +
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       // FindReferences collects all links referencing tangled-related objects

     

       17
       17
       +
       // like issues, PRs, comments or even @-mentions

     

       18
       18
       +
       // This funciton doesn't actually check for the existence of records in the DB

     

       19
       19
       +
       // or the PDS; it merely returns a list of what are presumed to be references.

     

       20
       20
       +
       func FindReferences(baseUrl string, source string) ([]string, []models.ReferenceLink) {

     

       21
       21
       +
       	var (

     

       22
       22
       +
       		refLinkSet  = make(map[models.ReferenceLink]struct{})

     

       23
       23
       +
       		mentionsSet = make(map[string]struct{})

     

       24
       24
       +
       		md          = NewMarkdown()

     

       25
       25
       +
       		sourceBytes = []byte(source)

     

       26
       26
       +
       		root        = md.Parser().Parse(text.NewReader(sourceBytes))

     

       27
       27
       +
       	)

     

       28
       28
       +
       	// trim url scheme. the SSL shouldn't matter

     

       29
       29
       +
       	baseUrl = strings.TrimPrefix(baseUrl, "https://")

     

       30
       30
       +
       	baseUrl = strings.TrimPrefix(baseUrl, "http://")

     

       31
       31
       +
       

     

       32
       32
       +
       	ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       33
       33
       +
       		if !entering {

     

       34
       34
       +
       			return ast.WalkContinue, nil

     

       35
       35
       +
       		}

     

       36
       36
       +
       		switch n.Kind() {

     

       37
       37
       +
       		case KindAt:

     

       38
       38
       +
       			handle := n.(*AtNode).handle

     

       39
       39
       +
       			mentionsSet[handle] = struct{}{}

     

       40
       40
       +
       			return ast.WalkSkipChildren, nil

     

       41
       41
       +
       		case ast.KindLink:

     

       42
       42
       +
       			dest := string(n.(*ast.Link).Destination)

     

       43
       43
       +
       			ref := parseTangledLink(baseUrl, dest)

     

       44
       44
       +
       			if ref != nil {

     

       45
       45
       +
       				refLinkSet[*ref] = struct{}{}

     

       46
       46
       +
       			}

     

       47
       47
       +
       			return ast.WalkSkipChildren, nil

     

       48
       48
       +
       		case ast.KindAutoLink:

     

       49
       49
       +
       			an := n.(*ast.AutoLink)

     

       50
       50
       +
       			if an.AutoLinkType == ast.AutoLinkURL {

     

       51
       51
       +
       				dest := string(an.URL(sourceBytes))

     

       52
       52
       +
       				ref := parseTangledLink(baseUrl, dest)

     

       53
       53
       +
       				if ref != nil {

     

       54
       54
       +
       					refLinkSet[*ref] = struct{}{}

     

       55
       55
       +
       				}

     

       56
       56
       +
       			}

     

       57
       57
       +
       			return ast.WalkSkipChildren, nil

     

       58
       58
       +
       		}

     

       59
       59
       +
       		return ast.WalkContinue, nil

     

       60
       60
       +
       	})

     

       61
       61
       +
       	mentions := slices.Collect(maps.Keys(mentionsSet))

     

       62
       62
       +
       	references := slices.Collect(maps.Keys(refLinkSet))

     

       63
       63
       +
       	return mentions, references

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

       66
       66
       +
       func parseTangledLink(baseHost string, urlStr string) *models.ReferenceLink {

     

       67
       67
       +
       	u, err := url.Parse(urlStr)

     

       68
       68
       +
       	if err != nil {

     

       69
       69
       +
       		return nil

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

       72
       72
       +
       	if u.Host != "" && !strings.EqualFold(u.Host, baseHost) {

     

       73
       73
       +
       		return nil

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	p := path.Clean(u.Path)

     

       77
       77
       +
       	parts := strings.FieldsFunc(p, func(r rune) bool { return r == '/' })

     

       78
       78
       +
       	if len(parts) < 4 {

     

       79
       79
       +
       		// need at least: handle / repo / kind / id

     

       80
       80
       +
       		return nil

     

       81
       81
       +
       	}

     

       82
       82
       +
       

     

       83
       83
       +
       	var (

     

       84
       84
       +
       		handle     = parts[0]

     

       85
       85
       +
       		repo       = parts[1]

     

       86
       86
       +
       		kindSeg    = parts[2]

     

       87
       87
       +
       		subjectSeg = parts[3]

     

       88
       88
       +
       	)

     

       89
       89
       +
       

     

       90
       90
       +
       	handle = strings.TrimPrefix(handle, "@")

     

       91
       91
       +
       

     

       92
       92
       +
       	var kind models.RefKind

     

       93
       93
       +
       	switch kindSeg {

     

       94
       94
       +
       	case "issues":

     

       95
       95
       +
       		kind = models.RefKindIssue

     

       96
       96
       +
       	case "pulls":

     

       97
       97
       +
       		kind = models.RefKindPull

     

       98
       98
       +
       	default:

     

       99
       99
       +
       		return nil

     

       100
       100
       +
       	}

     

       101
       101
       +
       

     

       102
       102
       +
       	subjectId, err := strconv.Atoi(subjectSeg)

     

       103
       103
       +
       	if err != nil {

     

       104
       104
       +
       		return nil

     

       105
       105
       +
       	}

     

       106
       106
       +
       	var commentId *int

     

       107
       107
       +
       	if u.Fragment != "" {

     

       108
       108
       +
       		if strings.HasPrefix(u.Fragment, "comment-") {

     

       109
       109
       +
       			commentIdStr := u.Fragment[len("comment-"):]

     

       110
       110
       +
       			if id, err := strconv.Atoi(commentIdStr); err == nil {

     

       111
       111
       +
       				commentId = &id

     

       112
       112
       +
       			}

     

       113
       113
       +
       		}

     

       114
       114
       +
       	}

     

       115
       115
       +
       

     

       116
       116
       +
       	return &models.ReferenceLink{

     

       117
       117
       +
       		Handle:    handle,

     

       118
       118
       +
       		Repo:      repo,

     

       119
       119
       +
       		Kind:      kind,

     

       120
       120
       +
       		SubjectId: subjectId,

     

       121
       121
       +
       		CommentId: commentId,

     

       122
       122
       +
       	}

     

       123
       123
       +
       }

+42

appview/pages/markup/reference_link_test.go

···

       1
       1
       +
       package markup_test

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       

     

       6
       6
       +
       	"github.com/stretchr/testify/assert"

     

       7
       7
       +
       	"tangled.org/core/appview/models"

     

       8
       8
       +
       	"tangled.org/core/appview/pages/markup"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       func TestMarkupParsing(t *testing.T) {

     

       12
       12
       +
       	tests := []struct {

     

       13
       13
       +
       		name         string

     

       14
       14
       +
       		source       string

     

       15
       15
       +
       		wantHandles  []string

     

       16
       16
       +
       		wantRefLinks []models.ReferenceLink

     

       17
       17
       +
       	}{

     

       18
       18
       +
       		{

     

       19
       19
       +
       			name:        "normal link",

     

       20
       20
       +
       			source:      `[link](http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1)`,

     

       21
       21
       +
       			wantHandles: make([]string, 0),

     

       22
       22
       +
       			wantRefLinks: []models.ReferenceLink{

     

       23
       23
       +
       				{Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil},

     

       24
       24
       +
       			},

     

       25
       25
       +
       		},

     

       26
       26
       +
       		{

     

       27
       27
       +
       			name:        "commonmark style autolink",

     

       28
       28
       +
       			source:      `<http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1>`,

     

       29
       29
       +
       			wantHandles: make([]string, 0),

     

       30
       30
       +
       			wantRefLinks: []models.ReferenceLink{

     

       31
       31
       +
       				{Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil},

     

       32
       32
       +
       			},

     

       33
       33
       +
       		},

     

       34
       34
       +
       	}

     

       35
       35
       +
       	for _, tt := range tests {

     

       36
       36
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       37
       37
       +
       			handles, refLinks := markup.FindReferences("http://127.0.0.1:3000", tt.source)

     

       38
       38
       +
       			assert.ElementsMatch(t, tt.wantHandles, handles)

     

       39
       39
       +
       			assert.ElementsMatch(t, tt.wantRefLinks, refLinks)

     

       40
       40
       +
       		})

     

       41
       41
       +
       	}

     

       42
       42
       +
       }

+6 -10

appview/pulls/pulls.go

···

       23
       23
        
       	"tangled.org/core/appview/oauth"

     

       24
       24
        
       	"tangled.org/core/appview/pages"

     

       25
       25
        
       	"tangled.org/core/appview/pages/markup"

     

       26
       26
       +
       	"tangled.org/core/appview/refresolver"

     

       26
       27
        
       	"tangled.org/core/appview/reporesolver"

     

       27
       28
        
       	"tangled.org/core/appview/validator"

     

       28
       29
        
       	"tangled.org/core/appview/xrpcclient"

     
···

       45
       46
        
       	repoResolver *reporesolver.RepoResolver

     

       46
       47
        
       	pages        *pages.Pages

     

       47
       48
        
       	idResolver   *idresolver.Resolver

     

       49
       49
       +
       	refResolver  *refresolver.Resolver

     

       48
       50
        
       	db           *db.DB

     

       49
       51
        
       	config       *config.Config

     

       50
       52
        
       	notifier     notify.Notifier

     
···

       59
       61
        
       	repoResolver *reporesolver.RepoResolver,

     

       60
       62
        
       	pages *pages.Pages,

     

       61
       63
        
       	resolver *idresolver.Resolver,

     

       64
       64
       +
       	refResolver *refresolver.Resolver,

     

       62
       65
        
       	db *db.DB,

     

       63
       66
        
       	config *config.Config,

     

       64
       67
        
       	notifier notify.Notifier,

     
···

       72
       75
        
       		repoResolver: repoResolver,

     

       73
       76
        
       		pages:        pages,

     

       74
       77
        
       		idResolver:   resolver,

     

       78
       78
       +
       		refResolver:  refResolver,

     

       75
       79
        
       		db:           db,

     

       76
       80
        
       		config:       config,

     

       77
       81
        
       		notifier:     notifier,

     
···

       691
       695
        
       }

     

       692
       696
        
       

     

       693
       697
        
       func (s *Pulls) PullComment(w http.ResponseWriter, r *http.Request) {

     

       694
       694
       -
       	l := s.logger.With("handler", "PullComment")

     

       695
       698
        
       	user := s.oauth.GetUser(r)

     

       696
       699
        
       	f, err := s.repoResolver.Resolve(r)

     

       697
       700
        
       	if err != nil {

     
···

       730
       733
        
       			return

     

       731
       734
        
       		}

     

       732
       735
        
       

     

       736
       736
       +
       		mentions, _ := s.refResolver.Resolve(r.Context(), body)

     

       737
       737
       +
       

     

       733
       738
        
       		// Start a transaction

     

       734
       739
        
       		tx, err := s.db.BeginTx(r.Context(), nil)

     

       735
       740
        
       		if err != nil {

     
···

       789
       794
        
       			return

     

       790
       795
        
       		}

     

       791
       796
        
       

     

       792
       792
       -
       		rawMentions := markup.FindUserMentions(comment.Body)

     

       793
       793
       -
       		idents := s.idResolver.ResolveIdents(r.Context(), rawMentions)

     

       794
       794
       -
       		l.Debug("parsed mentions", "raw", rawMentions, "idents", idents)

     

       795
       795
       -
       		var mentions []syntax.DID

     

       796
       796
       -
       		for _, ident := range idents {

     

       797
       797
       -
       			if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       798
       798
       -
       				mentions = append(mentions, ident.DID)

     

       799
       799
       -
       			}

     

       800
       800
       -
       		}

     

       801
       797
        
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       802
       798
        
       

     

       803
       799
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

+65

appview/refresolver/resolver.go

···

       1
       1
       +
       package refresolver

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	"tangled.org/core/appview/config"

     

       9
       9
       +
       	"tangled.org/core/appview/db"

     

       10
       10
       +
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/appview/pages/markup"

     

       12
       12
       +
       	"tangled.org/core/idresolver"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type Resolver struct {

     

       16
       16
       +
       	config     *config.Config

     

       17
       17
       +
       	idResolver *idresolver.Resolver

     

       18
       18
       +
       	execer     db.Execer

     

       19
       19
       +
       	logger     *slog.Logger

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func New(

     

       23
       23
       +
       	config *config.Config,

     

       24
       24
       +
       	idResolver *idresolver.Resolver,

     

       25
       25
       +
       	execer db.Execer,

     

       26
       26
       +
       	logger *slog.Logger,

     

       27
       27
       +
       ) *Resolver {

     

       28
       28
       +
       	return &Resolver{

     

       29
       29
       +
       		config,

     

       30
       30
       +
       		idResolver,

     

       31
       31
       +
       		execer,

     

       32
       32
       +
       		logger,

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) {

     

       37
       37
       +
       	l := r.logger.With("method", "find_references")

     

       38
       38
       +
       	rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source)

     

       39
       39
       +
       	l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs)

     

       40
       40
       +
       	idents := r.idResolver.ResolveIdents(ctx, rawMentions)

     

       41
       41
       +
       	var mentions []syntax.DID

     

       42
       42
       +
       	for _, ident := range idents {

     

       43
       43
       +
       		if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       44
       44
       +
       			mentions = append(mentions, ident.DID)

     

       45
       45
       +
       		}

     

       46
       46
       +
       	}

     

       47
       47
       +
       	l.Debug("found mentions", "mentions", mentions)

     

       48
       48
       +
       

     

       49
       49
       +
       	var resolvedRefs []models.ReferenceLink

     

       50
       50
       +
       	for _, rawRef := range rawRefs {

     

       51
       51
       +
       		ident, err := r.idResolver.ResolveIdent(ctx, rawRef.Handle)

     

       52
       52
       +
       		if err != nil || ident == nil || ident.Handle.IsInvalidHandle() {

     

       53
       53
       +
       			continue

     

       54
       54
       +
       		}

     

       55
       55
       +
       		rawRef.Handle = string(ident.DID)

     

       56
       56
       +
       		resolvedRefs = append(resolvedRefs, rawRef)

     

       57
       57
       +
       	}

     

       58
       58
       +
       	aturiRefs, err := db.FindReferences(r.execer, resolvedRefs)

     

       59
       59
       +
       	if err != nil {

     

       60
       60
       +
       		l.Error("failed running query", "err", err)

     

       61
       61
       +
       	}

     

       62
       62
       +
       	l.Debug("found references", "refs", aturiRefs)

     

       63
       63
       +
       

     

       64
       64
       +
       	return mentions, aturiRefs

     

       65
       65
       +
       }

appview/state/router.go

···

       260
       260
        
       		s.repoResolver,

     

       261
       261
        
       		s.pages,

     

       262
       262
        
       		s.idResolver,

     

       263
       263
       +
       		s.refResolver,

     

       263
       264
        
       		s.db,

     

       264
       265
        
       		s.config,

     

       265
       266
        
       		s.notifier,

     
···

       276
       277
        
       		s.repoResolver,

     

       277
       278
        
       		s.pages,

     

       278
       279
        
       		s.idResolver,

     

       280
       280
       +
       		s.refResolver,

     

       279
       281
        
       		s.db,

     

       280
       282
        
       		s.config,

     

       281
       283
        
       		s.notifier,

appview/state/state.go

···

       21
       21
        
       	phnotify "tangled.org/core/appview/notify/posthog"

     

       22
       22
        
       	"tangled.org/core/appview/oauth"

     

       23
       23
        
       	"tangled.org/core/appview/pages"

     

       24
       24
       +
       	"tangled.org/core/appview/refresolver"

     

       24
       25
        
       	"tangled.org/core/appview/reporesolver"

     

       25
       26
        
       	"tangled.org/core/appview/validator"

     

       26
       27
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     
···

       49
       50
        
       	enforcer      *rbac.Enforcer

     

       50
       51
        
       	pages         *pages.Pages

     

       51
       52
        
       	idResolver    *idresolver.Resolver

     

       53
       53
       +
       	refResolver   *refresolver.Resolver

     

       52
       54
        
       	posthog       posthog.Client

     

       53
       55
        
       	jc            *jetstream.JetstreamClient

     

       54
       56
        
       	config        *config.Config

     
···

       98
       100
        
       

     

       99
       101
        
       	repoResolver := reporesolver.New(config, enforcer, res, d)

     

       100
       102
        
       

     

       103
       103
       +
       	refResolver := refresolver.New(config, res, d, log.SubLogger(logger, "refResolver"))

     

       104
       104
       +
       

     

       101
       105
        
       	wrapper := db.DbWrapper{Execer: d}

     

       102
       106
        
       	jc, err := jetstream.NewJetstreamClient(

     

       103
       107
        
       		config.Jetstream.Endpoint,

     
···

       178
       182
        
       		enforcer,

     

       179
       183
        
       		pages,

     

       180
       184
        
       		res,

     

       185
       185
       +
       		refResolver,

     

       181
       186
        
       		posthog,

     

       182
       187
        
       		jc,

     

       183
       188
        
       		config,