Rewrite README.md sentence by sentence (closes #190)

README.md is rewritten from scratch against the rules on issue 190 and
checked statement by statement against the code on next. It leads with
what the program is and how to use it, puts every endpoint, command,
numeric reply, mode and setting in reference sections, and ends with
development and testing. Where the old text disagreed with the code,
the code decides; the PR body lists each case. The hashcash examples
are real 20-bit stamps. REPO_POLICIES.md and CONVENTIONS.md are copies
of shared documents and are untouched.

Model: fable-5-1

internal/cli/app.go

@@ -34,42 +34,28 @@ type App struct {
 
 // Run creates and runs the CLI application.
 func Run() {
-	err := run(NewUI())
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-// run starts the client on ui and returns when ui stops. Tests
-// call it with ui on a simulation screen.
-func run(ui *UI) error {
 	app := &App{ //nolint:exhaustruct
-		ui:   ui,
+		ui:   NewUI(),
 		nick: "guest",
 	}
 
 	app.ui.OnInput(app.handleInput)
+	app.ui.SetStatus(app.nick, "", "disconnected")
 
-	// SetStatus and AddStatus wait for the event loop, which
-	// app.ui.Run starts below, so they run on a goroutine. The
-	// nick is read first, as a typed /nick may change app.nick.
-	nick := app.nick
+	app.ui.AddStatus(
+		"Welcome to neoirc-cli — an IRC-style client",
+	)
+	app.ui.AddStatus(
+		"Type [yellow]/connect <server-url>" +
+			"[white] to begin, " +
+			"or [yellow]/help[white] for commands",
+	)
 
-	go func() {
-		app.ui.SetStatus(nick, "", "disconnected")
-
-		app.ui.AddStatus(
-			"Welcome to neoirc-cli — an IRC-style client",
-		)
-		app.ui.AddStatus(
-			"Type [yellow]/connect <server-url>" +
-				"[white] to begin, " +
-				"or [yellow]/help[white] for commands",
-		)
-	}()
-
-	return app.ui.Run()
+	err := app.ui.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
 }
 
 func (a *App) handleInput(text string) {
@@ -199,21 +185,11 @@ func (a *App) cmdConnect(serverURL string) {
 		return
 	}
 
-	// The poll loop of an earlier connection is stopped in the same
-	// step that replaces the client, so it never polls with the new
-	// one.
 	a.mu.Lock()
 	a.client = client
 	a.nick = resp.Nick
 	a.connected = true
 	a.lastQID = 0
-
-	if a.stopPoll != nil {
-		close(a.stopPoll)
-	}
-
-	stop := make(chan struct{})
-	a.stopPoll = stop
 	a.mu.Unlock()
 
 	a.ui.AddStatus(fmt.Sprintf(
@@ -222,7 +198,9 @@ func (a *App) cmdConnect(serverURL string) {
 	))
 	a.ui.SetStatus(resp.Nick, "", "connected")
 
-	go a.pollLoop(stop)
+	a.stopPoll = make(chan struct{})
+
+	go a.pollLoop()
 }
 
 func (a *App) cmdNick(nick string) {
@@ -632,37 +610,24 @@ func (a *App) cmdWindow(args string) {
 
 	_, _ = fmt.Sscanf(args, "%d", &bufIndex)
 
+	a.ui.SwitchBuffer(bufIndex)
+
 	a.mu.Lock()
 	nick := a.nick
-	connected := a.connected
 	a.mu.Unlock()
 
-	connStatus := "disconnected"
-	if connected {
-		connStatus = "connected"
-	}
-
-	// Read the name before switching. A message from the server can
-	// add a buffer at any time, but only at the end, so bufIndex
-	// still names this buffer when SwitchBuffer runs.
-	name, found := a.ui.BufferName(bufIndex)
-	if found {
-		a.ui.SwitchBuffer(bufIndex)
-
-		if name != "(status)" {
+	if bufIndex >= 0 && bufIndex < a.ui.BufferCount() {
+		buf := a.ui.buffers[bufIndex]
+		if buf.Name != "(status)" {
 			a.mu.Lock()
-			a.target = name
+			a.target = buf.Name
 			a.mu.Unlock()
 
 			a.ui.SetStatus(
-				nick, name, connStatus,
+				nick, buf.Name, "connected",
 			)
 		} else {
-			a.mu.Lock()
-			a.target = ""
-			a.mu.Unlock()
-
-			a.ui.SetStatus(nick, "", connStatus)
+			a.ui.SetStatus(nick, "", "connected")
 		}
 	}
 }
@@ -710,23 +675,16 @@ func (a *App) cmdHelp() {
 	}
 }
 
-// pollLoop long-polls for messages in the background until stop is
-// closed. A later /connect closes stop under a.mu as it replaces the
-// client and the cursor, so the loop checks stop under a.mu too. A
-// stopped loop then neither polls with the new client nor moves the
-// new cursor.
-func (a *App) pollLoop(stop <-chan struct{}) {
+// pollLoop long-polls for messages in the background.
+func (a *App) pollLoop() {
 	for {
-		a.mu.Lock()
-
 		select {
-		case <-stop:
-			a.mu.Unlock()
-
+		case <-a.stopPoll:
 			return
 		default:
 		}
 
+		a.mu.Lock()
 		client := a.client
 		lastQID := a.lastQID
 		a.mu.Unlock()
@@ -744,24 +702,12 @@ func (a *App) pollLoop(stop <-chan struct{}) {
 			continue
 		}
 
-		// A poll sent before stop was closed answers for the earlier
-		// connection.
-		a.mu.Lock()
-
-		select {
-		case <-stop:
-			a.mu.Unlock()
-
-			return
-		default:
-		}
-
 		if result.LastID > 0 {
+			a.mu.Lock()
 			a.lastQID = result.LastID
+			a.mu.Unlock()
 		}
 
-		a.mu.Unlock()
-
 		for i := range result.Messages {
 			a.handleServerMessage(&result.Messages[i])
 		}

internal/cli/app_internal_test.go

@@ -4,10 +4,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
-	"slices"
-	"strings"
 	"testing"
-	"time"
 
 	"github.com/gdamore/tcell/v2"
 	api "sneak.berlin/go/neoirc/internal/cli/api"
@@ -23,24 +20,6 @@ const (
 	testText      = "hello"
 )
 
-// eventLoopTimeout is how long a test waits for a typed line to
-// be handled, for the welcome lines, or for the UI to stop, before
-// it fails.
-const eventLoopTimeout = 5 * time.Second
-
-// holdTime is how long a test waits to see that something does not
-// happen: the second line handled while the first is held, or a
-// poll from a poll loop that was stopped.
-const holdTime = 200 * time.Millisecond
-
-// welcomeLines is the number of lines run adds to the status
-// window when the client starts.
-const welcomeLines = 2
-
-// checkInterval is how often TestStartUp reads the status window
-// while it waits for the welcome lines.
-const checkInterval = 10 * time.Millisecond
-
 func TestMemberPrefix(t *testing.T) {
 	t.Parallel()
 
@@ -240,400 +219,6 @@ func TestJoinResponse(t *testing.T) {
 	}
 }
 
-// TestAltDigit checks that Alt and a digit shows that window and
-// makes its channel or user the target, as /window does. Window
-// 0, the status window, leaves no target.
-func TestAltDigit(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name  string
-		digit rune
-		// The buffer shown and the target after the key.
-		wantBuffer string
-		wantTarget string
-	}{
-		{
-			name:       "channel window",
-			digit:      '1',
-			wantBuffer: testChannel,
-			wantTarget: testChannel,
-		},
-		{
-			name:       "status window",
-			digit:      '0',
-			wantBuffer: "(status)",
-			wantTarget: "",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			t.Parallel()
-
-			app := &App{ui: NewUI(), nick: testNick, target: testOtherNick}
-			handled := handledLines(app)
-			runUI(t, app.ui)
-
-			// Window 1 is the channel. Window 2, the one shown, is
-			// the other user's.
-			app.ui.SwitchToBuffer(testChannel)
-			app.ui.SwitchToBuffer(testOtherNick)
-
-			key := tcell.NewEventKey(tcell.KeyRune, test.digit, tcell.ModAlt)
-			app.ui.app.QueueEvent(key)
-			waitHandled(t, handled, "/window "+string(test.digit))
-
-			var shown string
-
-			app.ui.app.QueueUpdate(func() {
-				shown = app.ui.buffers[app.ui.currentBuffer].Name
-			})
-
-			if shown != test.wantBuffer || app.target != test.wantTarget {
-				t.Fatalf("got buffer %s and target %q, want %s and %q",
-					shown, app.target, test.wantBuffer, test.wantTarget)
-			}
-		})
-	}
-}
-
-// TestWindowConnectionState checks that typing /window 0, or
-// pressing Alt and 0, leaves the status bar showing [connected]
-// only while the client is connected, and [disconnected] otherwise.
-func TestWindowConnectionState(t *testing.T) {
-	t.Parallel()
-
-	const line = "/window 0"
-
-	typeLine := func(ui *UI) {
-		for _, r := range line {
-			ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, r, tcell.ModNone))
-		}
-
-		ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyEnter, 0, tcell.ModNone))
-	}
-
-	pressAltZero := func(ui *UI) {
-		ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, '0', tcell.ModAlt))
-	}
-
-	tests := []struct {
-		name      string
-		send      func(ui *UI)
-		connected bool
-		want      string
-	}{
-		{
-			name: "typed line, not connected", send: typeLine,
-			connected: false, want: "[disconnected]",
-		},
-		{
-			name: "Alt and 0, not connected", send: pressAltZero,
-			connected: false, want: "[disconnected]",
-		},
-		{
-			name: "typed line, connected", send: typeLine,
-			connected: true, want: "[connected]",
-		},
-		{
-			name: "Alt and 0, connected", send: pressAltZero,
-			connected: true, want: "[connected]",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			t.Parallel()
-
-			app := &App{ui: NewUI(), nick: testNick, connected: test.connected}
-			handled := handledLines(app)
-			runUI(t, app.ui)
-
-			test.send(app.ui)
-			waitHandled(t, handled, line)
-
-			status := statusBarText(app.ui)
-			if !strings.Contains(status, test.want) {
-				t.Fatalf("status bar is %q, want it to show %s", status, test.want)
-			}
-		})
-	}
-}
-
-// TestEventLoopKeepsRunning sends Alt and 1, then a typed line and
-// Enter, to a running UI. It checks that both are handled, so the
-// event loop did not stop on either.
-func TestEventLoopKeepsRunning(t *testing.T) {
-	t.Parallel()
-
-	app := &App{ui: NewUI(), nick: testNick}
-	handled := handledLines(app)
-	runUI(t, app.ui)
-
-	// Window 1 is the channel, and window 0, the status window, is
-	// shown. The typed line adds a line to the status window, as
-	// the client is not connected.
-	app.ui.SwitchToBuffer(testChannel)
-	app.ui.SwitchBuffer(0)
-
-	app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, '1', tcell.ModAlt))
-
-	for _, r := range testText {
-		app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, r, tcell.ModNone))
-	}
-
-	app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyEnter, 0, tcell.ModNone))
-
-	waitHandled(t, handled, "/window 1")
-	waitHandled(t, handled, testText)
-}
-
-// TestLinesKeepOrder holds the handling of a first line until a
-// second line has been passed in. It fails if the second line is
-// handled while the first is still held.
-func TestLinesKeepOrder(t *testing.T) {
-	t.Parallel()
-
-	const firstLine, secondLine = "one", "two"
-
-	ui := NewUI()
-	handled := make(chan string)
-	release := make(chan struct{})
-
-	ui.OnInput(func(text string) {
-		if text == firstLine {
-			<-release
-		}
-
-		handled <- text
-	})
-
-	ui.callOnInput(firstLine)
-	ui.callOnInput(secondLine)
-
-	select {
-	case got := <-handled:
-		t.Fatalf("handled %q while the first line was held", got)
-	case <-time.After(holdTime):
-	}
-
-	close(release)
-	waitHandled(t, handled, firstLine)
-	waitHandled(t, handled, secondLine)
-}
-
-// TestSecondConnectStopsFirstPollLoop connects to one server, then
-// to a second that holds every poll. Only the second connection's
-// poll loop may poll the second server.
-func TestSecondConnectStopsFirstPollLoop(t *testing.T) {
-	t.Parallel()
-
-	const session = `{"id": 1, "nick": "erin"}`
-
-	// The first server answers every request at once, so the first
-	// poll loop polls it until the second /connect.
-	first := newServer(t, session)
-
-	// The second server sends on polled for each poll and holds the
-	// poll until its connection closes. It answers anything else
-	// with the session.
-	polled := make(chan struct{})
-	second := httptest.NewServer(http.HandlerFunc(
-		func(writer http.ResponseWriter, request *http.Request) {
-			if request.Method != http.MethodGet ||
-				request.URL.Path != "/api/v1/messages" {
-				_, _ = io.WriteString(writer, session)
-
-				return
-			}
-
-			select {
-			case polled <- struct{}{}:
-			case <-request.Context().Done():
-			}
-
-			<-request.Context().Done()
-		},
-	))
-	// Close waits for the held polls, which end only once their
-	// connections close. Cleanups run last first, so the connections
-	// close before Close runs.
-	t.Cleanup(second.Close)
-	t.Cleanup(second.CloseClientConnections)
-
-	app := &App{ui: NewUI(), nick: testNick}
-	runUI(t, app.ui)
-
-	app.cmdConnect(first.URL)
-	app.cmdConnect(second.URL)
-
-	select {
-	case <-polled:
-	case <-time.After(eventLoopTimeout):
-		t.Fatalf("the second server got no poll within %v", eventLoopTimeout)
-	}
-
-	// The second connection's poll loop waits on its held poll, so
-	// another poll comes from the first loop.
-	select {
-	case <-polled:
-		t.Fatal("the first poll loop polled again after the second /connect")
-	case <-time.After(holdTime):
-	}
-
-	// Stop the second poll loop as /quit does. /quit itself also
-	// stops the UI, and runUI's cleanup stopping it again is a data
-	// race inside tview.
-	app.mu.Lock()
-	close(app.stopPoll)
-	app.mu.Unlock()
-}
-
-// TestStartUp runs the client's start-up path on a simulation
-// screen. It fails unless the event loop starts and the status
-// window gets two lines: first the one that holds "Welcome to
-// neoirc-cli", then the /connect hint. The status bar must show
-// [disconnected].
-func TestStartUp(t *testing.T) {
-	t.Parallel()
-
-	ui := NewUI()
-	ui.app.SetScreen(tcell.NewSimulationScreen(""))
-
-	// One slot, so that run's goroutine can end even after the
-	// cleanup below has stopped waiting for it.
-	done := make(chan error, 1)
-
-	go func() { done <- run(ui) }()
-
-	t.Cleanup(func() {
-		ui.Stop()
-
-		select {
-		case err := <-done:
-			if err != nil {
-				t.Errorf("run: %v", err)
-			}
-		case <-time.After(eventLoopTimeout):
-			t.Error("run did not return after the UI was stopped")
-		}
-	})
-
-	// run adds the welcome lines on a goroutine, so the status
-	// window is read until it holds two lines. Each read waits for
-	// the event loop, so the reads run on a goroutine too, which
-	// this test stops waiting for after eventLoopTimeout. The
-	// channel has one slot, so that goroutine can still end.
-	shown := make(chan []string, 1)
-
-	go func() {
-		for {
-			var lines []string
-
-			ui.app.QueueUpdate(func() {
-				lines = slices.Clone(ui.getOrCreateBuffer("(status)").Lines)
-			})
-
-			if len(lines) == welcomeLines {
-				shown <- lines
-
-				return
-			}
-
-			time.Sleep(checkInterval)
-		}
-	}()
-
-	var lines []string
-
-	select {
-	case lines = <-shown:
-	case <-time.After(eventLoopTimeout):
-		t.Fatalf("the status window did not get the welcome lines within %v",
-			eventLoopTimeout)
-	}
-
-	if !strings.Contains(lines[0], "Welcome to neoirc-cli") {
-		t.Errorf("first status line is %q, want the welcome line", lines[0])
-	}
-
-	if !strings.Contains(lines[1], "/connect <server-url>") {
-		t.Errorf("second status line is %q, want the /connect hint", lines[1])
-	}
-
-	// run sets the status bar before it adds the welcome lines.
-	status := statusBarText(ui)
-	if !strings.Contains(status, "[disconnected]") {
-		t.Errorf("status bar is %q, want it to show [disconnected]", status)
-	}
-}
-
-// TestStatusBar checks that the status bar shows [connected], and
-// shows a nick, target or window name with square brackets as it
-// is.
-func TestStatusBar(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name   string
-		nick   string
-		target string
-		unread string
-		want   string
-	}{
-		{
-			name:   "plain names",
-			nick:   testNick,
-			target: testChannel,
-			unread: testOtherNick,
-			want:   " [connected] erin [1:#chan] #chan [Act: 2:bob(1)]",
-		},
-		{
-			name:   "nicks with brackets",
-			nick:   "erin[away]",
-			target: "bob[m]",
-			unread: "dave[afk]",
-			want:   " [connected] erin[away] [1:bob[m]] bob[m] [Act: 2:dave[afk](1)]",
-		},
-		{
-			name:   "nicks with brackets and symbols",
-			nick:   "bob[|[]",
-			target: "x[^[]",
-			unread: testOtherNick,
-			want:   " [connected] bob[|[] [1:x[^[]] x[^[] [Act: 2:bob(1)]",
-		},
-		{
-			// /query takes any text as the target.
-			name:   "query target with brackets",
-			nick:   testNick,
-			target: "[:::y|z]",
-			unread: testOtherNick,
-			want:   " [connected] erin [1:[:::y|z]] [:::y|z] [Act: 2:bob(1)]",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			t.Parallel()
-
-			ui := NewUI()
-			runUI(t, ui)
-
-			// Window 1, the one shown, is the target's. Window 2
-			// gets one unread line.
-			ui.SwitchToBuffer(test.target)
-			ui.AddLine(test.unread, testText)
-			ui.SetStatus(test.nick, test.target, "connected")
-
-			got := statusBarText(ui)
-			if got != test.want {
-				t.Fatalf("status bar is %q, want %q", got, test.want)
-			}
-		})
-	}
-}
-
 // TestOwnEventFromOtherClient checks that a message, notice,
 // join or part that the user's session makes from another
 // client shows as one line in the buffer it belongs to.
