[onechat] / terminal_markdown.go

package main

import (
        "strings"
        "unicode"

        "golang.org/x/text/width"
)

const (
        terminalMarkdownBold = 1 << iota
        terminalMarkdownDim
        terminalMarkdownItalic
        terminalMarkdownReverse
)

// TerminalMarkdownGlyph holds a character, its display width, and its style.
type TerminalMarkdownGlyph struct {
        char    rune
        columns int
        style   int
}

// terminalMarkdown renders Markdown as lines with terminal styles. Width is in
// display columns, with a default of 80. Styles end at each line boundary.
func terminalMarkdown(text string, columns int) []string {
        if columns <= 0 {
                columns = 80
        }

        lines := strings.Split(text, "\n")

        var out []string

        for index := 0; index < len(lines); index++ {
                line := lines[index]
                _, fence := markdownCodeFence(line)
                end := markdownClosingFence(lines, index, fence)
                heading := markdownHeadingText(line)
                switch {
                case end > index:
                        for _, code := range lines[index+1 : end] {
                                out = append(out, terminalMarkdownLines(terminalMarkdownPlain(code, terminalMarkdownDim), columns, "  ", true)...)
                        }

                        index = end
                case strings.TrimSpace(line) == "---":
                        out = append(out, "\x1b[2m"+strings.Repeat("-", columns)+"\x1b[0m")
                case index+1 < len(lines) && terminalMarkdownSeparator(lines[index+1]) && len(terminalMarkdownCells(line)) > 1:
                        rows := [][]string{terminalMarkdownCells(line)}
                        index += 2
                        for index < len(lines) && strings.Contains(lines[index], "|") && strings.TrimSpace(lines[index]) != "" {
                                rows = append(rows, terminalMarkdownCells(lines[index]))
                                index++
                        }

                        index--
                        out = append(out, terminalMarkdownTable(rows, columns)...)
                case heading != "":
                        out = append(out, terminalMarkdownLines(terminalMarkdownInline(heading, terminalMarkdownBold), columns, "", false)...)
                default:
                        prefix, content := terminalMarkdownPrefix(line)
                        out = append(out, terminalMarkdownLines(terminalMarkdownInline(content, 0), columns, prefix, false)...)
                }
        }

        return out
}

// terminalMarkdownLines wraps glyphs with a hanging prefix. Literal lines keep
// their spaces. When a prefix leaves no text column, a list mark gets its own
// line and a quote uses a bar without a space or indent. A quote bar and one
// glyph, or a complete list mark, can exceed a narrower width rather than lose
// text. A wide character stays whole.
func terminalMarkdownLines(glyphs []TerminalMarkdownGlyph, columns int, prefix string, literal bool) []string {
        var out []string

        if len(prefix) >= columns {
                switch {
                case literal:
                        prefix = ""
                case strings.Contains(prefix, "|"):
                        prefix = "|"
                default:
                        out = append(out, strings.TrimSpace(prefix))
                        prefix = ""
                }
        }

        available := max(1, columns-len(prefix))

        parts := terminalMarkdownWrap(glyphs, available, literal)

        for index, part := range parts {
                mark := prefix
                if index > 0 && !literal && !strings.Contains(prefix, "|") {
                        mark = strings.Repeat(" ", len(prefix))
                }

                out = append(out, mark+terminalMarkdownSGR(part))
        }

        return out
}

// terminalMarkdownPlain makes display glyphs without reading inline marks.
// Control characters cannot insert terminal commands. Combining marks take no
// column and East Asian wide and fullwidth characters take two.
func terminalMarkdownPlain(text string, style int) []TerminalMarkdownGlyph {
        var glyphs []TerminalMarkdownGlyph

        for _, char := range strings.ReplaceAll(text, "\t", "    ") {
                if unicode.IsControl(char) {
                        continue
                }

                columns := 1
                switch {
                case unicode.Is(unicode.Mn, char) || unicode.Is(unicode.Me, char) || char == '\u200d':
                        columns = 0
                case width.LookupRune(char).Kind() == width.EastAsianWide || width.LookupRune(char).Kind() == width.EastAsianFullwidth:
                        columns = 2
                }

                glyphs = append(glyphs, TerminalMarkdownGlyph{
                        char:    char,
                        columns: columns,
                        style:   style,
                })
        }

        return glyphs
}

