gotextlog

domain.go (8620B)

---

 // Package domain contains pure application behavior shared by the TUI screens.
 package domain
 
 import (
 	"regexp"
 	"sort"
 	"strings"
 	"time"
 	"unicode"
 	"unicode/utf8"
 
 	"git.ryansepassi.com/git/gotextlog.git/internal/textlog"
 )
 
 const (
 	MaxPostCharacters = 280
 	MaxPostLines      = 10
 )
 
 // CodePointLength follows JavaScript's Array.from string length semantics for
 // valid UTF-8: a Unicode code point counts as one character.
 func CodePointLength(value string) int {
 	return utf8.RuneCountInString(value)
 }
 
 // ValidatePost returns a user-facing problem, or an empty string when valid.
 func ValidatePost(value string) string {
 	if strings.TrimFunc(value, func(character rune) bool {
 		return unicode.IsSpace(character) || character == '\uFEFF'
 	}) == "" {
 		return "Write something first"
 	}
 	if CodePointLength(value) > MaxPostCharacters {
 		return "Notes can be at most 280 characters"
 	}
 	if strings.Count(value, "\n")+1 > MaxPostLines {
 		return "Notes can be at most 10 lines"
 	}
 	return ""
 }
 
 // RelativeTime formats an RFC 3339 timestamp relative to now.
 func RelativeTime(value string, now time.Time) string {
 	created, err := time.Parse(time.RFC3339Nano, value)
 	if err != nil {
 		return ""
 	}
 	seconds := int64(now.Sub(created).Seconds())
 	if seconds < 0 {
 		seconds = 0
 	}
 	switch {
 	case seconds < 60:
 		return formatInteger(seconds) + "s"
 	case seconds < 60*60:
 		return formatInteger(seconds/60) + "m"
 	case seconds < 24*60*60:
 		return formatInteger(seconds/(60*60)) + "h"
 	case seconds < 30*24*60*60:
 		return formatInteger(seconds/(24*60*60)) + "d"
 	default:
 		return created.UTC().Format("2006-01-02")
 	}
 }
 
 func formatInteger(value int64) string {
 	if value == 0 {
 		return "0"
 	}
 	var digits [20]byte
 	index := len(digits)
 	for value > 0 {
 		index--
 		digits[index] = byte(value%10) + '0'
 		value /= 10
 	}
 	return string(digits[index:])
 }
 
 // Redact replaces every occurrence of token without changing tokenless text.
 func Redact(value, token string) string {
 	if token == "" {
 		return value
 	}
 	return strings.ReplaceAll(value, token, "[redacted]")
 }
 
 type TokenKind string
 
 const (
 	TokenText      TokenKind = "text"
 	TokenCode      TokenKind = "code"
 	TokenLink      TokenKind = "link"
 	TokenReference TokenKind = "reference"
 )
 
 type RichToken struct {
 	Kind TokenKind
 	Text string
 	URL  string
 }
 
 const (
 	inlineCodePattern    = "`[^`\n]+`"
 	javascriptWhitespace = `\t\n\v\f\r \x{00A0}\x{1680}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}\x{FEFF}`
 	markdownPattern      = `\[(?:\\[^\n]|[^\]\\\n])+\]\((?:https?://)?[^` + javascriptWhitespace + `)]+\)`
 	webURLPattern        = `https?://[^` + javascriptWhitespace + `]+`
 	domainPattern        = `(?:www\.)?[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z]{2,})(?:/[^` + javascriptWhitespace + `]*)?`
 	referencePattern     = `[#@][A-Za-z0-9_]+`
 )
 
 var (
 	richTextPattern = regexp.MustCompile("(?i)(" + strings.Join([]string{
 		inlineCodePattern,
 		markdownPattern,
 		webURLPattern,
 		domainPattern,
 		referencePattern,
 	}, "|") + ")")
 	markdownLinkPattern = regexp.MustCompile(`^\[((?:\\[^\n]|[^\]\\\n])+)\]\(([^)]+)\)$`)
 	asciiArtBodyPattern = regexp.MustCompile(`(?i)(^|[` + javascriptWhitespace + `])#(?:ascii|ascii_art)\b`)
 	markdownUnescaper   = strings.NewReplacer(`\\`, `\`, `\[`, `[`, `\]`, `]`)
 )
 
 // TokenizeRichText recognizes inline code, markdown links, bare web URLs,
 // domain names, mentions, and hashtags. Inline code wins over link parsing.
 func TokenizeRichText(body string) []RichToken {
 	matches := richTextPattern.FindAllStringIndex(body, -1)
 	if len(matches) == 0 {
 		if body == "" {
 			return []RichToken{}
 		}
 		return []RichToken{{Kind: TokenText, Text: body}}
 	}
 
 	tokens := make([]RichToken, 0, len(matches)*2+1)
 	offset := 0
 	for _, match := range matches {
 		if match[0] > offset {
 			tokens = append(tokens, RichToken{Kind: TokenText, Text: body[offset:match[0]]})
 		}
 		value := body[match[0]:match[1]]
 		switch {
 		case strings.HasPrefix(value, "`"):
 			tokens = append(tokens, RichToken{Kind: TokenCode, Text: value})
 		case strings.HasPrefix(value, "["):
 			parts := markdownLinkPattern.FindStringSubmatch(value)
 			if len(parts) != 3 {
 				tokens = append(tokens, RichToken{Kind: TokenText, Text: value})
 				break
 			}
 			tokens = append(tokens, RichToken{
 				Kind: TokenLink,
 				Text: markdownUnescaper.Replace(parts[1]),
 				URL:  absoluteWebURL(parts[2]),
 			})
 		case value[0] == '#' || value[0] == '@':
 			tokens = append(tokens, RichToken{Kind: TokenReference, Text: value})
 		default:
 			tokens = append(tokens, RichToken{Kind: TokenLink, Text: value, URL: absoluteWebURL(value)})
 		}
 		offset = match[1]
 	}
 	if offset < len(body) {
 		tokens = append(tokens, RichToken{Kind: TokenText, Text: body[offset:]})
 	}
 	return tokens
 }
 
 func absoluteWebURL(value string) string {
 	lower := strings.ToLower(value)
 	if strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://") {
 		return value
 	}
 	return "https://" + value
 }
 
 // TerminalSafeText normalizes line endings and tab stops and removes emoji
 // skin-tone modifiers that some terminals incorrectly render as wide glyphs.
 func TerminalSafeText(value string) string {
 	value = strings.ReplaceAll(value, "\r\n", "\n")
 	value = strings.ReplaceAll(value, "\r", "\n")
 
 	const tabWidth = 4
 	var safe strings.Builder
 	safe.Grow(len(value))
 	column := 0
 	for _, character := range value {
 		switch {
 		case character == '\n':
 			safe.WriteRune(character)
 			column = 0
 		case character >= '\U0001F3FB' && character <= '\U0001F3FF':
 			// Intentionally omitted from terminal output.
 		case character == '\t':
 			spaces := tabWidth - column%tabWidth
 			safe.WriteString(strings.Repeat(" ", spaces))
 			column += spaces
 		default:
 			safe.WriteRune(character)
 			column++
 		}
 	}
 	return safe.String()
 }
 
 // IsASCIIArt reports whether tags or an in-body hashtag request literal mode.
 func IsASCIIArt(body string, tags []string) bool {
 	for _, tag := range tags {
 		tag = strings.ToLower(strings.TrimPrefix(tag, "#"))
 		if tag == "ascii" || tag == "ascii_art" {
 			return true
 		}
 	}
 	return asciiArtBodyPattern.MatchString(body)
 }
 
 func IsASCIIArtPost(post textlog.Post) bool {
 	return IsASCIIArt(post.Body, post.Tags)
 }
 
 // ClampSelection keeps a list selection in range, with zero representing an
 // empty list as well as its first item.
 func ClampSelection(current, length int) int {
 	if current < 0 || length <= 0 {
 		return 0
 	}
 	if current >= length {
 		return length - 1
 	}
 	return current
 }
 
 type ThreadItem struct {
 	Post      textlog.Post
 	Depth     int
 	MoreCount int
 }
 
 // BuildReplyThread orders each set of siblings from oldest to newest and
 // places a reply's descendants immediately after it. Orphans remain visible,
 // and duplicate IDs and cycles cannot duplicate posts or recurse indefinitely.
 func BuildReplyThread(root textlog.Post, replies []textlog.Reply) []ThreadItem {
 	type candidate struct {
 		reply textlog.Reply
 		index int
 	}
 	byParent := make(map[int][]candidate)
 	unique := make([]candidate, 0, len(replies))
 	known := map[int]bool{root.ID: true}
 	for i, reply := range replies {
 		if known[reply.ID] {
 			continue
 		}
 		known[reply.ID] = true
 		item := candidate{reply: reply, index: i}
 		unique = append(unique, item)
 		if reply.ParentID != nil {
 			byParent[*reply.ParentID] = append(byParent[*reply.ParentID], item)
 		}
 	}
 	older := func(left, right candidate) bool {
 		leftTime, rightTime := left.reply.CreatedAt, right.reply.CreatedAt
 		if leftTime.Equal(rightTime) {
 			return left.index < right.index
 		}
 		return leftTime.Before(rightTime)
 	}
 	sort.SliceStable(unique, func(i, j int) bool { return older(unique[i], unique[j]) })
 	for parentID := range byParent {
 		children := byParent[parentID]
 		sort.SliceStable(children, func(i, j int) bool { return older(children[i], children[j]) })
 		byParent[parentID] = children
 	}
 
 	thread := []ThreadItem{{Post: root}}
 	emitted := map[int]bool{root.ID: true}
 	var appendReply func(candidate, int)
 	appendReply = func(item candidate, depth int) {
 		if emitted[item.reply.ID] {
 			return
 		}
 		emitted[item.reply.ID] = true
 		if depth < 1 {
 			depth = 1
 		}
 		moreCount := 0
 		if len(byParent[item.reply.ID]) == 0 {
 			moreCount = item.reply.ReplyCount
 		}
 		thread = append(thread, ThreadItem{Post: item.reply.Post, Depth: depth, MoreCount: moreCount})
 		for _, child := range byParent[item.reply.ID] {
 			appendReply(child, depth+1)
 		}
 	}
 	for _, child := range byParent[root.ID] {
 		appendReply(child, 1)
 	}
 	for _, item := range unique {
 		depth := item.reply.Depth
 		if depth < 1 {
 			depth = 1
 		}
 		appendReply(item, depth)
 	}
 	return thread
 }