@@ -716,49 +301,6 @@ func bufferState(ui *UI, name string) (int, int) {
 	return lines, unread
 }
 
-// statusBarText returns the text the status bar shows.
-// GetText(true) leaves out whatever tview reads as a tag, as
-// drawing does.
-func statusBarText(ui *UI) string {
-	var text string
-
-	ui.app.QueueUpdate(func() {
-		text = ui.statusBar.GetText(true)
-	})
-
-	return text
-}
-
-// handledLines makes app.ui pass each typed line to
-// app.handleInput, as Run does, and returns a channel that
-// receives each line once it has been handled.
-func handledLines(app *App) <-chan string {
-	handled := make(chan string)
-
-	app.ui.OnInput(func(text string) {
-		app.handleInput(text)
-
-		handled <- text
-	})
-
-	return handled
-}
-
-// waitHandled fails the test unless want is the next line handled,
-// within eventLoopTimeout.
-func waitHandled(t *testing.T, handled <-chan string, want string) {
-	t.Helper()
-
-	select {
-	case got := <-handled:
-		if got != want {
-			t.Fatalf("handled %q, want %q", got, want)
-		}
-	case <-time.After(eventLoopTimeout):
-		t.Fatalf("%q was not handled within %v", want, eventLoopTimeout)
-	}
-}
-
 // newServer starts a server that answers every request with
 // body until the test ends.
 func newServer(t *testing.T, body string) *httptest.Server {
@@ -780,22 +322,16 @@ func runUI(t *testing.T, ui *UI) {
 
 	ui.app.SetScreen(tcell.NewSimulationScreen(""))
 
-	// One slot, so that Run's goroutine can end even after the
-	// cleanup below has stopped waiting for it.
-	done := make(chan error, 1)
+	done := make(chan error)
 
 	go func() { done <- ui.Run() }()
 
 	t.Cleanup(func() {
 		ui.Stop()
 
-		select {
-		case err := <-done:
-			if err != nil {
-				t.Errorf("run ui: %v", err)
-			}
-		case <-time.After(eventLoopTimeout):
-			t.Error("the UI did not stop: its event loop stopped responding")
+		err := <-done
+		if err != nil {
+			t.Errorf("run ui: %v", err)
 		}
 	})
 }

internal/cli/ui.go

@@ -16,10 +16,7 @@ type Buffer struct {
 	Unread int
 }
 
-// UI manages the terminal interface. Most of its methods wait for
-// the tview event loop to run their update. Code that runs on that
-// loop, such as a key handler, must not call them: it would wait
-// for itself.
+// UI manages the terminal interface.
 type UI struct {
 	app       *tview.Application
 	messages  *tview.TextView
@@ -31,10 +28,6 @@ type UI struct {
 	currentBuffer int
 
 	onInput func(string)
-	// inputDone is closed once the line last passed to onInput
-	// has been handled. Only callOnInput, on the event loop, uses
-	// it.
-	inputDone chan struct{}
 }
 
 // NewUI creates the tview-based IRC-like UI.
@@ -183,24 +176,9 @@ func (ui *UI) SetStatus(
 	})
 }
 
-// BufferName returns the name of the buffer at index bufIndex,
-// and whether there is such a buffer.
-func (ui *UI) BufferName(bufIndex int) (string, bool) {
-	var (
-		name  string
-		found bool
-	)
-
-	ui.app.QueueUpdate(func() {
-		if bufIndex < 0 || bufIndex >= len(ui.buffers) {
-			return
-		}
-
-		name = ui.buffers[bufIndex].Name
-		found = true
-	})
-
-	return name, found
+// BufferCount returns the number of buffers.
+func (ui *UI) BufferCount() int {
+	return len(ui.buffers)
 }
 
 // BufferIndex returns the index of a named buffer.
@@ -226,10 +204,8 @@ func (ui *UI) initMessages() {
 }
 
 func (ui *UI) initStatusBar() {
-	// Colour tags stay off. With them on, tview reads text in
-	// square brackets, such as "[connected]" or part of a nick,
-	// as a tag and drops it.
-	ui.statusBar = tview.NewTextView()
+	ui.statusBar = tview.NewTextView().
+		SetDynamicColors(true)
 	ui.statusBar.SetBackgroundColor(tcell.ColorNavy)
 	ui.statusBar.SetTextColor(tcell.ColorWhite)
 }
@@ -250,7 +226,10 @@ func (ui *UI) initInput() {
 		}
 
 		ui.input.SetText("")
-		ui.callOnInput(text)
+
+		if ui.onInput != nil {
+			ui.onInput(text)
+		}
 	})
 }
 
