Files
pipelines/internal/turn/output.go
T

171 lines
4.6 KiB
Go

package turn
import (
"errors"
"fmt"
"strings"
)
var (
// ErrEmptyOutput means the turn produced no markdown at all.
ErrEmptyOutput = errors.New("turn output: empty")
// ErrMissingOutcome means no outcome heading and value were found.
ErrMissingOutcome = errors.New("turn output: missing outcome")
// ErrDuplicateOutcome means more than one outcome heading was found.
ErrDuplicateOutcome = errors.New("turn output: duplicate outcome")
// ErrOutcomeNotAllowed means the value was not one of the declared words.
ErrOutcomeNotAllowed = errors.New("turn output: outcome not allowed")
)
// ParseOutput extracts the single outcome section from a turn's markdown.
//
// A heading whose text is "outcome" (any ATX level) is followed by the first
// non-blank line, which must contain exactly one allowed word. Matching is
// trim-and-lower-case, and the canonical spelling from allowedOutcomes is
// returned. Everything after that value line is the body, preserved byte for
// byte. Text before the outcome heading is ignored. Headings and values inside
// fenced code blocks are never considered.
func ParseOutput(markdown string, allowedOutcomes []string) (Outcome string, Body string, err error) {
if strings.TrimSpace(markdown) == "" {
return "", "", ErrEmptyOutput
}
lines := markdownLines(markdown)
var headings []int
var fence fenceState
for i, line := range lines {
if fence.open() {
if fence.closes(line.text) {
fence = fenceState{}
}
continue
}
if marker, ok := openingFence(line.text); ok {
fence = marker
continue
}
if isOutcomeHeading(line.text) {
headings = append(headings, i)
}
}
switch len(headings) {
case 0:
return "", "", ErrMissingOutcome
case 1:
default:
return "", "", fmt.Errorf("%w: found %d outcome headings", ErrDuplicateOutcome, len(headings))
}
heading := headings[0]
value := heading + 1
for value < len(lines) && strings.TrimSpace(lines[value].text) == "" {
value++
}
if value == len(lines) {
return "", "", fmt.Errorf("%w: outcome heading has no value", ErrMissingOutcome)
}
word := strings.TrimSpace(lines[value].text)
canonical, ok := allowedOutcome(word, allowedOutcomes)
if !ok {
return "", "", fmt.Errorf("%w: %q", ErrOutcomeNotAllowed, word)
}
return canonical, markdown[lines[value].next:], nil
}
func allowedOutcome(word string, outcomes []string) (string, bool) {
key := strings.ToLower(word)
for _, outcome := range outcomes {
outcome = strings.TrimSpace(outcome)
if outcome != "" && strings.ToLower(outcome) == key {
return outcome, true
}
}
return "", false
}
type markdownLine struct {
text string
next int
}
// markdownLines records each line's content without its line ending and the
// byte position immediately after that line ending. Body slices therefore keep
// CRLF and every other byte exactly as supplied.
func markdownLines(markdown string) []markdownLine {
lines := make([]markdownLine, 0, strings.Count(markdown, "\n")+1)
for start := 0; start < len(markdown); {
next := len(markdown)
text := markdown[start:]
if relative := strings.IndexByte(markdown[start:], '\n'); relative >= 0 {
next = start + relative + 1
text = markdown[start : start+relative]
}
lines = append(lines, markdownLine{
text: strings.TrimSuffix(text, "\r"),
next: next,
})
if next == len(markdown) {
break
}
start = next
}
return lines
}
func isOutcomeHeading(text string) bool {
text = strings.TrimSpace(text)
hashes := 0
for hashes < len(text) && text[hashes] == '#' {
hashes++
}
if hashes == 0 || hashes == len(text) {
return false
}
// Markdown ATX headings require whitespace between the marker and text.
if text[hashes] != ' ' && text[hashes] != '\t' {
return false
}
return strings.EqualFold(strings.TrimSpace(text[hashes:]), "outcome")
}
type fenceState struct {
char byte
length int
}
func (f fenceState) open() bool {
return f.length > 0
}
func (f fenceState) closes(text string) bool {
char, length, ok := fenceMarker(text)
if !ok || char != f.char || length < f.length {
return false
}
trimmed := strings.TrimLeft(text, " \t")
return strings.TrimSpace(trimmed[length:]) == ""
}
func openingFence(text string) (fenceState, bool) {
char, length, ok := fenceMarker(text)
if !ok {
return fenceState{}, false
}
return fenceState{char: char, length: length}, true
}
func fenceMarker(text string) (byte, int, bool) {
trimmed := strings.TrimLeft(text, " \t")
if len(trimmed) < 3 || (trimmed[0] != '`' && trimmed[0] != '~') {
return 0, 0, false
}
char := trimmed[0]
length := 0
for length < len(trimmed) && trimmed[length] == char {
length++
}
if length < 3 {
return 0, 0, false
}
return char, length, true
}