refactor(uninterpreted): pass delimiter to IsComplete and DRY readUninterpreted

Change UninterpretedConfig.IsComplete to func(accumulated, delimiter
string) bool so the callback receives the delimiter currently in effect
without the consumer having to capture the shell. Collapse the duplicated
terminator logic in readUninterpreted into a single predicate plus a
lineIsComplete helper, and make readMultiLinesFunc delegate to
readMultiLinesAccumFunc to remove the duplicated accumulation loop.

Refs: dolthub/dolt#10866

Author: codeaucafe

ishell.go

@@ -65,7 +65,7 @@ type Shell struct {
 	specialTerminators []string
 	backSlashCmds      []string
 	quitKeywords       []string
-	isComplete         func(accumulated string) bool
+	isComplete         func(accumulated, delimiter string) bool
 	contextValues
 	Actions
 }
@@ -81,14 +81,10 @@ type UninterpretedConfig struct {
 	BackSlashCmds []string
 	// Quit keywords to exit the shell if discovered
 	QuitKeywords []string
-	// IsComplete, when non-nil, replaces the per-line LineTerminator suffix
-	// check in readUninterpreted. It is called after each physical line is
-	// read with the cumulative buffer (lines joined by "\n", matching the
-	// final delivered string). Returning true ends accumulation. Special
-	// terminators, backslash commands, and quit keywords still apply on top
-	// of IsComplete; first-line DELIMITER detection and the leading "--"
-	// short-circuit also still apply.
-	IsComplete func(accumulated string) bool
+	// IsComplete, when set, replaces the LineTerminator suffix check: it is
+	// called with the cumulative buffer and current delimiter and returns true
+	// when accumulation should stop.
+	IsComplete func(accumulated, delimiter string) bool
 }
 
 // New creates a new shell with default settings. Uses standard output and default prompt ">> ".
@@ -376,72 +372,24 @@ func (s *Shell) readUninterpreted() (string, error) {
 
 	if s.lineTerminator != "" {
 		firstLine := true
-		if s.isComplete != nil {
-			lines, err = s.readMultiLinesAccumFunc(func(line, accumulated string) (keepReading bool) {
-				if firstLine {
-					firstLine = false
-					if matches := delimiterRegex.FindStringSubmatch(line); len(matches) == 2 {
-						s.lineTerminator = matches[1]
-						return false
-					}
-					if strings.HasPrefix(line, "--") {
-						return false
-					}
-					for _, keyword := range s.quitKeywords {
-						if strings.TrimSpace(line) == keyword {
-							return false
-						}
-					}
-				}
-
-				for _, sc := range s.specialTerminators {
-					if strings.HasSuffix(strings.TrimSpace(line), sc) {
-						return false
-					}
-				}
-				for _, sc := range s.backSlashCmds {
-					if strings.HasPrefix(strings.TrimSpace(line), sc) {
-						return false
-					}
-				}
-
-				return !s.isComplete(accumulated)
-			})
-		} else {
-			lines, err = s.readMultiLinesFunc(func(line string) (keepReading bool) {
-				if firstLine {
-					firstLine = false
-					if matches := delimiterRegex.FindStringSubmatch(line); len(matches) == 2 {
-						s.lineTerminator = matches[1]
-						return false
-					}
-					if strings.HasPrefix(line, "--") {
-						return false
-					}
-					for _, keyword := range s.quitKeywords {
-						if strings.TrimSpace(line) == keyword {
-							return false
-						}
-					}
-				}
-
-				if strings.HasSuffix(strings.TrimSpace(line), s.lineTerminator) {
+		lines, err = s.readMultiLinesAccumFunc(func(line, accumulated string) (keepReading bool) {
+			if firstLine {
+				firstLine = false
+				if matches := delimiterRegex.FindStringSubmatch(line); len(matches) == 2 {
+					s.lineTerminator = matches[1]
 					return false
 				}
-				for _, sc := range s.specialTerminators {
-					if strings.HasSuffix(strings.TrimSpace(line), sc) {
-						return false
-					}
+				if strings.HasPrefix(line, "--") {
+					return false
 				}
-				for _, sc := range s.backSlashCmds {
-					if strings.HasPrefix(strings.TrimSpace(line), sc) {
+				for _, keyword := range s.quitKeywords {
+					if strings.TrimSpace(line) == keyword {
 						return false
 					}
 				}
-
-				return true
-			})
-		}
+			}
+			return !s.lineIsComplete(line, accumulated)
+		})
 
 		if err != nil {
 			return "", err
@@ -480,6 +428,27 @@ func (s *Shell) readUninterpreted() (string, error) {
 	return lines, nil
 }
 
+// lineIsComplete reports whether reading should stop: special terminators and
+// backslash commands always end input, otherwise it defers to IsComplete or the
+// line-terminator suffix check.
+func (s *Shell) lineIsComplete(line, accumulated string) bool {
+	trimmed := strings.TrimSpace(line)
+	for _, sc := range s.specialTerminators {
+		if strings.HasSuffix(trimmed, sc) {
+			return true
+		}
+	}
+	for _, sc := range s.backSlashCmds {
+		if strings.HasPrefix(trimmed, sc) {
+			return true
+		}
+	}
+	if s.isComplete != nil {
+		return s.isComplete(accumulated, s.lineTerminator)
+	}
+	return strings.HasSuffix(trimmed, s.lineTerminator)
+}
+
 func (s *Shell) read() ([]string, error) {
 	s.rawArgs = nil
 	eof := ""
@@ -526,44 +495,21 @@ func (s *Shell) read() ([]string, error) {
 }
 
 func (s *Shell) readMultiLinesFunc(f func(string) (keepReading bool)) (string, error) {
-	var lines bytes.Buffer
-	currentLine := 0
-	var err error
-	for {
-		if currentLine == 1 {
-			// from second line, enable next line prompt.
-			s.reader.setMultiMode(true)
-		}
-		var line string
-		line, err = s.readLine()
-		fmt.Fprint(&lines, line)
-		if !f(line) || err != nil {
-			break
-		}
-		fmt.Fprintln(&lines)
-		currentLine++
-	}
-	if currentLine > 0 {
-		// if more than one line is read
-		// revert to standard prompt.
-		s.reader.setMultiMode(false)
-	}
-	return lines.String(), err
+	return s.readMultiLinesAccumFunc(func(line, _ string) bool {
+		return f(line)
+	})
 }
 
-// readMultiLinesAccumFunc is a sibling of readMultiLinesFunc that passes
-// both the most recent physical line and the cumulative buffer to the
-// predicate. The cumulative buffer matches what readMultiLinesFunc would
-// produce: physical lines joined by "\n" with no trailing newline on the
-// terminating line.
+// readMultiLinesAccumFunc accumulates physical lines until the predicate
+// returns false. The predicate receives the latest line and the cumulative
+// buffer (lines joined by "\n").
 func (s *Shell) readMultiLinesAccumFunc(f func(line, accumulated string) (keepReading bool)) (string, error) {
 	return readMultiLinesAccumFromReader(s.readLine, s.reader.setMultiMode, f)
 }
 
-// readMultiLinesAccumFromReader is the inner accumulation loop used by
-// readMultiLinesAccumFunc. It is parameterized on the line reader and the
-// multi-mode toggle so unit tests can drive it without a real readline
-// instance.
+// readMultiLinesAccumFromReader is the inner accumulation loop, parameterized
+// on the line reader and multi-mode toggle so tests can drive it without a real
+// readline instance.
 func readMultiLinesAccumFromReader(
 	readLine func() (string, error),
 	setMulti func(bool),