Merge pull request #117 from reeflective/dev

fix(display): unify line renderer and restore right-edge wrap handling

Author: maxlandon

internal/display/engine.go

@@ -5,11 +5,9 @@ import (
 	"strings"
 
 	"github.com/reeflective/readline/inputrc"
-	"github.com/reeflective/readline/internal/color"
 	"github.com/reeflective/readline/internal/completion"
 	"github.com/reeflective/readline/internal/core"
 	"github.com/reeflective/readline/internal/history"
-	"github.com/reeflective/readline/internal/strutil"
 	"github.com/reeflective/readline/internal/term"
 	"github.com/reeflective/readline/internal/ui"
 )
@@ -249,51 +247,6 @@ func (e *Engine) computeCoordinates(suggested bool) {
 	e.primaryPrinted = false
 }
 
-func (e *Engine) displayLine() {
-	var line string
-
-	// Apply user-defined highlighter to the input line.
-	if e.highlighter != nil {
-		line = e.highlighter(*e.line)
-	} else {
-		line = string(*e.line)
-	}
-
-	// Highlight matching parenthesis
-	if e.opts.GetBool("blink-matching-paren") {
-		core.HighlightMatchers(e.selection)
-		defer core.ResetMatchers(e.selection)
-	}
-
-	// Apply visual selections highlighting if any
-	line = e.highlightLine([]rune(line), *e.selection)
-
-	// Get the subset of the suggested line to print.
-	suggestionAdded := false
-	if len(e.suggested) > e.line.Len() && e.opts.GetBool("history-autosuggest") {
-		line += color.Dim + color.Fmt(color.Fg+"242") + string(e.suggested[e.line.Len():]) + color.Reset
-		suggestionAdded = true
-	}
-
-	currentLine := string(*e.line)
-	if !suggestionAdded && e.inlineSuggestionApplies(currentLine) {
-		line += color.Dim + color.Fmt(color.Fg+"242") + e.inline[len(currentLine):] + color.Reset
-	}
-
-	// Format tabs as spaces, for consistent display
-	line = strutil.FormatTabs(line) + term.ClearLineAfter
-
-	// And display the line.
-	e.suggested.Set([]rune(line)...)
-	core.DisplayLine(&e.suggested, e.startCols)
-
-	// Adjust the cursor if the line fits exactly in the terminal width.
-	if e.lineCol == 0 {
-		term.WriteString(term.NewlineReturn)
-		term.WriteString(term.ClearLineAfter)
-	}
-}
-
 // AvailableHelperLines returns the number of lines available below the hint section.
 // It returns half the terminal space if we currently have less than 1/3rd of it below.
 func (e *Engine) AvailableHelperLines() int {

internal/display/hint_test.go

@@ -7,6 +7,12 @@ import (
 	"testing"
 )
 
+// compactScreen collapses all runs of whitespace so screen contents can be
+// matched irrespective of terminal padding or soft-wrap column boundaries.
+func compactScreen(screen string) string {
+	return strings.Join(strings.Fields(screen), "")
+}
+
 // rowIndex returns the index of the first screen row containing substr, or -1.
 func rowIndex(screen, substr string) int {
 	for i, row := range strings.Split(screen, "\n") {

internal/display/refresh.go

@@ -114,7 +114,7 @@ func (e *Engine) repaintPromptUpperLines() {
 }
 
 func (e *Engine) renderInputArea() {
-	e.displayLineRefactored()
+	e.displayLine()
 	e.renderMultilineIndicators()
 	e.renderRightPrompt()
 }
@@ -252,7 +252,11 @@ func (e *Engine) ensureInputSpace() {
 	term.MoveCursorForwards(e.startCols)
 }
 
-func (e *Engine) displayLineRefactored() {
+// displayLine renders the input line — highlighting, history-autosuggest and
+// inline-suggestion suffixes, and tab expansion — at the current cursor row. It
+// is the single line renderer shared by the main refresh path (renderInputArea)
+// and the transient-prompt redraw (RefreshTransient).
+func (e *Engine) displayLine() {
 	var line string
 	// Apply user-defined highlighter to the input line.
 	if e.highlighter != nil {
@@ -278,11 +282,26 @@ func (e *Engine) displayLineRefactored() {
 	if !suggestionAdded && e.inlineSuggestionApplies(currentLine) {
 		line += color.Dim + color.Fmt(color.Fg+"242") + e.inline[len(currentLine):] + color.Reset
 	}
-	// Format tabs as spaces, for consistent display
-	line = strutil.FormatTabs(line) + term.ClearLineAfter
+
+	// Format tabs as spaces, for consistent display. When the rendered input
+	// lands exactly on the terminal's right edge (lineCol == 0), the cursor is
+	// left in the terminal's pending-wrap state; emitting clear-to-end-of-line
+	// there can erase the edge glyph, so skip it in that case.
+	wrappedAtRightEdge := e.lineCol == 0 && len(line) > 0
+	line = strutil.FormatTabs(line)
+	if !wrappedAtRightEdge {
+		line += term.ClearLineAfter
+	}
+
 	// And display the line.
 	e.suggested.Set([]rune(line)...)
 	core.DisplayLine(&e.suggested, e.startCols)
+
+	// Force the pending wrap before any later clear/cursor-movement sequences,
+	// so redraws do not overwrite the edge character or scroll one row per key.
+	if wrappedAtRightEdge {
+		term.WriteString(term.NewlineReturn)
+	}
 }
 
 func (e *Engine) renderMultilineIndicators() {

internal/display/render_test.go

@@ -192,3 +192,56 @@ func TestRenderWithCursorProbeDisabled(t *testing.T) {
 		t.Fatalf("row 0 misaligned with probing disabled:\n  got:  %q\n  want: %q", row0, want)
 	}
 }
+
+// TestRenderRightEdgeWrapAtBottomKeepsInputVisiblePerKey guards the common
+// shell position: the prompt is already at the bottom of the terminal, and the
+// typed input soft-wraps at the right edge. Each keypress should keep the
+// current input visible instead of erasing the edge character or scrolling one
+// row per refresh.
+//
+// This is a regression test for the right-edge redraw fix (originally proposed
+// in PR #112 by @rztaylor): the display refactor dropped the pending-wrap
+// handling from the main render path, so typing past the right edge on the last
+// row wedged the redraw.
+func TestRenderRightEdgeWrapAtBottomKeepsInputVisiblePerKey(t *testing.T) {
+	const (
+		cols = 20
+		rows = 8
+	)
+	const prompt = "P> "
+
+	c := startConsole(t, consoleConfig{
+		prompt:  prompt,
+		cols:    cols,
+		rows:    rows,
+		prefill: rows - 1,
+	})
+
+	typed := "abcdefghijklmnopqrstu"
+	firstWrappedInputLen := cols - len(prompt) + 1
+	stableTopRow := -1
+
+	c.waitForScreen(prompt)
+	for idx, ch := range typed {
+		c.send(string(ch))
+		want := typed[:idx+1]
+
+		screen := c.waitUntil(func(screen string) bool {
+			return strings.Contains(compactScreen(screen), "P>"+want)
+		})
+
+		if idx+1 == firstWrappedInputLen {
+			stableTopRow = rowIndex(screen, prompt)
+		}
+		if idx+1 > firstWrappedInputLen {
+			if got := rowIndex(screen, prompt); got != stableTopRow {
+				t.Fatalf("prompt scrolled while typing within the same wrapped row after key %d (%q): prompt row %d, want %d\n%s", idx+1, ch, got, stableTopRow, screen)
+			}
+		}
+	}
+
+	c.send("\r")
+	c.waitUntil(func(screen string) bool {
+		return strings.Contains(compactScreen(screen), "[LINE:"+typed+"]")
+	})
+}