@@ -261,11 +240,10 @@ func (ui *UI) initKeyCapture() {
 				return event
 			}
 
-			// Alt and a digit runs /window with that digit.
-			// SwitchBuffer alone would leave the target as it was.
 			r := event.Rune()
 			if r >= '0' && r <= '9' {
-				ui.callOnInput("/window " + string(r))
+				idx := int(r - '0')
+				ui.SwitchBuffer(idx)
 
 				return nil
 			}
@@ -275,31 +253,6 @@ func (ui *UI) initKeyCapture() {
 	)
 }
 
-// callOnInput passes text to the input callback on a new
-// goroutine. The key handlers call it on the event loop, and the
-// callback waits for that loop to update the screen, so they must
-// not wait for the callback. The goroutine first waits for the
-// line before it to be handled, which keeps lines in the order
-// they were typed.
-func (ui *UI) callOnInput(text string) {
-	if ui.onInput == nil {
-		return
-	}
-
-	previous := ui.inputDone
-	done := make(chan struct{})
-	ui.inputDone = done
-
-	go func() {
-		if previous != nil {
-			<-previous
-		}
-
-		ui.onInput(text)
-		close(done)
-	}()
-}
-
 func (ui *UI) refreshStatusBar() {
 	// Placeholder; full refresh needs nick/target context.
 }

