package main
import (
"bufio"
"errors"
"flag"
"fmt"
"io"
"os"
"regexp"
"strings"
"github.com/mattn/go-runewidth"
)
type paragraph struct {
// email quote prefix, if any
quotes string
// list item indent, if any
leader string
// actual text of this paragraph
text string
// percentage of letters in text
proseRatio int
// text ends with a space
flowed bool
// paragraph is a list item
listItem bool
}
func main() {
var err error
var width int
var reflow bool
var file string
var proseRatio int
var input *os.File
fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
fs.IntVar(&width, "w", 80, "preferred wrap margin")
fs.BoolVar(&reflow, "r", false,
"reflow all paragraphs even if no trailing space")
fs.IntVar(&proseRatio, "l", 50,
"minimum percentage of letters in a line to be considered a paragaph")
fs.StringVar(&file, "f", "", "read from file instead of stdin")
_ = fs.Parse(os.Args[1:])
if file != "" {
input, err = os.OpenFile(file, os.O_RDONLY, 0o644)
if err != nil {
goto end
}
} else {
input = os.Stdin
}
err = wrap(input, os.Stdout, width, reflow, proseRatio)
end:
if err != nil && !errors.Is(err, io.EOF) {
fmt.Fprintf(os.Stderr, "error: %s\n", err)
os.Exit(1)
}
}
func wrap(
in io.Reader, out io.Writer, width int, reflow bool, proseRatio int,
) error {
var para *paragraph = nil
var line string
var err error
if patchSubjectRe.MatchString(os.Getenv("AERC_SUBJECT")) {
// never reflow patches
_, err = io.Copy(out, in)
} else {
reader := bufio.NewReader(in)
line, err = reader.ReadString('\n')
for ; err == nil; line, err = reader.ReadString('\n') {
next := parse(line)
switch {
case para == nil:
para = next
case para.isContinuation(next, reflow, proseRatio):
para.join(next)
default:
para.write(out, width, proseRatio)
para = next
}
}
if para != nil {
para.write(out, width, proseRatio)
}
}
return err
}
// Parse a line of text into a paragraph structure
func parse(line string) *paragraph {
p := new(paragraph)
q := 0
t := 0
line = strings.TrimRight(line, "\r\n")
// tabs cause a whole lot of troubles, replace them with 8 spaces
line = strings.ReplaceAll(line, "\t", " ")
// Use integer offsets to find relevant positions in the line
//
// > > > 2) blah blah blah blah
// ^--------+-----^
// q | t
// end of quotes | start of text
// |
// list item leader
// detect the end of quotes prefix if any
for q < len(line) && line[q] == '>' {
q += 1
if q < len(line) && line[q] == ' ' {
q += 1
}
}
// detect list item leader
loc := listItemRe.FindStringIndex(line[q:])
if loc != nil {
// start of list item
p.listItem = true
} else {
// maybe list item continuation
loc = leadingSpaceRe.FindStringIndex(line[q:])
}
if loc != nil {
t = q + loc[1]
} else {
// no list at all
t = q
}
// check if there is trailing whitespace, indicating format=flowed
loc = trailingSpaceRe.FindStringIndex(line[t:])
if loc != nil {
p.flowed = true
// trim whitespace
line = line[:t+loc[0]]
}
p.quotes = line[:q]
p.leader = strings.Repeat(" ", runewidth.StringWidth(line[q:t]))
p.text = line[q:]
// compute the ratio of letters in the actual text
onlyLetters := strings.TrimLeft(line[q:], " ")
totalLen := runewidth.StringWidth(onlyLetters)
if totalLen == 0 {
// to avoid division by zero
totalLen = 1
}
onlyLetters = notLetterRe.ReplaceAllLiteralString(onlyLetters, "")
p.proseRatio = 100 * runewidth.StringWidth(onlyLetters) / totalLen
return p
}
// Return true if a paragraph is a continuation of the current one.
func (p *paragraph) isContinuation(
next *paragraph, reflow bool, proseRatio int,
) bool {
switch {
case next.listItem:
// new list items always start a new paragraph
return false
case next.proseRatio < proseRatio || p.proseRatio < proseRatio:
// does not look like prose, maybe ascii art
return false
case next.quotes != p.quotes || next.leader != p.leader:
// quote level and/or list item leader have changed
return false
case len(strings.Trim(next.text, " ")) == 0:
// empty line
return false
case p.flowed:
// current paragraph has trailing space, indicating
// format=flowed
return true
case reflow:
// user forced paragraph reflow on the command line
return true
default:
return false
}
}
// Join next paragraph into current one.
func (p *paragraph) join(next *paragraph) {
if p.text == "" {
p.text = next.text
} else {
p.text = p.text + " " + strings.Trim(next.text, " ")
}
p.proseRatio = (p.proseRatio + next.proseRatio) / 2
p.flowed = next.flowed
}
// Write a paragraph, wrapping at words boundaries.
//
// Only try to do word wrapping on things that look like prose. When the text
// contains too many non-letter characters, print it as-is.
func (p *paragraph) write(out io.Writer, margin int, proseRatio int) {
leader := ""
more := true
quotesWidth := runewidth.StringWidth(p.quotes)
for more {
var line string
width := quotesWidth + runewidth.StringWidth(leader)
remain := runewidth.StringWidth(p.text)
if width+remain <= margin || p.proseRatio < proseRatio {
// whole paragraph fits on a single line
line = p.text
p.text = ""
more = false
} else {
// find split point, preferably before margin
split := -1
w := 0
for i, r := range p.text {
w += runewidth.RuneWidth(r)
if width+w > margin && split != -1 {
break
}
if r == ' ' {
split = i
}
}
if split == -1 {
// no space found to split, print a long line
line = p.text
p.text = ""
more = false
} else {
line = p.text[:split]
// find start of next word
for split < len(p.text) && p.text[split] == ' ' {
split++
}
if split < len(p.text) {
p.text = p.text[split:]
} else {
// only trailing whitespace, we're done
p.text = ""
more = false
}
}
}
fmt.Fprintf(out, "%s%s%s\n", p.quotes, leader, line)
leader = p.leader
}
}
var (
patchSubjectRe = regexp.MustCompile(`\bPATCH\b`)
listItemRe = regexp.MustCompile(`^\s*([\-\*\.]|[a-z\d]{1,2}[\)\]\.])\s+`)
leadingSpaceRe = regexp.MustCompile(`^\s+`)
trailingSpaceRe = regexp.MustCompile(`\s+$`)
notLetterRe = regexp.MustCompile(`[^\pL]`)
)
