internal/suggest/suggest.go

  1// Package suggest reads the replacement lines a review comment proposes
  2// in a fenced suggestion block, and applies them to a file's anchored
  3// line range. The server's apply and the CLI's local apply share it, so
  4// both produce the same bytes.
  5package suggest
  6
  7import (
  8	"bytes"
  9	"errors"
 10	"fmt"
 11	"strings"
 12)
 13
 14// Parse returns the lines of the one ```suggestion block in body. found
 15// is false when there is none. An empty block proposes deleting the
 16// range; a block holding one empty line proposes a blank line.
 17func Parse(body string) (lines []string, found bool, err error) {
 18	start, end, err := locate(body)
 19	if err != nil || start < 0 {
 20		return nil, false, err
 21	}
 22	all := strings.Split(normalize(body), "\n")
 23	return append([]string{}, all[start+1:end]...), true, nil
 24}
 25
 26// Strip returns body without its suggestion block, for rendering the
 27// prose around a suggestion that is shown as a diff instead.
 28func Strip(body string) string {
 29	start, end, err := locate(body)
 30	if err != nil || start < 0 {
 31		return body
 32	}
 33	all := strings.Split(normalize(body), "\n")
 34	return strings.TrimSpace(strings.Join(append(all[:start:start], all[end+1:]...), "\n"))
 35}
 36
 37func normalize(body string) string { return strings.ReplaceAll(body, "\r\n", "\n") }
 38
 39// locate finds the suggestion block's opening and closing fence lines.
 40// start is -1 when there is no block.
 41func locate(body string) (start, end int, err error) {
 42	all := strings.Split(normalize(body), "\n")
 43	start = -1
 44	for i := 0; i < len(all); i++ {
 45		fence, ok := opening(all[i])
 46		if !ok {
 47			continue
 48		}
 49		if start >= 0 {
 50			return -1, -1, errors.New("a comment carries one suggestion block")
 51		}
 52		j := i + 1
 53		for ; j < len(all); j++ {
 54			if closing(all[j], fence) {
 55				break
 56			}
 57		}
 58		if j == len(all) {
 59			return -1, -1, errors.New("the suggestion block is not closed")
 60		}
 61		start, end = i, j
 62		i = j
 63	}
 64	return start, end, nil
 65}
 66
 67// opening reports whether line opens a suggestion block, and the length
 68// of its backtick fence.
 69func opening(line string) (int, bool) {
 70	t := strings.TrimLeft(line, " ")
 71	if len(line)-len(t) > 3 {
 72		return 0, false
 73	}
 74	n := len(t) - len(strings.TrimLeft(t, "`"))
 75	if n < 3 {
 76		return 0, false
 77	}
 78	return n, strings.TrimSpace(t[n:]) == "suggestion"
 79}
 80
 81func closing(line string, fence int) bool {
 82	t := strings.TrimSpace(line)
 83	return len(t) >= fence && strings.Trim(t, "`") == ""
 84}
 85
 86// Text is the replacement as one string, every line ending in a newline:
 87// "" deletes the range and "\n" is one blank line.
 88func Text(lines []string) string {
 89	var b strings.Builder
 90	for _, l := range lines {
 91		b.WriteString(l)
 92		b.WriteByte('\n')
 93	}
 94	return b.String()
 95}
 96
 97// FromText undoes Text.
 98func FromText(s string) []string {
 99	if s == "" {
100		return nil
101	}
102	return strings.Split(strings.TrimSuffix(s, "\n"), "\n")
103}
104
105// split cuts content into lines, each keeping its terminator. The last
106// line has none when the file does not end in a newline.
107func split(content []byte) [][]byte {
108	var out [][]byte
109	for len(content) > 0 {
110		i := bytes.IndexByte(content, '\n')
111		if i < 0 {
112			out = append(out, content)
113			break
114		}
115		out = append(out, content[:i+1])
116		content = content[i+1:]
117	}
118	return out
119}
120
121// Range returns lines start through end (1-based, inclusive) of content
122// with their terminators, and false when the file is shorter than that.
123func Range(content []byte, start, end int) ([]byte, bool) {
124	lines := split(content)
125	if start < 1 || end < start || end > len(lines) {
126		return nil, false
127	}
128	return bytes.Join(lines[start-1:end], nil), true
129}
130
131// Apply replaces lines start through end of content with repl. The
132// replacement takes the line ending the file uses there, CRLF or LF, and
133// the last replacement line keeps whatever ended the range, so a range
134// at the end of a file with no final newline still has none.
135func Apply(content []byte, start, end int, repl []string) ([]byte, error) {
136	lines := split(content)
137	if start < 1 || end < start {
138		return nil, fmt.Errorf("bad line range %d-%d", start, end)
139	}
140	if end > len(lines) {
141		return nil, fmt.Errorf("the file has %d lines; the suggestion ends at line %d", len(lines), end)
142	}
143	last := lines[end-1]
144	eol, lastEOL := []byte("\n"), []byte{}
145	switch {
146	case bytes.HasSuffix(last, []byte("\r\n")):
147		eol, lastEOL = []byte("\r\n"), []byte("\r\n")
148	case bytes.HasSuffix(last, []byte("\n")):
149		lastEOL = []byte("\n")
150	case end > 1 && bytes.HasSuffix(lines[end-2], []byte("\r\n")):
151		eol = []byte("\r\n")
152	}
153	var b bytes.Buffer
154	for _, l := range lines[:start-1] {
155		b.Write(l)
156	}
157	for i, r := range repl {
158		b.WriteString(r)
159		if i == len(repl)-1 {
160			b.Write(lastEOL)
161		} else {
162			b.Write(eol)
163		}
164	}
165	for _, l := range lines[end:] {
166		b.Write(l)
167	}
168	return b.Bytes(), nil
169}
170
171// Message is the commit message of an applied suggestion, naming the
172// merge request and the thread. The server and the CLI's local apply
173// both write it.
174func Message(repoPath string, mr, thread int64, author string) string {
175	return fmt.Sprintf("Apply suggestion from %s\n\nThread %d on %s!%d.\n", author, thread, repoPath, mr)
176}