// terminalMarkdownSeparator tells if a line is a Markdown table separator.
func terminalMarkdownSeparator(line string) bool {
        cells := terminalMarkdownCells(line)
        if len(cells) < 2 {
                return false
        }

        for _, cell := range cells {
                cell = strings.Trim(cell, ":")
                if len(cell) < 3 || strings.Trim(cell, "-") != "" {
                        return false
                }
        }

        return true
}

// terminalMarkdownCells splits a row outside code spans and escaped pipes.
func terminalMarkdownCells(line string) []string {
        line = strings.TrimSpace(line)
        line = strings.TrimPrefix(line, "|")
        if strings.HasSuffix(line, "|") && !strings.HasSuffix(line, "\\|") {
                line = strings.TrimSuffix(line, "|")
        }

        var cells []string

        start := 0
        for index := 0; index < len(line); index++ {
                switch line[index] {
                case '\\':
                        index++
                case '`':
                        span, found := markdownCodeSpan(line, index)
                        if found {
                                index = span.end - 1
                        }
                case '|':
                        cells = append(cells, strings.TrimSpace(line[start:index]))
                        start = index + 1
                }
        }

        return append(cells, strings.TrimSpace(line[start:]))
}

// terminalMarkdownTable fits columns to the available width and wraps cells.
// When the separators and one glyph per column cannot fit, cells stack in row
// order.
func terminalMarkdownTable(rows [][]string, columns int) []string {
        count := len(rows[0])

        sizes := make([]int, count)

        minimum := make([]int, count)
        cells := make([][][]TerminalMarkdownGlyph, len(rows))
        for row, values := range rows {
                cells[row] = make([][]TerminalMarkdownGlyph, count)
                for column := range count {
                        value := ""
                        if column < len(values) {
                                value = values[column]
                        }

                        style := 0
                        if row == 0 {
                                style = terminalMarkdownBold
                        }

                        cells[row][column] = terminalMarkdownInline(value, style)

                        sizes[column] = max(sizes[column], terminalMarkdownColumns(cells[row][column]), 1)
                        minimum[column] = max(minimum[column], 1)
                        for _, glyph := range cells[row][column] {
                                minimum[column] = max(minimum[column], glyph.columns)
                        }
                }
        }

        required := (count - 1) * 3
        for _, size := range minimum {
                required += size
        }

        if required > columns {
                var out []string

                for _, row := range cells {
                        for _, cell := range row {
                                out = append(out, terminalMarkdownLines(cell, columns, "", false)...)
                        }
                }

                return out
        }

        budget := columns - (count-1)*3
        for {
                total, largest := 0, 0
                for column, size := range sizes {
                        total += size
                        if size > minimum[column] && (sizes[largest] == minimum[largest] || size > sizes[largest]) {
                                largest = column
                        }
                }

                if total <= budget {
                        break
                }

                sizes[largest]--
        }

        var out []string

        for row, values := range cells {
                wrapped := make([][][]TerminalMarkdownGlyph, count)
                height := 1
                for column, value := range values {
                        wrapped[column] = terminalMarkdownWrap(value, sizes[column], false)
                        height = max(height, len(wrapped[column]))
                }

                for line := range height {
                        parts := make([]string, count)
                        for column := range count {
                                var glyphs []TerminalMarkdownGlyph

                                if line < len(wrapped[column]) {
                                        glyphs = wrapped[column][line]
                                }

                                parts[column] = terminalMarkdownSGR(glyphs) + strings.Repeat(" ", sizes[column]-terminalMarkdownColumns(glyphs))
                        }

                        out = append(out, strings.Join(parts, " | "))
                }

                if row == 0 {
                        rules := make([]string, count)
                        for column, size := range sizes {
                                rules[column] = strings.Repeat("-", size)
                        }

                        out = append(out, "\x1b[2m"+strings.Join(rules, "-+-")+"\x1b[0m")
                }
        }

        return out
}

