protocol/messenger_mention.go
package protocol
// this is a reimplementation of the mention feature in status-react
// reference implementation: https://github.com/status-im/status-react/blob/972347963498fc4a2bb8f85541e79ed0541698da/src/status_im/chat/models/mentions.cljs#L1
import (
"encoding/json"
"fmt"
"regexp"
"strings"
"unicode"
"unicode/utf8"
"go.uber.org/zap"
"github.com/status-im/status-go/logutils"
"github.com/status-im/status-go/api/multiformat"
"github.com/status-im/status-go/protocol/common"
)
const (
endingChars = `[\s\.,;:]`
charAtSign = "@"
charQuote = ">"
charNewline = "\n"
charAsterisk = "*"
charUnderscore = "_"
charTilde = "~"
charCodeBlock = "`"
intUnknown = -1
)
var (
specialCharsRegex = regexp.MustCompile("[@~\\\\*_\n>`]{1}")
endingCharsRegex = regexp.MustCompile(endingChars)
wordRegex = regexp.MustCompile("^[\\w\\d\\-]*" + endingChars + "|[\\S]+")
)
type specialCharLocation struct {
Index int
Value string
}
type atSignIndex struct {
Pending []int
Checked []int
}
type styleTag struct {
Len int
Idx int
}
type textMeta struct {
atSign *atSignIndex
styleTagMap map[string]*styleTag
quoteIndex *int
newlineIndexes []int
}
type searchablePhrase struct {
originalName string
phrase string
}
type MentionableUser struct {
*Contact
searchablePhrases []searchablePhrase
Key string // a unique identifier of a mentionable user
Match string
SearchedText string
}
func (c *MentionableUser) MarshalJSON() ([]byte, error) {
compressedKey, err := multiformat.SerializeLegacyKey(c.ID)
if err != nil {
return nil, err
}
type MentionableUserJSON struct {
PrimaryName string `json:"primaryName"`
SecondaryName string `json:"secondaryName"`
ENSVerified bool `json:"ensVerified"`
Added bool `json:"added"`
DisplayName string `json:"displayName"`
Key string `json:"key"`
Match string `json:"match"`
SearchedText string `json:"searchedText"`
ID string `json:"id"`
CompressedKey string `json:"compressedKey,omitempty"`
}
contactJSON := MentionableUserJSON{
PrimaryName: c.PrimaryName(),
SecondaryName: c.SecondaryName(),
ENSVerified: c.ENSVerified,
Added: c.added(),
DisplayName: c.GetDisplayName(),
Key: c.Key,
Match: c.Match,
SearchedText: c.SearchedText,
ID: c.ID,
CompressedKey: compressedKey,
}
return json.Marshal(contactJSON)
}
func (c *MentionableUser) GetDisplayName() string {
if c.ENSVerified && c.EnsName != "" {
return c.EnsName
}
if c.DisplayName != "" {
return c.DisplayName
}
if c.PrimaryName() != "" {
return c.PrimaryName()
}
return c.Alias
}
type SegmentType int
const (
Text SegmentType = iota
Mention
)
type InputSegment struct {
Type SegmentType `json:"type"`
Value string `json:"value"`
}
type MentionState struct {
AtSignIdx int
AtIdxs []*AtIndexEntry
MentionEnd int
PreviousText string
NewText string
Start int
End int
operation textOperation
}
func (ms *MentionState) String() string {
atIdxsStr := ""
for i, entry := range ms.AtIdxs {
if i > 0 {
atIdxsStr += ", "
}
atIdxsStr += fmt.Sprintf("%+v", entry)
}
return fmt.Sprintf("MentionState{AtSignIdx: %d, AtIdxs: [%s], MentionEnd: %d, PreviousText: %q, NewText: %s, Start: %d, End: %d}",
ms.AtSignIdx, atIdxsStr, ms.MentionEnd, ms.PreviousText, ms.NewText, ms.Start, ms.End)
}
type ChatMentionContext struct {
ChatID string
InputSegments []InputSegment
MentionSuggestions map[string]*MentionableUser
MentionState *MentionState
PreviousText string // user input text before the last change
NewText string
}
func NewChatMentionContext(chatID string) *ChatMentionContext {
return &ChatMentionContext{
ChatID: chatID,
MentionSuggestions: make(map[string]*MentionableUser),
MentionState: new(MentionState),
}
}
type mentionableUserGetter interface {
getMentionableUsers(chatID string) (map[string]*MentionableUser, error)
getMentionableUser(chatID string, pk string) (*MentionableUser, error)
}
type MentionManager struct {
mentionContexts map[string]*ChatMentionContext
*Messenger
mentionableUserGetter
logger *zap.Logger
}
func NewMentionManager(m *Messenger) *MentionManager {
mm := &MentionManager{
mentionContexts: make(map[string]*ChatMentionContext),
Messenger: m,
logger: logutils.ZapLogger().Named("MentionManager"),
}
mm.mentionableUserGetter = mm
return mm
}
func (m *MentionManager) getChatMentionContext(chatID string) *ChatMentionContext {
ctx, ok := m.mentionContexts[chatID]
if !ok {
ctx = NewChatMentionContext(chatID)
m.mentionContexts[chatID] = ctx
}
return ctx
}
func (m *MentionManager) getMentionableUser(chatID string, pk string) (*MentionableUser, error) {
mentionableUsers, err := m.mentionableUserGetter.getMentionableUsers(chatID)
if err != nil {
return nil, err
}
user, ok := mentionableUsers[pk]
if !ok {
return nil, fmt.Errorf("user not found when getting mentionable user, pk: %s", pk)
}
return user, nil
}
func (m *MentionManager) getMentionableUsers(chatID string) (map[string]*MentionableUser, error) {
mentionableUsers := make(map[string]*MentionableUser)
chat, _ := m.allChats.Load(chatID)
if chat == nil {
return nil, fmt.Errorf("chat not found when getting mentionable users, chatID: %s", chatID)
}
var publicKeys []string
switch {
case chat.PrivateGroupChat():
for _, mb := range chat.Members {
publicKeys = append(publicKeys, mb.ID)
}
case chat.OneToOne():
publicKeys = append(publicKeys, chatID)
case chat.CommunityChat():
community, err := m.communitiesManager.GetByIDString(chat.CommunityID)
if err != nil {
return nil, err
}
for _, pk := range community.GetMemberPubkeys() {
publicKeys = append(publicKeys, common.PubkeyToHex(pk))
}
case chat.Public():
m.allContacts.Range(func(pk string, _ *Contact) bool {
publicKeys = append(publicKeys, pk)
return true
})
}
var me = m.myHexIdentity()
for _, pk := range publicKeys {
if pk == me {
continue
}
if err := m.addMentionableUser(mentionableUsers, pk); err != nil {
return nil, err
}
}
return mentionableUsers, nil
}
func (m *MentionManager) addMentionableUser(mentionableUsers map[string]*MentionableUser, publicKey string) error {
contact, ok := m.allContacts.Load(publicKey)
if !ok {
c, err := buildContactFromPkString(publicKey)
if err != nil {
return err
}
contact = c
}
user := &MentionableUser{
Contact: contact,
}
user = addSearchablePhrases(user)
if user != nil {
mentionableUsers[publicKey] = user
}
return nil
}
func (m *MentionManager) ReplaceWithPublicKey(chatID, text string) (string, error) {
chat, _ := m.allChats.Load(chatID)
if chat == nil {
return "", fmt.Errorf("chat not found when check mentions, chatID: %s", chatID)
}
mentionableUsers, err := m.mentionableUserGetter.getMentionableUsers(chatID)
if err != nil {
return "", err
}
newText := ReplaceMentions(text, mentionableUsers)
m.ClearMentions(chatID)
return newText, nil
}
func (m *MentionManager) OnChangeText(chatID, fullText string) (*ChatMentionContext, error) {
ctx := m.getChatMentionContext(chatID)
diff := diffText(ctx.PreviousText, fullText)
if diff == nil {
return ctx, nil
}
ctx.PreviousText = fullText
if ctx.MentionState == nil {
ctx.MentionState = &MentionState{}
}
ctx.MentionState.PreviousText = diff.previousText
ctx.MentionState.NewText = diff.newText
ctx.MentionState.Start = diff.start
ctx.MentionState.End = diff.end
ctx.MentionState.operation = diff.operation
atIndexes, err := calculateAtIndexEntries(ctx.MentionState)
if err != nil {
return ctx, err
}
ctx.MentionState.AtIdxs = atIndexes
m.logger.Debug("OnChangeText", zap.String("chatID", chatID), zap.Any("state", ctx.MentionState))
return m.calculateSuggestions(chatID, fullText)
}
func (m *MentionManager) calculateSuggestions(chatID, fullText string) (*ChatMentionContext, error) {
ctx := m.getChatMentionContext(chatID)
mentionableUsers, err := m.mentionableUserGetter.getMentionableUsers(chatID)
if err != nil {
return nil, err
}
m.logger.Debug("calculateSuggestions", zap.String("chatID", chatID), zap.String("fullText", fullText), zap.Int("num of mentionable user", len(mentionableUsers)))
m.calculateSuggestionsWithMentionableUsers(chatID, fullText, mentionableUsers)
return ctx, nil
}
func (m *MentionManager) calculateSuggestionsWithMentionableUsers(chatID string, fullText string, mentionableUsers map[string]*MentionableUser) {
ctx := m.getChatMentionContext(chatID)
state := ctx.MentionState
if len(state.AtIdxs) == 0 {
state.AtIdxs = nil
ctx.MentionSuggestions = nil
ctx.InputSegments = []InputSegment{{
Type: Text,
Value: fullText,
}}
return
}
newAtIndexEntries := checkIdxForMentions(fullText, state.AtIdxs, mentionableUsers)
calculatedInput, success := calculateInput(fullText, newAtIndexEntries)
if !success {
m.logger.Warn("calculateSuggestionsWithMentionableUsers: calculateInput failed", zap.String("chatID", chatID), zap.String("fullText", fullText), zap.Any("state", state))
}
var end int
switch state.operation {
case textOperationAdd:
end = state.Start + len([]rune(state.NewText))
case textOperationDelete:
end = state.Start
case textOperationReplace:
end = state.Start + len([]rune(state.NewText))
default:
m.logger.Error("calculateSuggestionsWithMentionableUsers: unknown textOperation", zap.String("chatID", chatID), zap.String("fullText", fullText), zap.Any("state", state))
}
atSignIdx := lastIndexOfAtSign(fullText, end)
var suggestions map[string]*MentionableUser
if atSignIdx != -1 {
searchedText := strings.ToLower(subs(fullText, atSignIdx+1, end))
m.logger.Debug("calculateSuggestionsWithMentionableUsers", zap.Int("atSignIdx", atSignIdx), zap.String("searchedText", searchedText), zap.String("fullText", fullText), zap.Any("state", state), zap.Int("end", end))
if end-atSignIdx <= 100 {
suggestions = getUserSuggestions(mentionableUsers, searchedText, -1)
}
}
state.AtSignIdx = atSignIdx
state.AtIdxs = newAtIndexEntries
state.MentionEnd = end
ctx.InputSegments = calculatedInput
ctx.MentionSuggestions = suggestions
}
func (m *MentionManager) SelectMention(chatID, text, primaryName, publicKey string) (*ChatMentionContext, error) {
ctx := m.getChatMentionContext(chatID)
state := ctx.MentionState
atSignIdx := state.AtSignIdx
mentionEnd := state.MentionEnd
var nextChar rune
tr := []rune(text)
if mentionEnd < len(tr) {
nextChar = tr[mentionEnd]
}
space := ""
if string(nextChar) == "" || (!unicode.IsSpace(nextChar)) {
space = " "
}
ctx.NewText = string(tr[:atSignIdx+1]) + primaryName + space + string(tr[mentionEnd:])
ctx, err := m.OnChangeText(chatID, ctx.NewText)
if err != nil {
return nil, err
}
m.clearSuggestions(chatID)
return ctx, nil
}
func (m *MentionManager) clearSuggestions(chatID string) {
m.getChatMentionContext(chatID).MentionSuggestions = nil
}
func (m *MentionManager) ClearMentions(chatID string) {
ctx := m.getChatMentionContext(chatID)
ctx.MentionState = nil
ctx.InputSegments = nil
ctx.NewText = ""
ctx.PreviousText = ""
m.clearSuggestions(chatID)
}
func (m *MentionManager) ToInputField(chatID, text string) (*ChatMentionContext, error) {
mentionableUsers, err := m.mentionableUserGetter.getMentionableUsers(chatID)
if err != nil {
return nil, err
}
textWithMentions := toInputField(text)
newText := ""
for i, segment := range textWithMentions {
if segment.Type == Mention {
mentionableUser := mentionableUsers[segment.Value]
mention := mentionableUser.GetDisplayName()
if !strings.HasPrefix(mention, charAtSign) {
segment.Value = charAtSign + mention
}
textWithMentions[i] = segment
}
newText += segment.Value
}
ctx := m.getChatMentionContext(chatID)
ctx.InputSegments = textWithMentions
ctx.MentionState = toInfo(textWithMentions)
ctx.NewText = newText
ctx.PreviousText = newText
return ctx, nil
}
func rePos(s string) []specialCharLocation {
var res []specialCharLocation
lastMatch := specialCharsRegex.FindStringIndex(s)
for lastMatch != nil {
start, end := lastMatch[0], lastMatch[1]
c := s[start:end]
res = append(res, specialCharLocation{utf8.RuneCountInString(s[:start]), c})
lastMatch = specialCharsRegex.FindStringIndex(s[end:])
if lastMatch != nil {
lastMatch[0] += end
lastMatch[1] += end
}
}
return res
}
func codeTagLen(idxs []specialCharLocation, idx int) int {
pos, c := idxs[idx].Index, idxs[idx].Value
next := func(n int) (int, string) {
if n < len(idxs) {
return idxs[n].Index, idxs[n].Value
}
return 0, ""
}
pos2, c2 := next(idx + 1)
pos3, c3 := next(idx + 2)
if c == c2 && pos == pos2-1 && c2 == c3 && pos == pos3-2 {
return 3
}
if c == c2 && pos == pos2-1 {
return 2
}
return 1
}
func clearPendingAtSigns(data *textMeta, from int) {
newIdxs := make([]int, 0)
for _, idx := range data.atSign.Pending {
if idx < from {
newIdxs = append(newIdxs, idx)
}
}
data.atSign.Pending = []int{}
data.atSign.Checked = append(data.atSign.Checked, newIdxs...)
}
func checkStyleTag(text string, idxs []specialCharLocation, idx int) (length int, canBeStart bool, canBeEnd bool) {
pos, c := idxs[idx].Index, idxs[idx].Value
tr := []rune(text)
next := func(n int) (int, string) {
if n < len(idxs) {
return idxs[n].Index, idxs[n].Value
}
return len(tr), ""
}
pos2, c2 := next(idx + 1)
pos3, c3 := next(idx + 2)
switch {
case c == c2 && c2 == c3 && pos == pos2-1 && pos == pos3-2:
length = 3
case c == c2 && pos == pos2-1:
length = 2
default:
length = 1
}
var prevC, nextC *rune
if decPos := pos - 1; decPos >= 0 {
prevC = &tr[decPos]
}
nextIdx := idxs[idx+length-1].Index + 1
if nextIdx < len(tr) {
nextC = &tr[nextIdx]
}
if length == 1 {
canBeEnd = prevC != nil && !unicode.IsSpace(*prevC) && (nextC == nil || unicode.IsSpace(*nextC))
} else {
canBeEnd = prevC != nil && !unicode.IsSpace(*prevC)
}
canBeStart = nextC != nil && !unicode.IsSpace(*nextC)
return length, canBeStart, canBeEnd
}
func applyStyleTag(data *textMeta, idx int, pos int, c string, len int, start bool, end bool) int {
tag := data.styleTagMap[c]
tripleTilde := c == charTilde && len == 3
if tag != nil && end {
oldLen := (*tag).Len
var tagLen int
if tripleTilde && oldLen == 3 {
tagLen = 2
} else if oldLen >= len {
tagLen = len
} else {
tagLen = oldLen
}
oldIdx := (*tag).Idx
delete(data.styleTagMap, c)
clearPendingAtSigns(data, oldIdx)
return idx + tagLen
} else if start {
data.styleTagMap[c] = &styleTag{
Len: len,
Idx: pos,
}
clearPendingAtSigns(data, pos)
}
return idx + len
}
func newTextMeta() *textMeta {
return &textMeta{
atSign: new(atSignIndex),
styleTagMap: make(map[string]*styleTag),
}
}
func newDataWithAtSignAndQuoteIndex(atSign *atSignIndex, quoteIndex *int) *textMeta {
data := newTextMeta()
data.atSign = atSign
data.quoteIndex = quoteIndex
return data
}
func getAtSigns(text string) []int {
idxs := rePos(text)
data := newTextMeta()
nextIdx := 0
tr := []rune(text)
for i := range idxs {
if i != nextIdx {
continue
}
nextIdx = i + 1
quoteIndex := data.quoteIndex
c := idxs[i].Value
pos := idxs[i].Index
switch {
case c == charNewline:
prevNewline := intUnknown
if len(data.newlineIndexes) > 0 {
prevNewline = data.newlineIndexes[0]
}
data.newlineIndexes = append(data.newlineIndexes, pos)
if quoteIndex != nil && prevNewline != intUnknown && strings.TrimSpace(string(tr[prevNewline:pos-1])) == "" {
data.quoteIndex = nil
}
case quoteIndex != nil:
continue
case c == charQuote:
prevNewlines := make([]int, 0, 2)
if len(data.newlineIndexes) > 0 {
prevNewlines = data.newlineIndexes
}
if pos == 0 ||
(len(prevNewlines) == 1 && strings.TrimSpace(string(tr[:pos-1])) == "") ||
(len(prevNewlines) == 2 && strings.TrimSpace(string(tr[prevNewlines[0]:pos-1])) == "") {
data = newDataWithAtSignAndQuoteIndex(data.atSign, &pos)
}
case c == charAtSign:
data.atSign.Pending = append(data.atSign.Pending, pos)
case c == charCodeBlock:
length := codeTagLen(idxs, i)
nextIdx = applyStyleTag(data, i, pos, c, length, true, true)
case c == charAsterisk || c == charUnderscore || c == charTilde:
length, canBeStart, canBeEnd := checkStyleTag(text, idxs, i)
nextIdx = applyStyleTag(data, i, pos, c, length, canBeStart, canBeEnd)
}
}
return append(data.atSign.Checked, data.atSign.Pending...)
}
func getUserSuggestions(users map[string]*MentionableUser, searchedText string, limit int) map[string]*MentionableUser {
result := make(map[string]*MentionableUser)
for pk, user := range users {
match := findMatch(user, searchedText)
if match != "" {
result[pk] = &MentionableUser{
searchablePhrases: user.searchablePhrases,
Contact: user.Contact,
Key: pk,
Match: match,
SearchedText: searchedText,
}
}
if limit != -1 && len(result) >= limit {
break
}
}
return result
}
// findMatch searches for a matching phrase in MentionableUser's searchable phrases or names.
func findMatch(user *MentionableUser, searchedText string) string {
if len(user.searchablePhrases) > 0 {
return findMatchInPhrases(user, searchedText)
}
return findMatchInNames(user, searchedText)
}
// findMatchInPhrases searches for a matching phrase in MentionableUser's searchable phrases.
func findMatchInPhrases(user *MentionableUser, searchedText string) string {
var match string
for _, p := range user.searchablePhrases {
if searchedText == "" || strings.HasPrefix(strings.ToLower(p.phrase), searchedText) {
match = p.originalName
break
}
}
return match
}
// findMatchInNames searches for a matching phrase in MentionableUser's primary and secondary names.
func findMatchInNames(user *MentionableUser, searchedText string) string {
var match string
for _, name := range user.names() {
if hasMatchingPrefix(name, searchedText) {
match = name
}
}
return match
}
// hasMatchingPrefix checks if the given text has a matching prefix with the searched text.
func hasMatchingPrefix(text, searchedText string) bool {
return text != "" && (searchedText == "" || strings.HasPrefix(strings.ToLower(text), searchedText))
}
func isMentioned(user *MentionableUser, text string) bool {
regexStr := ""
for i, name := range user.names() {
if name == "" {
continue
}
name = strings.ToLower(name)
if i != 0 {
regexStr += "|"
}
regexStr += "^" + name + endingChars + "|" + "^" + name + "$"
}
regex := regexp.MustCompile(regexStr)
lCaseText := strings.ToLower(text)
return regex.MatchString(lCaseText)
}
func MatchMention(text string, users map[string]*MentionableUser, mentionKeyIdx int) *MentionableUser {
return matchMention(text, users, mentionKeyIdx, mentionKeyIdx+1, nil)
}
func matchMention(text string, users map[string]*MentionableUser, mentionKeyIdx int, nextWordIdx int, words []string) *MentionableUser {
tr := []rune(text)
if nextWordIdx >= len(tr) {
return nil
}
if word := wordRegex.FindString(string(tr[nextWordIdx:])); word != "" {
newWords := append(words, word)
t := strings.TrimSpace(strings.ToLower(strings.Join(newWords, "")))
tt := []rune(t)
searchedText := t
if lastChar := len(tt) - 1; lastChar >= 0 && endingCharsRegex.MatchString(string(tt[lastChar:])) {
searchedText = string(tt[:lastChar])
}
userSuggestions := getUserSuggestions(users, searchedText, -1)
userSuggestionsCnt := len(userSuggestions)
switch {
case userSuggestionsCnt == 0:
return nil
case userSuggestionsCnt == 1:
user := getFirstUser(userSuggestions)
// maybe len(users) == 1 and user input `@` so we need to recheck if the user is really mentioned
if isMentioned(user, string(tr[mentionKeyIdx+1:])) {
return user
}
case userSuggestionsCnt > 1:
wordLen := len([]rune(word))
textLen := len(tr)
nextWordStart := nextWordIdx + wordLen
if textLen > nextWordStart {
user := matchMention(text, users, mentionKeyIdx, nextWordStart, newWords)
if user != nil {
return user
}
}
return filterWithFullMatch(userSuggestions, searchedText)
}
}
return nil
}
func filterWithFullMatch(userSuggestions map[string]*MentionableUser, text string) *MentionableUser {
if text == "" {
return nil
}
result := make(map[string]*MentionableUser)
for pk, user := range userSuggestions {
for _, name := range user.names() {
if strings.ToLower(name) == text {
result[pk] = user
}
}
}
return getFirstUser(result)
}
func getFirstUser(userSuggestions map[string]*MentionableUser) *MentionableUser {
for _, user := range userSuggestions {
return user
}
return nil
}
func ReplaceMentions(text string, users map[string]*MentionableUser) string {
idxs := getAtSigns(text)
return replaceMentions(text, users, idxs, 0)
}
func replaceMentions(text string, users map[string]*MentionableUser, idxs []int, diff int) string {
if strings.TrimSpace(text) == "" || len(idxs) == 0 {
return text
}
mentionKeyIdx := idxs[0] - diff
if len(users) == 0 {
return text
}
matchUser := MatchMention(text, users, mentionKeyIdx)
if matchUser == nil {
return replaceMentions(text, users, idxs[1:], diff)
}
tr := []rune(text)
newText := string(tr[:mentionKeyIdx+1]) + matchUser.ID + string(tr[mentionKeyIdx+1+len([]rune(matchUser.Match)):])
newDiff := diff + len(tr) - len([]rune(newText))
return replaceMentions(newText, users, idxs[1:], newDiff)
}
func addSearchablePhrases(user *MentionableUser) *MentionableUser {
if !user.Blocked {
searchablePhrases := user.names()
for _, s := range searchablePhrases {
if s != "" {
newWords := []string{s}
newWords = append(newWords, strings.Split(s, " ")[1:]...)
var phrases []searchablePhrase
for _, w := range newWords {
phrases = append(phrases, searchablePhrase{s, w})
}
user.searchablePhrases = append(user.searchablePhrases, phrases...)
}
}
return user
}
return nil
}
type AtIndexEntry struct {
From int
To int
Checked bool
Mentioned bool
NextAtIdx int
}
func (e *AtIndexEntry) String() string {
return fmt.Sprintf("{From: %d, To: %d, Checked: %t, Mentioned: %t, NextAtIdx: %d}", e.From, e.To, e.Checked, e.Mentioned, e.NextAtIdx)
}
func calculateAtIndexEntries(state *MentionState) ([]*AtIndexEntry, error) {
var keptAtIndexEntries []*AtIndexEntry
var oldRunes []rune
var newRunes []rune
var previousRunes = []rune(state.PreviousText)
switch state.operation {
case textOperationAdd:
newRunes = []rune(state.NewText)
case textOperationDelete:
oldRunes = previousRunes[state.Start : state.End+1]
case textOperationReplace:
oldRunes = previousRunes[state.Start : state.End+1]
newRunes = []rune(state.NewText)
default:
return nil, fmt.Errorf("unknown text operation: %d", state.operation)
}
oldLen := len(oldRunes)
newLen := len(newRunes)
diff := newLen - oldLen
oldAtSignIndexes := getAtSignIdxs(string(oldRunes), state.Start)
newAtSignIndexes := getAtSignIdxs(state.NewText, state.Start)
for _, entry := range state.AtIdxs {
deleted := false
for _, idx := range oldAtSignIndexes {
if idx == entry.From {
deleted = true
}
}
if !deleted {
if entry.From >= state.Start { // update range with diff
entry.From += diff
entry.To += diff
}
if entry.From < state.Start && entry.To+1 >= state.Start { // impacted after user edit so need to be rechecked
entry.Checked = false
}
keptAtIndexEntries = append(keptAtIndexEntries, entry)
}
}
return addNewAtSignIndexes(keptAtIndexEntries, newAtSignIndexes), nil
}
func addNewAtSignIndexes(keptAtIdxs []*AtIndexEntry, newAtSignIndexes []int) []*AtIndexEntry {
var newAtIndexEntries []*AtIndexEntry
var added bool
var lastNewIdx int
newAtSignIndexesCount := len(newAtSignIndexes)
if newAtSignIndexesCount > 0 {
lastNewIdx = newAtSignIndexes[newAtSignIndexesCount-1]
}
for _, entry := range keptAtIdxs {
if newAtSignIndexesCount > 0 && !added && entry.From > lastNewIdx {
newAtIndexEntries = append(newAtIndexEntries, makeAtIdxs(newAtSignIndexes)...)
newAtIndexEntries = append(newAtIndexEntries, entry)
added = true
} else {
newAtIndexEntries = append(newAtIndexEntries, entry)
}
}
if !added {
newAtIndexEntries = append(newAtIndexEntries, makeAtIdxs(newAtSignIndexes)...)
}
return newAtIndexEntries
}
func makeAtIdxs(idxs []int) []*AtIndexEntry {
result := make([]*AtIndexEntry, len(idxs))
for i, idx := range idxs {
result[i] = &AtIndexEntry{
From: idx,
Checked: false,
}
}
return result
}
// getAtSignIdxs returns the indexes of all @ signs in the text.
// delta is the offset of the text within the original text.
func getAtSignIdxs(text string, delta int) []int {
return getAtSignIdxsHelper(text, delta, 0, []int{})
}
func getAtSignIdxsHelper(text string, delta int, from int, idxs []int) []int {
tr := []rune(text)
idx := strings.IndexRune(string(tr[from:]), '@')
if idx != -1 {
idx = utf8.RuneCountInString(text[:idx])
idx += from
idxs = append(idxs, delta+idx)
return getAtSignIdxsHelper(text, delta, idx+1, idxs)
}
return idxs
}
func checkAtIndexEntry(fullText string, entry *AtIndexEntry, mentionableUsers map[string]*MentionableUser) *AtIndexEntry {
if entry.Checked {
return entry
}
result := MatchMention(fullText, mentionableUsers, entry.From)
if result != nil && result.Match != "" {
return &AtIndexEntry{
From: entry.From,
To: entry.From + len([]rune(result.Match)),
Checked: true,
Mentioned: true,
}
}
return &AtIndexEntry{
From: entry.From,
To: len([]rune(fullText)),
Checked: true,
}
}
func checkIdxForMentions(fullText string, currentAtIndexEntries []*AtIndexEntry, mentionableUsers map[string]*MentionableUser) []*AtIndexEntry {
var newIndexEntries []*AtIndexEntry
for _, entry := range currentAtIndexEntries {
previousEntryIdx := len(newIndexEntries) - 1
newEntry := checkAtIndexEntry(fullText, entry, mentionableUsers)
if previousEntryIdx >= 0 && !newIndexEntries[previousEntryIdx].Mentioned {
newIndexEntries[previousEntryIdx].To = entry.From - 1
}
if previousEntryIdx >= 0 {
newIndexEntries[previousEntryIdx].NextAtIdx = entry.From
}
newEntry.NextAtIdx = intUnknown
newIndexEntries = append(newIndexEntries, newEntry)
}
if len(newIndexEntries) > 0 {
lastIdx := len(newIndexEntries) - 1
if newIndexEntries[lastIdx].Mentioned {
return newIndexEntries
}
newIndexEntries[lastIdx].To = len([]rune(fullText)) - 1
newIndexEntries[lastIdx].Checked = false
return newIndexEntries
}
return nil
}
func appendInputSegment(result *[]InputSegment, typ SegmentType, value string, fullText *string) {
if value != "" {
*result = append(*result, InputSegment{Type: typ, Value: value})
*fullText += value
}
}
func calculateInput(text string, atIndexEntries []*AtIndexEntry) ([]InputSegment, bool) {
if len(atIndexEntries) == 0 {
return []InputSegment{{Type: Text, Value: text}}, true
}
idxCount := len(atIndexEntries)
lastFrom := atIndexEntries[idxCount-1].From
var result []InputSegment
fullText := ""
if atIndexEntries[0].From != 0 {
t := subs(text, 0, atIndexEntries[0].From)
appendInputSegment(&result, Text, t, &fullText)
}
for _, entry := range atIndexEntries {
from := entry.From
to := entry.To
nextAtIdx := entry.NextAtIdx
mentioned := entry.Mentioned
if mentioned && nextAtIdx != intUnknown {
t := subs(text, from, to+1)
appendInputSegment(&result, Mention, t, &fullText)
t = subs(text, to+1, nextAtIdx)
appendInputSegment(&result, Text, t, &fullText)
} else if mentioned && lastFrom == from {
t := subs(text, from, to+1)
appendInputSegment(&result, Mention, t, &fullText)
t = subs(text, to+1)
appendInputSegment(&result, Text, t, &fullText)
} else {
t := subs(text, from, to+1)
appendInputSegment(&result, Text, t, &fullText)
}
}
return result, fullText == text
}
func subs(s string, start int, end ...int) string {
tr := []rune(s)
e := len(tr)
if len(end) > 0 {
e = end[0]
}
if start < 0 {
start = 0
}
if e > len(tr) {
e = len(tr)
}
if e < 0 {
e = 0
}
if start > e {
start, e = e, start
if e > len(tr) {
e = len(tr)
}
}
return string(tr[start:e])
}
func isValidTerminatingCharacter(c rune) bool {
switch c {
case '\t': // tab
return true
case '\n': // newline
return true
case '\f': // new page
return true
case '\r': // carriage return
return true
case ' ': // whitespace
return true
case ',':
return true
case '.':
return true
case ':':
return true
case ';':
return true
default:
return false
}
}
var hexReg = regexp.MustCompile("[0-9a-f]")
func isPublicKeyCharacter(c rune) bool {
return hexReg.MatchString(string(c))
}
const mentionLength = 133
func toInputField(text string) []InputSegment {
// Initialize the variables
currentMentionLength := 0
currentText := ""
currentMention := ""
var inputFieldEntries []InputSegment
// Iterate through each character in the input text
for _, character := range text {
isPKCharacter := isPublicKeyCharacter(character)
isTerminationCharacter := isValidTerminatingCharacter(character)
switch {
// It's a valid mention.
// Add any text that is before if present
// and add the mention.
// Set the text to the new termination character
case currentMentionLength == mentionLength && isTerminationCharacter:
if currentText != "" {
inputFieldEntries = append(inputFieldEntries, InputSegment{Type: Text, Value: currentText})
}
inputFieldEntries = append(inputFieldEntries, InputSegment{Type: Mention, Value: currentMention})
currentMentionLength = 0
currentMention = ""
currentText = string(character)
// It's either a pk character, or the `x` in the pk
// in this case add the text to the mention and continue
case (isPKCharacter && currentMentionLength > 0) || (currentMentionLength == 2 && character == 'x'):
currentMentionLength++
currentMention += string(character)
// The beginning of a mention, discard the @ sign
// and start following a mention
case character == '@':
currentMentionLength = 1
currentMention = ""
// Not a mention character, but we were following a mention
// discard everything up to now and count as text
case !isPKCharacter && currentMentionLength > 0:
currentText += "@" + currentMention + string(character)
currentMentionLength = 0
currentMention = ""
// Just a normal text character
default:
currentText += string(character)
}
}
// Process any remaining mention/text
if currentText != "" {
inputFieldEntries = append(inputFieldEntries, InputSegment{Type: Text, Value: currentText})
}
if currentMentionLength == mentionLength {
inputFieldEntries = append(inputFieldEntries, InputSegment{Type: Mention, Value: currentMention})
}
return inputFieldEntries
}
func toInfo(inputSegments []InputSegment) *MentionState {
newText := ""
state := &MentionState{
AtSignIdx: intUnknown,
End: intUnknown,
AtIdxs: []*AtIndexEntry{},
MentionEnd: 0,
PreviousText: "",
NewText: newText,
Start: intUnknown,
}
for _, segment := range inputSegments {
t := segment.Type
text := segment.Value
tr := []rune(text)
if t == Mention {
newMention := &AtIndexEntry{
Checked: true,
Mentioned: true,
From: state.MentionEnd,
To: state.Start + len(tr),
}
if len(state.AtIdxs) > 0 {
lastIdx := state.AtIdxs[len(state.AtIdxs)-1]
state.AtIdxs = state.AtIdxs[:len(state.AtIdxs)-1]
lastIdx.NextAtIdx = state.MentionEnd
state.AtIdxs = append(state.AtIdxs, lastIdx)
}
state.AtIdxs = append(state.AtIdxs, newMention)
state.AtSignIdx = state.MentionEnd
}
state.MentionEnd += len(tr)
state.NewText = string(tr[len(tr)-1])
state.Start += len(tr)
state.End += len(tr)
}
return state
}
// lastIndexOfAtSign returns the index of the last occurrence of substr in s starting from index start.
// If substr is not present in s, it returns -1.
func lastIndexOfAtSign(s string, start int) int {
if start < 0 {
return -1
}
t := []rune(s)
if start >= len(t) {
start = len(t) - 1
}
// Reverse the input strings to find the first occurrence of the reversed substr in the reversed s.
reversedS := reverse(t[:start+1])
idx := strings.IndexRune(reversedS, '@')
if idx == -1 {
return -1
}
// Calculate the index in the original string.
idx = utf8.RuneCountInString(reversedS[:idx])
return start - idx
}
// reverse returns the reversed string of input s.
func reverse(r []rune) string {
for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
r[i], r[j] = r[j], r[i]
}
return string(r)
}
type textOperation int
const (
textOperationAdd textOperation = iota + 1
textOperationDelete
textOperationReplace
)
type TextDiff struct {
previousText string
newText string // if add operation, newText is the added text; if replace operation, newText is the text used to replace the previousText
start int // start index of the operation relate to previousText
end int // end index of the operation relate to previousText, always the same as start if the operation is add, range: start<=end<=len(previousText)-1
operation textOperation
}
func diffText(oldText, newText string) *TextDiff {
if oldText == newText {
return nil
}
t1 := []rune(oldText)
t2 := []rune(newText)
oldLen := len(t1)
newLen := len(t2)
if oldLen == 0 {
return &TextDiff{previousText: oldText, newText: newText, start: 0, end: 0, operation: textOperationAdd}
}
if newLen == 0 {
return &TextDiff{previousText: oldText, newText: "", start: 0, end: oldLen, operation: textOperationReplace}
}
// if we reach here, t1 and t2 are not empty
start := 0
for start < oldLen && start < newLen && t1[start] == t2[start] {
start++
}
oldEnd, newEnd := oldLen, newLen
for oldEnd > start && newEnd > start && t1[oldEnd-1] == t2[newEnd-1] {
oldEnd--
newEnd--
}
diff := &TextDiff{previousText: oldText, start: start}
if newLen > oldLen && (start == oldLen || oldEnd == 0 || start == oldEnd) {
diff.operation = textOperationAdd
diff.end = start
diff.newText = string(t2[start:newEnd])
} else if newLen < oldLen && (start == newLen || newEnd == 0 || start == newEnd) {
diff.operation = textOperationDelete
diff.end = oldEnd - 1
} else {
diff.operation = textOperationReplace
if start == 0 && oldEnd == oldLen { // full replace
diff.end = oldLen - 1
diff.newText = newText
} else { // partial replace
diff.end = oldEnd - 1
diff.newText = string(t2[start:newEnd])
}
}
return diff
}