internal/config/config.go

@@ -3,12 +3,8 @@ package config
 
 import (
 	"errors"
-	"fmt"
 	"log/slog"
-	"math"
 	"os"
-	"strconv"
-	"time"
 
 	"github.com/spf13/viper"
 	"go.uber.org/fx"
@@ -32,8 +28,6 @@ Type /help for available commands.`
 const DefaultDBURL = "file:///var/lib/neoirc/state.db" +
 	"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)"
 
-var errOutOfRange = errors.New("setting out of range")
-
 // Params defines the dependencies for creating a Config.
 type Params struct {
 	fx.In
@@ -69,8 +63,6 @@ type Config struct {
 }
 
 // New creates a new Config by reading from files and environment variables.
-// It returns an error when a number, true/false or duration setting does
-// not parse or is out of range.
 func New(
 	_ fx.Lifecycle, params Params,
 ) (*Config, error) {
@@ -115,27 +107,29 @@ func New(
 
 	cfg := &Config{
 		DBURL:              viper.GetString("DBURL"),
+		Debug:              viper.GetBool("DEBUG"),
+		Port:               viper.GetInt("PORT"),
 		SentryDSN:          viper.GetString("SENTRY_DSN"),
+		MaintenanceMode:    viper.GetBool("MAINTENANCE_MODE"),
 		MetricsUsername:    viper.GetString("METRICS_USERNAME"),
 		MetricsPassword:    viper.GetString("METRICS_PASSWORD"),
 		MessageMaxAge:      viper.GetString("MESSAGE_MAX_AGE"),
+		MaxMessageSize:     viper.GetInt("MAX_MESSAGE_SIZE"),
 		QueueMaxAge:        viper.GetString("QUEUE_MAX_AGE"),
 		MOTD:               viper.GetString("MOTD"),
 		ServerName:         viper.GetString("SERVER_NAME"),
 		FederationKey:      viper.GetString("FEDERATION_KEY"),
 		SessionIdleTimeout: viper.GetString("SESSION_IDLE_TIMEOUT"),
+		HashcashBits:       viper.GetInt("NEOIRC_HASHCASH_BITS"),
 		OperName:           viper.GetString("NEOIRC_OPER_NAME"),
 		OperPassword:       viper.GetString("NEOIRC_OPER_PASSWORD"),
+		LoginRateLimit:     viper.GetFloat64("LOGIN_RATE_LIMIT"),
+		LoginRateBurst:     viper.GetInt("LOGIN_RATE_BURST"),
 		IRCListenAddr:      viper.GetString("IRC_LISTEN_ADDR"),
 		log:                log,
 		params:             &params,
 	}
 
-	err = parseSettings(cfg)
-	if err != nil {
-		return nil, err
-	}
-
 	// Viper counts an empty environment variable as unset, but an
 	// empty IRC_LISTEN_ADDR must turn the IRC listener off.
 	ircListenAddr, set := os.LookupEnv("IRC_LISTEN_ADDR")
@@ -150,93 +144,3 @@ func New(
 
 	return cfg, nil
 }
-
-// parseSettings reads the number and true/false settings into cfg and
-// checks the duration settings. Each number and duration must be above
-// zero. PORT and NEOIRC_HASHCASH_BITS may also be zero: port 0 lets the
-// system pick a port, and 0 bits turns proof of work off. The error
-// names each setting that does not parse or is out of range.
-func parseSettings(cfg *Config) error {
-	return errors.Join(
-		parseInt("PORT", 0, &cfg.Port),
-		parseInt("MAX_MESSAGE_SIZE", 1, &cfg.MaxMessageSize),
-		parseInt("NEOIRC_HASHCASH_BITS", 0, &cfg.HashcashBits),
-		parseInt("LOGIN_RATE_BURST", 1, &cfg.LoginRateBurst),
-		parseFloat("LOGIN_RATE_LIMIT", &cfg.LoginRateLimit),
-		parseBool("DEBUG", &cfg.Debug),
-		parseBool("MAINTENANCE_MODE", &cfg.MaintenanceMode),
-		checkDuration("MESSAGE_MAX_AGE", cfg.MessageMaxAge),
-		checkDuration("QUEUE_MAX_AGE", cfg.QueueMaxAge),
-		checkDuration("SESSION_IDLE_TIMEOUT", cfg.SessionIdleTimeout),
-	)
-}
-
-// parseInt sets *value to the setting key read as a whole number. It
-// returns an error when the value does not parse or is below minimum.
-func parseInt(key string, minimum int, value *int) error {
-	raw := viper.GetString(key)
-
-	parsed, err := strconv.Atoi(raw)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if parsed < minimum {
-		return fmt.Errorf("%w: %s is %s, but must be at least %d",
-			errOutOfRange, key, raw, minimum)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// parseFloat sets *value to the setting key read as a floating-point
-// number. It returns an error when the value does not parse or is not a
-// finite number above zero.
-func parseFloat(key string, value *float64) error {
-	raw := viper.GetString(key)
-
-	parsed, err := strconv.ParseFloat(raw, 64)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed <= 0 {
-		return fmt.Errorf(
-			"%w: %s is %s, but must be a finite number above zero",
-			errOutOfRange, key, raw)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// parseBool sets *value to the setting key read as true or false.
-func parseBool(key string, value *bool) error {
-	parsed, err := strconv.ParseBool(viper.GetString(key))
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// checkDuration returns an error naming the setting key when value is
-// not a Go duration above zero.
-func checkDuration(key, value string) error {
-	duration, err := time.ParseDuration(value)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if duration <= 0 {
-		return fmt.Errorf("%w: %s is %s, but must be above zero",
-			errOutOfRange, key, value)
-	}
-
-	return nil
-}

internal/config/config_test.go

@@ -2,7 +2,6 @@ package config_test
 
 import (
 	"os"
-	"strings"
 	"testing"
 	"time"
 
@@ -11,8 +10,7 @@ import (
 	"sneak.berlin/go/neoirc/internal/logger"
 )
 
-// loadConfig runs config.New and returns its result.
-func loadConfig(t *testing.T) (*config.Config, error) {
+func newConfig(t *testing.T) *config.Config {
 	t.Helper()
 
 	globs := &globals.Globals{
@@ -26,15 +24,9 @@ func loadConfig(t *testing.T) (*config.Config, error) {
 		t.Fatal(err)
 	}
 
-	return config.New(
+	cfg, err := config.New(
 		nil, config.Params{Globals: globs, Logger: log},
 	)
-}
-
-func newConfig(t *testing.T) *config.Config {
-	t.Helper()
-
-	cfg, err := loadConfig(t)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -42,145 +34,6 @@ func newConfig(t *testing.T) *config.Config {
 	return cfg
 }
 
-func TestUnsetSettingsKeepDefaults(t *testing.T) {
-	// Viper counts an empty environment variable as unset.
-	t.Setenv("PORT", "")
-	t.Setenv("MAX_MESSAGE_SIZE", "")
-	t.Setenv("NEOIRC_HASHCASH_BITS", "")
-	t.Setenv("LOGIN_RATE_BURST", "")
-	t.Setenv("LOGIN_RATE_LIMIT", "")
-	t.Setenv("DEBUG", "")
-	t.Setenv("MAINTENANCE_MODE", "")
-	t.Setenv("MESSAGE_MAX_AGE", "")
-	t.Setenv("QUEUE_MAX_AGE", "")
-	t.Setenv("SESSION_IDLE_TIMEOUT", "")
-
-	// Each duration setting defaults to 30 days.
-	const thirtyDays = "720h"
-
-	want := settings{
-		Port:               8080,
-		MaxMessageSize:     4096,
-		HashcashBits:       20,
-		LoginRateBurst:     5,
-		LoginRateLimit:     1,
-		Debug:              false,
-		MaintenanceMode:    false,
-		MessageMaxAge:      thirtyDays,
-		QueueMaxAge:        thirtyDays,
-		SessionIdleTimeout: thirtyDays,
-	}
-
-	got := settingsOf(newConfig(t))
-	if got != want {
-		t.Errorf("settings = %+v, want %+v", got, want)
-	}
-}
-
-func TestValidSettingsAreUsed(t *testing.T) {
-	// Each whole number is the lowest value its setting allows, and 1ns
-	// is the shortest duration allowed.
-	t.Setenv("PORT", "0")
-	t.Setenv("MAX_MESSAGE_SIZE", "1")
-	t.Setenv("NEOIRC_HASHCASH_BITS", "0")
-	t.Setenv("LOGIN_RATE_BURST", "1")
-	t.Setenv("LOGIN_RATE_LIMIT", "0.5")
-	t.Setenv("DEBUG", "true")
-	t.Setenv("MAINTENANCE_MODE", "true")
-	t.Setenv("MESSAGE_MAX_AGE", "1ns")
-	t.Setenv("QUEUE_MAX_AGE", "1h30m")
-	t.Setenv("SESSION_IDLE_TIMEOUT", "45m")
-
-	want := settings{
-		Port:               0,
-		MaxMessageSize:     1,
-		HashcashBits:       0,
-		LoginRateBurst:     1,
-		LoginRateLimit:     0.5,
-		Debug:              true,
-		MaintenanceMode:    true,
-		MessageMaxAge:      "1ns",
-		QueueMaxAge:        "1h30m",
-		SessionIdleTimeout: "45m",
-	}
-
-	got := settingsOf(newConfig(t))
-	if got != want {
-		t.Errorf("settings = %+v, want %+v", got, want)
-	}
-}
-
-// settings holds the Config fields whose settings config.New parses.
-type settings struct {
-	Port               int
-	MaxMessageSize     int
-	HashcashBits       int
-	LoginRateBurst     int
-	LoginRateLimit     float64
-	Debug              bool
-	MaintenanceMode    bool
-	MessageMaxAge      string
-	QueueMaxAge        string
-	SessionIdleTimeout string
-}
-
-func settingsOf(cfg *config.Config) settings {
-	return settings{
-		Port:               cfg.Port,
-		MaxMessageSize:     cfg.MaxMessageSize,
-		HashcashBits:       cfg.HashcashBits,
-		LoginRateBurst:     cfg.LoginRateBurst,
-		LoginRateLimit:     cfg.LoginRateLimit,
-		Debug:              cfg.Debug,
-		MaintenanceMode:    cfg.MaintenanceMode,
-		MessageMaxAge:      cfg.MessageMaxAge,
-		QueueMaxAge:        cfg.QueueMaxAge,
-		SessionIdleTimeout: cfg.SessionIdleTimeout,
-	}
-}
-
-func TestBadSettingStopsStartup(t *testing.T) {
-	// For each setting, the first value does not parse and the others
-	// parse but are out of range.
-	tests := []struct {
-		key    string
-		values []string
-	}{
-		{key: "PORT", values: []string{"80a", "-1"}},
-		{key: "MAX_MESSAGE_SIZE", values: []string{"4k", "0", "-4096"}},
-		{key: "NEOIRC_HASHCASH_BITS", values: []string{"twenty", "-1"}},
-		{key: "LOGIN_RATE_BURST", values: []string{"five", "0", "-5"}},
-		{key: "LOGIN_RATE_LIMIT", values: []string{
-			"fast", "0", "-1", "NaN", "Inf", "-Inf",
-		}},
-		{key: "DEBUG", values: []string{"yes"}},
-		{key: "MAINTENANCE_MODE", values: []string{"on"}},
-		{key: "MESSAGE_MAX_AGE", values: []string{"30d", "0", "-1h"}},
-		{key: "QUEUE_MAX_AGE", values: []string{"720", "0s", "-24h"}},
-		{key: "SESSION_IDLE_TIMEOUT", values: []string{"a month", "0", "-1m"}},
-	}
-
-	for _, test := range tests {
-		for _, value := range test.values {
-			t.Run(test.key+"="+value, func(t *testing.T) {
-				t.Setenv(test.key, value)
-
-				_, err := loadConfig(t)
-				if err == nil {
-					t.Fatalf("%s=%q: got no error", test.key, value)
-				}
-
-				msg := err.Error()
-				if !strings.Contains(msg, test.key) ||
-					!strings.Contains(msg, value) {
-					t.Errorf("error %q does not name %s and %q",
-						msg, test.key, value)
-				}
-			})
-		}
-	}
-}
-
 func TestIRCListenAddrUnsetKeepsDefault(t *testing.T) {
 	// t.Setenv puts back whatever value was there after the test.
 	t.Setenv("IRC_LISTEN_ADDR", "")