// terminalMarkdownInline uses the shared marks, so unclosed marks stay as text.
// Strikethrough stays as text because the terminal styles exclude it.
func terminalMarkdownInline(line string, style int) []TerminalMarkdownGlyph {
        var out []TerminalMarkdownGlyph

        for index := 0; index < len(line); {
                if line[index] == '\\' && index+1 < len(line) && strings.IndexByte(markdownPunctuation, line[index+1]) >= 0 {
                        out = append(out, terminalMarkdownPlain(line[index+1:index+2], style)...)
                        index += 2

                        continue
                }

                span, found := markdownMarkSpan(line, index)
                if !found || span.kind == "strikethrough" {
                        end := index + 1
                        for end < len(line) && !strings.ContainsRune("\\`[*_~", rune(line[end])) {
                                end++
                        }

                        out = append(out, terminalMarkdownPlain(line[index:end], style)...)
                        index = end

                        continue
                }

                mark := 0
                switch span.kind {
                case "bold":
                        mark = terminalMarkdownBold
                case "italic":
                        mark = terminalMarkdownItalic
                case "code":
                        mark = terminalMarkdownReverse
                }

                var content []TerminalMarkdownGlyph

                if span.kind == "code" {
                        content = terminalMarkdownPlain(span.content, style|mark)
                } else {
                        content = terminalMarkdownInline(span.content, style|mark)
                }

                out = append(out, content...)
                if span.kind == "text_link" && terminalMarkdownGlyphText(content) != span.url {
                        out = append(out, terminalMarkdownPlain(" ("+span.url+")", style)...)
                }

                index = span.end
        }

        return out
}

// terminalMarkdownPrefix returns the hanging mark of a quote or a list item.
func terminalMarkdownPrefix(line string) (string, string) {
        trimmed := strings.TrimLeft(line, " ")
        indent := line[:len(line)-len(trimmed)]
        if strings.HasPrefix(trimmed, ">") {
                return indent + "| ", strings.TrimPrefix(strings.TrimPrefix(trimmed, ">"), " ")
        }

        if len(trimmed) > 1 && strings.ContainsRune("-*+", rune(trimmed[0])) && trimmed[1] == ' ' {
                return indent + "- ", trimmed[2:]
        }

        digits := 0
        for digits < len(trimmed) && trimmed[digits] >= '0' && trimmed[digits] <= '9' {
                digits++
        }

        if digits > 0 && digits+1 < len(trimmed) && strings.ContainsRune(".)", rune(trimmed[digits])) && trimmed[digits+1] == ' ' {
                return indent + trimmed[:digits+2], trimmed[digits+2:]
        }

        return "", line
}

// terminalMarkdownWrap splits at spaces when possible and otherwise at glyph
// boundaries. It always makes progress, even for a single wide glyph.
func terminalMarkdownWrap(glyphs []TerminalMarkdownGlyph, columns int, literal bool) [][]TerminalMarkdownGlyph {
        var out [][]TerminalMarkdownGlyph

        for len(glyphs) > 0 {
                end, used, space := 0, 0, -1
                for end < len(glyphs) && (used+glyphs[end].columns <= columns || end == 0) {
                        if glyphs[end].char == ' ' {
                                space = end
                        }

                        used += glyphs[end].columns
                        end++
                }

                next := end
                if !literal && end < len(glyphs) && glyphs[end].char != ' ' && space > 0 {
                        end = space
                        next = space + 1
                }

                out = append(out, glyphs[:end])
                glyphs = glyphs[next:]
                if !literal {
                        for len(glyphs) > 0 && glyphs[0].char == ' ' {
                                glyphs = glyphs[1:]
                        }
                }
        }

        if len(out) == 0 {
                out = append(out, nil)
        }

        return out
}

// terminalMarkdownSGR writes only the selected SGR styles and a final reset.
func terminalMarkdownSGR(glyphs []TerminalMarkdownGlyph) string {
        var out strings.Builder

        style := 0
        for _, glyph := range glyphs {
                if glyph.style != style {
                        if style != 0 {
                                out.WriteString("\x1b[0m")
                        }

                        for bit, code := range []string{"1", "2", "3", "7"} {
                                if glyph.style&(1<<bit) != 0 {
                                        out.WriteString("\x1b[" + code + "m")
                                }
                        }

                        style = glyph.style
                }

                out.WriteRune(glyph.char)
        }

        if style != 0 {
                out.WriteString("\x1b[0m")
        }

        return out.String()
}

// terminalMarkdownColumns returns the display width without SGR commands.
func terminalMarkdownColumns(glyphs []TerminalMarkdownGlyph) int {
        columns := 0
        for _, glyph := range glyphs {
                columns += glyph.columns
        }

        return columns
}

// terminalMarkdownGlyphText returns the text without its styles.
func terminalMarkdownGlyphText(glyphs []TerminalMarkdownGlyph) string {
        var out strings.Builder

        for _, glyph := range glyphs {
                out.WriteRune(glyph.char)
        }

        return out.String()
}