// GoToSocial // Copyright (C) GoToSocial Authors admin@gotosocial.org // SPDX-License-Identifier: AGPL-3.0-or-later // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. package text import ( "fmt" "strings" "github.com/superseriousbusiness/gotosocial/internal/regexes" "github.com/yuin/goldmark/ast" "github.com/yuin/goldmark/parser" "github.com/yuin/goldmark/text" ) /* MENTION PARSER STUFF */ // mention fulfils the goldmark // ast.Node interface. type mention struct { ast.BaseInline Segment text.Segment } var kindMention = ast.NewNodeKind("Mention") func (n *mention) Kind() ast.NodeKind { return kindMention } func (n *mention) Dump(source []byte, level int) { fmt.Printf("%sMention: %s\n", strings.Repeat(" ", level), string(n.Segment.Value(source))) } // newMention creates a goldmark ast.Node // from a text.Segment. The contained segment // is used in rendering. func newMention(s text.Segment) *mention { return &mention{ BaseInline: ast.BaseInline{}, Segment: s, } } // mentionParser fulfils the goldmark // parser.InlineParser interface. type mentionParser struct{} // Mention parsing is triggered by the `@` symbol // which appears at the beginning of a mention. func (p *mentionParser) Trigger() []byte { return []byte{'@'} } func (p *mentionParser) Parse( _ ast.Node, block text.Reader, _ parser.Context, ) ast.Node { // If preceding character is not a valid boundary // character, then this cannot be a valid mention. if !isMentionBoundary(block.PrecendingCharacter()) { return nil } line, segment := block.PeekLine() // Ascertain location of mention in the line // that starts with the trigger character. loc := regexes.MentionFinder.FindIndex(line) if loc == nil || loc[0] != 0 { // Noop if not found or // not found at start. return nil } // Advance the block to // the end of the mention. block.Advance(loc[1]) // mention ast.Node spans from the // beginning of this segment up to // the last character of the mention. return newMention( segment.WithStop( segment.Start + loc[1], ), ) } /* HASHTAG PARSER STUFF */ // hashtag fulfils the goldmark // ast.Node interface. type hashtag struct { ast.BaseInline Segment text.Segment } var kindHashtag = ast.NewNodeKind("Hashtag") func (n *hashtag) Kind() ast.NodeKind { return kindHashtag } func (n *hashtag) Dump(source []byte, level int) { fmt.Printf("%sHashtag: %s\n", strings.Repeat(" ", level), string(n.Segment.Value(source))) } // newHashtag creates a goldmark ast.Node // from a text.Segment. The contained segment // is used in rendering. func newHashtag(s text.Segment) *hashtag { return &hashtag{ BaseInline: ast.BaseInline{}, Segment: s, } } type hashtagParser struct{} // Hashtag parsing is triggered by a '#' symbol // which appears at the beginning of a hashtag. func (p *hashtagParser) Trigger() []byte { return []byte{'#'} } func (p *hashtagParser) Parse( _ ast.Node, block text.Reader, _ parser.Context, ) ast.Node { // If preceding character is not a valid boundary // character, then this cannot be a valid hashtag. if !isHashtagBoundary(block.PrecendingCharacter()) { return nil } var ( line, segment = block.PeekLine() lineStr = string(line) lineStrLen = len(lineStr) ) if lineStrLen <= 1 { // This is probably just // a lonely '#' char. return nil } // Iterate through the runes in the detected // hashtag string until we reach either: // - A weird character (bad). // - The end of the hashtag (ok). // - The end of the string (also ok). for i, r := range lineStr { switch { case r == '#' && i == 0: // Ignore initial '#'. continue case !isPlausiblyInHashtag(r) && !isHashtagBoundary(r): // Weird non-boundary character // in the hashtag. Don't trust it. return nil case isHashtagBoundary(r): // Reached closing hashtag // boundary. Advance block // to the end of the hashtag. block.Advance(i) // hashtag ast.Node spans from // the beginning of this segment // up to the boundary character. return newHashtag( segment.WithStop( segment.Start + i, ), ) } } // No invalid or boundary characters before the // end of the line: it's all hashtag, baby 😎 // // Advance block to the end of the segment. block.Advance(segment.Len()) // hashtag ast.Node spans // the entire segment. return newHashtag(segment) } /* EMOJI PARSER STUFF */ // emoji fulfils the goldmark // ast.Node interface. type emoji struct { ast.BaseInline Segment text.Segment } var kindEmoji = ast.NewNodeKind("Emoji") func (n *emoji) Kind() ast.NodeKind { return kindEmoji } func (n *emoji) Dump(source []byte, level int) { fmt.Printf("%sEmoji: %s\n", strings.Repeat(" ", level), string(n.Segment.Value(source))) } // newEmoji creates a goldmark ast.Node // from a text.Segment. The contained // segment is used in rendering. func newEmoji(s text.Segment) *emoji { return &emoji{ BaseInline: ast.BaseInline{}, Segment: s, } } type emojiParser struct{} // Emoji parsing is triggered by a ':' char // which appears at the start of the emoji. func (p *emojiParser) Trigger() []byte { return []byte{':'} } func (p *emojiParser) Parse( _ ast.Node, block text.Reader, _ parser.Context, ) ast.Node { line, segment := block.PeekLine() // Ascertain location of emoji in the line // that starts with the trigger character. loc := regexes.EmojiFinder.FindIndex(line) if loc == nil || loc[0] != 0 { // Noop if not found or // not found at start. return nil } // Advance the block to // the end of the emoji. block.Advance(loc[1]) // emoji ast.Node spans from the // beginning of this segment up to // the last character of the emoji. return newEmoji( segment.WithStop( segment.Start + loc[1], ), ) }