2020-06-18 20:54:48 +00:00
|
|
|
// Package renderer provides functions to convert various data into a cview primitive.
|
|
|
|
// Example objects include a Gemini response, and an error.
|
|
|
|
//
|
|
|
|
// Rendered lines always end with \r\n, in an effort to be Window compatible.
|
|
|
|
package renderer
|
|
|
|
|
|
|
|
import (
|
2020-07-28 20:58:32 +00:00
|
|
|
"fmt"
|
2020-06-18 20:54:48 +00:00
|
|
|
urlPkg "net/url"
|
2020-09-04 16:42:01 +00:00
|
|
|
"regexp"
|
2020-06-18 20:54:48 +00:00
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
|
2020-07-28 20:58:32 +00:00
|
|
|
"github.com/makeworld-the-better-one/amfora/config"
|
2020-06-18 20:54:48 +00:00
|
|
|
"github.com/spf13/viper"
|
|
|
|
"gitlab.com/tslocum/cview"
|
|
|
|
)
|
|
|
|
|
2020-09-04 16:42:01 +00:00
|
|
|
// Regex for identifying ANSI color codes
|
|
|
|
var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;]*m`)
|
|
|
|
|
2020-07-10 21:45:14 +00:00
|
|
|
// RenderANSI renders plain text pages containing ANSI codes.
|
|
|
|
// Practically, it is used for the text/x-ansi.
|
|
|
|
func RenderANSI(s string, leftMargin int) string {
|
|
|
|
s = cview.Escape(s)
|
2020-09-04 16:42:01 +00:00
|
|
|
if viper.GetBool("a-general.color") && viper.GetBool("a-general.ansi") {
|
2020-07-10 21:45:14 +00:00
|
|
|
s = cview.TranslateANSI(s)
|
2020-09-04 16:42:01 +00:00
|
|
|
} else {
|
|
|
|
s = ansiRegex.ReplaceAllString(s, "")
|
2020-07-10 21:45:14 +00:00
|
|
|
}
|
|
|
|
var shifted string
|
|
|
|
lines := strings.Split(s, "\n")
|
|
|
|
for i := range lines {
|
|
|
|
shifted += strings.Repeat(" ", leftMargin) + lines[i] + "\n"
|
|
|
|
}
|
|
|
|
return shifted
|
|
|
|
}
|
|
|
|
|
2020-07-03 21:28:56 +00:00
|
|
|
// RenderPlainText should be used to format plain text pages.
|
|
|
|
func RenderPlainText(s string, leftMargin int) string {
|
|
|
|
var shifted string
|
|
|
|
lines := strings.Split(cview.Escape(s), "\n")
|
|
|
|
for i := range lines {
|
2020-07-28 20:58:32 +00:00
|
|
|
shifted += strings.Repeat(" ", leftMargin) +
|
|
|
|
"[" + config.GetColorString("regular_text") + "]" + lines[i] + "[-]" +
|
|
|
|
"\n"
|
2020-07-03 21:28:56 +00:00
|
|
|
}
|
|
|
|
return shifted
|
|
|
|
}
|
|
|
|
|
2020-07-03 18:02:33 +00:00
|
|
|
// wrapLine wraps a line to the provided width, and adds the provided prefix and suffix to each wrapped line.
|
|
|
|
// It recovers from wrapping panics and should never cause a panic.
|
|
|
|
// It returns a slice of lines, without newlines at the end.
|
|
|
|
//
|
|
|
|
// Set includeFirst to true if the prefix and suffix should be applied to the first wrapped line as well
|
|
|
|
func wrapLine(line string, width int, prefix, suffix string, includeFirst bool) []string {
|
|
|
|
// Anonymous function to allow recovery from potential WordWrap panic
|
|
|
|
var ret []string
|
|
|
|
func() {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
// Use unwrapped line instead
|
|
|
|
if includeFirst {
|
|
|
|
ret = []string{prefix + line + suffix}
|
|
|
|
} else {
|
|
|
|
ret = []string{line}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
wrapped := cview.WordWrap(line, width)
|
|
|
|
for i := range wrapped {
|
|
|
|
if !includeFirst && i == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
wrapped[i] = prefix + wrapped[i] + suffix
|
|
|
|
}
|
|
|
|
ret = wrapped
|
|
|
|
}()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
2020-06-18 20:54:48 +00:00
|
|
|
// convertRegularGemini converts non-preformatted blocks of text/gemini
|
|
|
|
// into a cview-compatible format.
|
2020-09-01 20:41:30 +00:00
|
|
|
// Since this only works on non-preformatted blocks, RenderGemini
|
|
|
|
// should always be used instead.
|
|
|
|
//
|
2020-06-18 20:54:48 +00:00
|
|
|
// It also returns a slice of link URLs.
|
|
|
|
// numLinks is the number of links that exist so far.
|
2020-06-21 20:53:12 +00:00
|
|
|
// width is the number of columns to wrap to.
|
2020-06-18 20:54:48 +00:00
|
|
|
//
|
2020-09-01 20:41:30 +00:00
|
|
|
//
|
|
|
|
// proxied is whether the request is through the gemini:// scheme.
|
|
|
|
// If it's not a gemini:// page, set this to true.
|
|
|
|
func convertRegularGemini(s string, numLinks, width int, proxied bool) (string, []string) {
|
2020-06-18 20:54:48 +00:00
|
|
|
links := make([]string, 0)
|
|
|
|
lines := strings.Split(s, "\n")
|
|
|
|
wrappedLines := make([]string, 0) // Final result
|
|
|
|
|
|
|
|
for i := range lines {
|
|
|
|
lines[i] = strings.TrimRight(lines[i], " \r\t\n")
|
|
|
|
|
2020-08-28 16:22:49 +00:00
|
|
|
if strings.HasPrefix(lines[i], "#") {
|
2020-06-18 20:54:48 +00:00
|
|
|
// Headings
|
2020-07-28 20:58:32 +00:00
|
|
|
var tag string
|
2020-06-24 16:01:09 +00:00
|
|
|
if viper.GetBool("a-general.color") {
|
2020-08-28 16:22:49 +00:00
|
|
|
if strings.HasPrefix(lines[i], "###") {
|
2020-07-28 20:58:32 +00:00
|
|
|
tag = fmt.Sprintf("[%s::b]", config.GetColorString("hdg_3"))
|
2020-07-03 18:02:33 +00:00
|
|
|
} else if strings.HasPrefix(lines[i], "##") {
|
2020-07-28 20:58:32 +00:00
|
|
|
tag = fmt.Sprintf("[%s::b]", config.GetColorString("hdg_2"))
|
2020-07-03 18:02:33 +00:00
|
|
|
} else if strings.HasPrefix(lines[i], "#") {
|
2020-07-28 20:58:32 +00:00
|
|
|
tag = fmt.Sprintf("[%s::b]", config.GetColorString("hdg_1"))
|
2020-06-24 16:01:09 +00:00
|
|
|
}
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedLines = append(wrappedLines, wrapLine(lines[i], width, tag, "[-::-]", true)...)
|
2020-06-24 16:01:09 +00:00
|
|
|
} else {
|
|
|
|
// Just bold, no colors
|
2020-07-03 18:02:33 +00:00
|
|
|
wrappedLines = append(wrappedLines, wrapLine(lines[i], width, "[::b]", "[-::-]", true)...)
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Links
|
|
|
|
} else if strings.HasPrefix(lines[i], "=>") && len([]rune(lines[i])) >= 3 {
|
|
|
|
// Trim whitespace and separate link from link text
|
|
|
|
|
|
|
|
lines[i] = strings.Trim(lines[i][2:], " \t") // Remove `=>` part too
|
|
|
|
delim := strings.IndexAny(lines[i], " \t") // Whitespace between link and link text
|
|
|
|
|
|
|
|
var url string
|
|
|
|
var linkText string
|
|
|
|
if delim == -1 {
|
|
|
|
// No link text
|
|
|
|
url = lines[i]
|
|
|
|
linkText = url
|
|
|
|
} else {
|
|
|
|
// There is link text
|
|
|
|
url = lines[i][:delim]
|
|
|
|
linkText = strings.Trim(lines[i][delim:], " \t")
|
2020-12-01 19:00:01 +00:00
|
|
|
if viper.GetBool("a-general.show_link") {
|
|
|
|
linkText += " (" + url + ")"
|
|
|
|
}
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if strings.TrimSpace(lines[i]) == "" || strings.TrimSpace(url) == "" {
|
|
|
|
// Link was just whitespace, reset it and move on
|
|
|
|
lines[i] = "=>"
|
|
|
|
wrappedLines = append(wrappedLines, lines[i])
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
links = append(links, url)
|
2020-08-05 00:44:43 +00:00
|
|
|
num := numLinks + len(links) // Visible link number, one-indexed
|
|
|
|
|
|
|
|
var indent int
|
|
|
|
if num > 99 {
|
|
|
|
// Indent link text by 3 or more spaces
|
|
|
|
indent = len(strconv.Itoa(num)) + 4 // +4 indent for spaces and brackets
|
|
|
|
} else {
|
|
|
|
// One digit and two digit links have the same spacing - see #60
|
|
|
|
indent = 5 // +4 indent for spaces and brackets, and 1 for link number
|
|
|
|
}
|
|
|
|
|
|
|
|
// Spacing after link number: 1 or 2 spaces?
|
|
|
|
var spacing string
|
|
|
|
if num > 9 {
|
|
|
|
// One space to keep it in line with other links - see #60
|
|
|
|
spacing = " "
|
|
|
|
} else {
|
|
|
|
// One digit numbers use two spaces
|
|
|
|
spacing = " "
|
|
|
|
}
|
2020-06-18 20:54:48 +00:00
|
|
|
|
2020-07-03 18:02:33 +00:00
|
|
|
// Wrap and add link text
|
|
|
|
// Wrap the link text, but add some spaces to indent the wrapped lines past the link number
|
|
|
|
// Set the style tags
|
|
|
|
// Add them to the first line
|
|
|
|
|
2020-07-09 19:21:09 +00:00
|
|
|
var wrappedLink []string
|
|
|
|
|
2020-06-18 20:54:48 +00:00
|
|
|
if viper.GetBool("a-general.color") {
|
2020-06-24 00:07:25 +00:00
|
|
|
pU, err := urlPkg.Parse(url)
|
2020-09-01 20:41:30 +00:00
|
|
|
if !proxied && err == nil &&
|
|
|
|
(pU.Scheme == "" || pU.Scheme == "gemini" || pU.Scheme == "about") {
|
2020-06-18 20:54:48 +00:00
|
|
|
// A gemini link
|
|
|
|
// Add the link text in blue (in a region), and a gray link number to the left of it
|
2020-07-28 20:58:32 +00:00
|
|
|
// Those are the default colors, anyway
|
2020-07-09 19:21:09 +00:00
|
|
|
|
|
|
|
wrappedLink = wrapLine(linkText, width,
|
2020-08-05 00:44:43 +00:00
|
|
|
strings.Repeat(" ", indent)+
|
|
|
|
`["`+strconv.Itoa(num-1)+`"][`+config.GetColorString("amfora_link")+`]`,
|
2020-07-09 19:21:09 +00:00
|
|
|
`[-][""]`,
|
|
|
|
false, // Don't indent the first line, it's the one with link number
|
|
|
|
)
|
|
|
|
|
|
|
|
// Add special stuff to first line, like the link number
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedLink[0] = fmt.Sprintf(`[%s::b][`, config.GetColorString("link_number")) +
|
2020-08-05 00:44:43 +00:00
|
|
|
strconv.Itoa(num) + "[]" + "[-::-]" + spacing +
|
|
|
|
`["` + strconv.Itoa(num-1) + `"][` + config.GetColorString("amfora_link") + `]` +
|
2020-07-09 19:21:09 +00:00
|
|
|
wrappedLink[0] + `[-][""]`
|
2020-06-18 20:54:48 +00:00
|
|
|
} else {
|
2020-07-28 20:58:32 +00:00
|
|
|
// Not a gemini link
|
2020-07-09 19:21:09 +00:00
|
|
|
|
|
|
|
wrappedLink = wrapLine(linkText, width,
|
2020-08-05 00:44:43 +00:00
|
|
|
strings.Repeat(" ", indent)+
|
|
|
|
`["`+strconv.Itoa(num-1)+`"][`+config.GetColorString("foreign_link")+`]`,
|
2020-07-09 19:21:09 +00:00
|
|
|
`[-][""]`,
|
|
|
|
false, // Don't indent the first line, it's the one with link number
|
|
|
|
)
|
|
|
|
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedLink[0] = fmt.Sprintf(`[%s::b][`, config.GetColorString("link_number")) +
|
2020-08-05 00:44:43 +00:00
|
|
|
strconv.Itoa(num) + "[]" + "[-::-]" + spacing +
|
|
|
|
`["` + strconv.Itoa(num-1) + `"][` + config.GetColorString("foreign_link") + `]` +
|
2020-07-09 19:21:09 +00:00
|
|
|
wrappedLink[0] + `[-][""]`
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
} else {
|
2020-07-28 20:58:32 +00:00
|
|
|
// No colors allowed
|
2020-07-09 19:21:09 +00:00
|
|
|
|
|
|
|
wrappedLink = wrapLine(linkText, width,
|
2020-08-05 00:44:43 +00:00
|
|
|
strings.Repeat(" ", len(strconv.Itoa(num))+4)+ // +4 for spaces and brackets
|
|
|
|
`["`+strconv.Itoa(num-1)+`"]`,
|
2020-07-09 19:21:09 +00:00
|
|
|
`[""]`,
|
|
|
|
false, // Don't indent the first line, it's the one with link number
|
|
|
|
)
|
|
|
|
|
2020-08-05 00:44:43 +00:00
|
|
|
wrappedLink[0] = `[::b][` + strconv.Itoa(num) + "[][::-] " +
|
|
|
|
`["` + strconv.Itoa(num-1) + `"]` +
|
2020-07-09 19:21:09 +00:00
|
|
|
wrappedLink[0] + `[""]`
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
|
2020-07-03 18:02:33 +00:00
|
|
|
wrappedLines = append(wrappedLines, wrappedLink...)
|
|
|
|
|
2020-06-18 20:54:48 +00:00
|
|
|
// Lists
|
|
|
|
} else if strings.HasPrefix(lines[i], "* ") {
|
|
|
|
if viper.GetBool("a-general.bullets") {
|
2020-07-03 18:02:33 +00:00
|
|
|
// Wrap list item, and indent wrapped lines past the bullet
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedItem := wrapLine(lines[i][1:], width,
|
|
|
|
fmt.Sprintf(" [%s]", config.GetColorString("list_text")),
|
|
|
|
"[-]", false)
|
2020-07-03 18:02:33 +00:00
|
|
|
// Add bullet
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedItem[0] = fmt.Sprintf(" [%s]\u2022", config.GetColorString("list_text")) +
|
|
|
|
wrappedItem[0] + "[-]"
|
2020-07-03 18:02:33 +00:00
|
|
|
wrappedLines = append(wrappedLines, wrappedItem...)
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
// Optionally list lines could be colored here too, if color is enabled
|
2020-07-03 18:02:33 +00:00
|
|
|
} else if strings.HasPrefix(lines[i], ">") {
|
|
|
|
// It's a quote line, add extra quote symbols and italics to the start of each wrapped line
|
2020-06-18 20:54:48 +00:00
|
|
|
|
2020-12-20 22:52:06 +00:00
|
|
|
if len(lines[i]) == 1 {
|
|
|
|
// Just an empty quote line
|
|
|
|
wrappedLines = append(wrappedLines, fmt.Sprintf("[%s::i]>[-::-]", config.GetColorString("quote_text")))
|
|
|
|
} else {
|
|
|
|
// Remove beginning quote and maybe space
|
|
|
|
lines[i] = strings.TrimPrefix(lines[i], ">")
|
|
|
|
lines[i] = strings.TrimPrefix(lines[i], " ")
|
|
|
|
wrappedLines = append(wrappedLines,
|
|
|
|
wrapLine(lines[i], width, fmt.Sprintf("[%s::i]> ", config.GetColorString("quote_text")),
|
|
|
|
"[-::-]", true)...,
|
|
|
|
)
|
|
|
|
}
|
2020-06-18 20:54:48 +00:00
|
|
|
|
2020-07-03 18:02:33 +00:00
|
|
|
} else if strings.TrimSpace(lines[i]) == "" {
|
2020-06-18 20:54:48 +00:00
|
|
|
// Just add empty line without processing
|
|
|
|
wrappedLines = append(wrappedLines, "")
|
|
|
|
} else {
|
2020-07-03 18:02:33 +00:00
|
|
|
// Regular line, just wrap it
|
2020-07-28 20:58:32 +00:00
|
|
|
wrappedLines = append(wrappedLines, wrapLine(lines[i], width,
|
|
|
|
fmt.Sprintf("[%s]", config.GetColorString("regular_text")),
|
|
|
|
"[-]", true)...)
|
2020-06-18 20:54:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return strings.Join(wrappedLines, "\r\n"), links
|
|
|
|
}
|
|
|
|
|
2020-06-21 20:53:12 +00:00
|
|
|
// RenderGemini converts text/gemini into a cview displayable format.
|
2020-06-18 20:54:48 +00:00
|
|
|
// It also returns a slice of link URLs.
|
2020-07-03 03:55:24 +00:00
|
|
|
//
|
|
|
|
// width is the number of columns to wrap to.
|
|
|
|
// leftMargin is the number of blank spaces to prepend to each line.
|
2020-09-01 20:41:30 +00:00
|
|
|
//
|
|
|
|
// proxied is whether the request is through the gemini:// scheme.
|
|
|
|
// If it's not a gemini:// page, set this to true.
|
|
|
|
func RenderGemini(s string, width, leftMargin int, proxied bool) (string, []string) {
|
2020-06-18 20:54:48 +00:00
|
|
|
s = cview.Escape(s)
|
2020-09-04 16:42:01 +00:00
|
|
|
|
2020-06-18 20:54:48 +00:00
|
|
|
lines := strings.Split(s, "\n")
|
|
|
|
|
|
|
|
links := make([]string, 0)
|
|
|
|
|
|
|
|
// Process and wrap non preformatted lines
|
|
|
|
rendered := "" // Final result
|
|
|
|
pre := false
|
|
|
|
buf := "" // Block of regular or preformatted lines
|
|
|
|
for i := range lines {
|
|
|
|
if strings.HasPrefix(lines[i], "```") {
|
|
|
|
if pre {
|
|
|
|
// In a preformatted block, so add the text as is
|
|
|
|
// Don't add the current line with backticks
|
2020-11-05 01:31:04 +00:00
|
|
|
|
|
|
|
// Support ANSI color codes in preformatted blocks - see #59
|
|
|
|
if viper.GetBool("a-general.color") && viper.GetBool("a-general.ansi") {
|
|
|
|
buf = cview.TranslateANSI(buf)
|
|
|
|
} else {
|
|
|
|
buf = ansiRegex.ReplaceAllString(buf, "")
|
|
|
|
}
|
|
|
|
|
|
|
|
rendered += fmt.Sprintf("[%s]", config.GetColorString("preformatted_text")) +
|
|
|
|
buf + "[-]"
|
2020-06-18 20:54:48 +00:00
|
|
|
} else {
|
|
|
|
// Not preformatted, regular text
|
2020-11-05 01:31:04 +00:00
|
|
|
|
|
|
|
// ANSI not allowed in regular text - see #59
|
|
|
|
buf = ansiRegex.ReplaceAllString(buf, "")
|
|
|
|
|
2020-09-01 20:41:30 +00:00
|
|
|
ren, lks := convertRegularGemini(buf, len(links), width, proxied)
|
2020-06-18 20:54:48 +00:00
|
|
|
links = append(links, lks...)
|
|
|
|
rendered += ren
|
|
|
|
}
|
|
|
|
buf = "" // Clear buffer for next block
|
|
|
|
pre = !pre
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// Lines always end with \r\n for Windows compatibility
|
|
|
|
buf += strings.TrimSuffix(lines[i], "\r") + "\r\n"
|
|
|
|
}
|
|
|
|
// Gone through all the lines, but there still is likely a block in the buffer
|
|
|
|
if pre {
|
|
|
|
// File ended without closing the preformatted block
|
2020-11-05 01:31:04 +00:00
|
|
|
// Same code as in the loop above
|
|
|
|
|
|
|
|
if viper.GetBool("a-general.color") && viper.GetBool("a-general.ansi") {
|
|
|
|
buf = cview.TranslateANSI(buf)
|
|
|
|
} else {
|
|
|
|
buf = ansiRegex.ReplaceAllString(buf, "")
|
|
|
|
}
|
|
|
|
rendered += fmt.Sprintf("[%s]", config.GetColorString("preformatted_text")) +
|
|
|
|
buf + "[-]"
|
2020-06-18 20:54:48 +00:00
|
|
|
} else {
|
|
|
|
// Not preformatted, regular text
|
|
|
|
// Same code as in the loop above
|
2020-11-05 01:31:04 +00:00
|
|
|
|
|
|
|
buf = ansiRegex.ReplaceAllString(buf, "")
|
|
|
|
|
2020-09-01 20:41:30 +00:00
|
|
|
ren, lks := convertRegularGemini(buf, len(links), width, proxied)
|
2020-06-18 20:54:48 +00:00
|
|
|
links = append(links, lks...)
|
|
|
|
rendered += ren
|
|
|
|
}
|
|
|
|
|
2020-07-03 03:55:24 +00:00
|
|
|
if leftMargin > 0 {
|
|
|
|
renLines := strings.Split(rendered, "\n")
|
|
|
|
for i := range renLines {
|
|
|
|
renLines[i] = strings.Repeat(" ", leftMargin) + renLines[i]
|
|
|
|
}
|
|
|
|
return strings.Join(renLines, "\n"), links
|
|
|
|
}
|
|
|
|
|
2020-06-18 20:54:48 +00:00
|
|
|
return rendered, links
|
|
|
|
}
|