Commit 1dcac38

rmptui1dcac38

Merge pull request #11 from krolyxon/v0.2

V0.2

Author: Amaan
Date: 2026-10-20 11:42 +0530
Committer: GitHub · 2026-10-20 11:42 +0530
Parents: c847cda 3c223ad
Commit: 1dcac383102e3fa5e8658742e5a6a9800d322560

+11172 −3571

61 files changed

Browse files Patch

−Context 3+

M .github/copilot-instructions.md +59 −23
M CHANGELOG.md +30 −0
M Cargo.lock +1693 −48
M Cargo.toml +26 −15
M README.md +192 −154
A assets/browse-screen.png
A assets/lyrics-screen.png
A assets/playlist-editor-screen.png
D assets/ss.png
A src/action.rs +323 −0
M src/app.rs +451 −422
D src/browser.rs +0 −164
D src/config.rs +0 −669
A src/config/default.toml +221 −0
A src/config/keys.rs +305 −0
A src/config/mod.rs +554 −0
A src/config/mpd_conf.rs +87 −0
A src/config/theme.rs +104 −0
D src/connection.rs +0 −741
A src/event.rs +20 −0
D src/event_handler/handler.rs +0 −473
D src/event_handler/mod.rs +0 −1
M src/lib.rs +15 −10
D src/list.rs +0 −30
M src/logging.rs +39 −67
A src/lyrics/lrc.rs +165 −0
A src/lyrics/mod.rs +373 −0
M src/main.rs +47 −176
A src/mpd/commands.rs +168 −0
A src/mpd/connection.rs +173 −0
A src/mpd/error.rs +42 −0
A src/mpd/mod.rs +16 −0
A src/mpd/protocol.rs +227 −0
A src/mpd/selection.rs +36 −0
A src/mpd/types.rs +425 −0
A src/mpd/worker.rs +477 −0
A src/popups/add_to_playlist.rs +114 −0
A src/popups/confirm.rs +69 −0
A src/popups/help.rs +133 −0
A src/popups/input.rs +99 −0
A src/popups/mod.rs +60 −0
A src/screens/browser.rs +325 −0
A src/screens/library.rs +396 −0
A src/screens/lyrics.rs +138 −0
A src/screens/mod.rs +168 −0
A src/screens/playlists.rs +296 −0
A src/screens/queue.rs +238 −0
A src/screens/tag_editor.rs +669 −0
A src/screens/visualizer.rs +352 −0
A src/state.rs +177 −0
A src/tags.rs +186 −0
D src/tui.rs +0 −62
D src/ui.rs +0 −489
A src/ui/input.rs +160 −0
A src/ui/list.rs +346 −0
A src/ui/mod.rs +337 −0
A src/util.rs +96 −0
D src/utils.rs +0 −27
A src/visualizer/bars.rs +130 −0
A src/visualizer/mod.rs +251 −0
A tests/mpd_client.rs +164 −0

M .github/copilot-instructions.md View

M CHANGELOG.md View

M Cargo.lock View

M Cargo.toml View

M README.md View

A assets/browse-screen.png View

[Binary file]

A assets/lyrics-screen.png View

[Binary file]

A assets/playlist-editor-screen.png View

[Binary file]

D assets/ss.png View

[Diff too large] View file

A src/action.rs View

M src/app.rs View

Mode 100755 → 100644

D src/browser.rs View

D src/config.rs View

A src/config/default.toml View

A src/config/keys.rs View

A src/config/mod.rs View

A src/config/mpd_conf.rs View

A src/config/theme.rs View

D src/connection.rs View

A src/event.rs View

D src/event_handler/handler.rs View

D src/event_handler/mod.rs View

M src/lib.rs View

Mode 100755 → 100644

D src/list.rs View

M src/logging.rs View

A src/lyrics/lrc.rs View

A src/lyrics/mod.rs View

M src/main.rs View

Mode 100755 → 100644

A src/mpd/commands.rs View

A src/mpd/connection.rs View

A src/mpd/error.rs View

A src/mpd/mod.rs View

A src/mpd/protocol.rs View

A src/mpd/selection.rs View

A src/mpd/types.rs View

A src/mpd/worker.rs View

A src/popups/add_to_playlist.rs View

A src/popups/confirm.rs View

A src/popups/help.rs View

A src/popups/input.rs View

A src/popups/mod.rs View

A src/screens/browser.rs View

[Diff too large] View file

A src/screens/library.rs View

[Diff too large] View file

A src/screens/lyrics.rs View

A src/screens/mod.rs View

[Diff too large] View file

A src/screens/playlists.rs View

[Diff too large] View file

A src/screens/queue.rs View

[Diff too large] View file

A src/screens/tag_editor.rs View

[Diff too large] View file

A src/screens/visualizer.rs View

[Diff too large] View file

A src/state.rs View

[Diff too large] View file

A src/tags.rs View

[Diff too large] View file

D src/tui.rs View

D src/ui.rs View

[Diff too large] View file

A src/ui/input.rs View

[Diff too large] View file

A src/ui/list.rs View

[Diff too large] View file

A src/ui/mod.rs View

[Diff too large] View file

A src/util.rs View

[Diff too large] View file

D src/utils.rs View

A src/visualizer/bars.rs View

[Diff too large] View file

A src/visualizer/mod.rs View

[Diff too large] View file

A tests/mpd_client.rs View

[Diff too large] View file

		@@ -1,3 +1,33 @@
	1	+	## rmptui-v0.2.0
	2	+
	3	+	A rewrite from scratch with a new architecture modelled on ncmpcpp and rmpc.
	4	+
	5	+	- New screens: Media Library (artists → albums → songs), Tag Editor,
	6	+	ncmpcpp-style Visualizer (wave, filled wave, spectrum and ellipse, in
	7	+	stereo, from an MPD fifo output) and synced Lyrics (local `.lrc`
	8	+	files, cache and LRCLIB), plus a lyrics pane on the queue.
	9	+	- Browser shows stored playlists at the bottom of the root folder;
	10	+	playlist editor, queue and browser keep every 0.1 feature.
	11	+	- MPD I/O runs in background tasks; key presses never wait for the server,
	12	+	and the client reconnects automatically. Unix sockets are supported.
	13	+	- Marks (`v`) for acting on several items, fuzzy search on every list,
	14	+	confirmation before clearing the queue or deleting playlists, a key help
	15	+	popup (`?`) and mouse support (select, double-click, wheel, tabs, seek).
	16	+	- New configuration format with per-context key bindings, a theme, queue
	17	+	columns and lyrics/visualizer settings. The documented default file is the
	18	+	single source of truth; partial files keep all other defaults. 0.1 config
	19	+	files are detected and rejected with instructions.
	20	+	- ncmpcpp-style interface: screen title and volume on top, column headers,
	21	+	folders spanning the whole row, reverse-video selection and a
	22	+	`Playing: "Title" by Artist in Album` status line under the progress bar.
	23	+	- The tag editor follows ncmpcpp (directories, tag types, tags) and can also
	24	+	rename files and fix letter case.
	25	+	- The music directory is read from the local `mpd.conf` when MPD runs on the
	26	+	same machine.
	27	+	- `c` clears the queue from every screen.
	28	+	- New `--config` and `--print-default-config` options; `RMPTUI_LOG` sets
	29	+	the log level.
	30	+
1	31		## rmptui-v0.1.7
2	32
3	33		- Replace the outdated MPD crate with an asynchronous native MPD TCP protocol

	@@ -0,0 +1,87 @@
1	+	//! Reading `music_directory` from the local MPD configuration.
2	+	//!
3	+	//! MPD only reveals its music directory over a Unix socket, so for a local
4	+	//! server reached over TCP rmptui reads it from MPD's own config file.
5	+
6	+	use std::{
7	+	env, fs,
8	+	path::{Path, PathBuf},
9	+	};
10	+
11	+	use crate::{mpd::Address, util::expand_tilde};
12	+
13	+	/// The music directory of a local MPD, if `address` is local and an MPD
14	+	/// config file names one.
15	+	pub fn local_music_directory(address: &Address) -> Option<PathBuf> {
16	+	if !address.is_local() {
17	+	return None;
18	+	}
19	+	candidates()
20	+	.iter()
21	+	.find_map(\|path\| fs::read_to_string(path).ok())
22	+	.and_then(\|contents\| parse_music_directory(&contents))
23	+	}
24	+
25	+	/// MPD's config file locations, in MPD's lookup order.
26	+	fn candidates() -> Vec<PathBuf> {
27	+	let mut paths = Vec::new();
28	+	if let Some(dir) = env::var_os("XDG_CONFIG_HOME").filter(\|d\| !d.is_empty()) {
29	+	paths.push(Path::new(&dir).join("mpd/mpd.conf"));
30	+	}
31	+	paths.extend(
32	+	[
33	+	"~/.config/mpd/mpd.conf",
34	+	"~/.mpdconf",
35	+	"~/.mpd/mpd.conf",
36	+	"/etc/mpd.conf",
37	+	]
38	+	.map(expand_tilde),
39	+	);
40	+	paths
41	+	}
42	+
43	+	fn parse_music_directory(contents: &str) -> Option<PathBuf> {
44	+	contents.lines().find_map(\|line\| {
45	+	let line = line.trim();
46	+	let value = line.strip_prefix("music_directory")?;
47	+	if !value.starts_with(char::is_whitespace) {
48	+	return None;
49	+	}
50	+	let value = value.trim();
51	+	let value = value
52	+	.strip_prefix('"')
53	+	.and_then(\|v\| v.split_once('"'))
54	+	.map_or(value, \|(inner, _)\| inner);
55	+	(!value.is_empty()).then(\|\| expand_tilde(value))
56	+	})
57	+	}
58	+
59	+	#[cfg(test)]
60	+	mod tests {
61	+	use super::*;
62	+
63	+	#[test]
64	+	fn parses_music_directory() {
65	+	let conf = "# music_directory \"/commented\"\n\
66	+	music_directory_x \"/no\"\n\
67	+	music_directory\t\t\"~/music\" # trailing comment\n";
68	+	let home = env::var("HOME").unwrap();
69	+	assert_eq!(
70	+	parse_music_directory(conf),
71	+	Some(PathBuf::from(format!("{home}/music")))
72	+	);
73	+	assert_eq!(
74	+	parse_music_directory("music_directory /srv/music"),
75	+	Some(PathBuf::from("/srv/music"))
76	+	);
77	+	assert_eq!(parse_music_directory("port \"6600\""), None);
78	+	}
79	+
80	+	#[test]
81	+	fn ignores_remote_servers() {
82	+	assert_eq!(
83	+	local_music_directory(&Address::Tcp("192.168.1.20:6600".into())),
84	+	None
85	+	);
86	+	}
87	+	}

	@@ -0,0 +1,104 @@
1	+	use std::str::FromStr;
2	+
3	+	use ratatui::style::{Color, Modifier, Style};
4	+	use serde::{Deserialize, Deserializer, de};
5	+
6	+	/// Colors used throughout the UI.
7	+	#[derive(Clone, Debug, Deserialize)]
8	+	#[serde(deny_unknown_fields)]
9	+	pub struct Theme {
10	+	#[serde(deserialize_with = "color")]
11	+	pub text: Color,
12	+	#[serde(deserialize_with = "color")]
13	+	pub dim: Color,
14	+	#[serde(deserialize_with = "color")]
15	+	pub border: Color,
16	+	#[serde(deserialize_with = "color")]
17	+	pub selection_fg: Color,
18	+	#[serde(deserialize_with = "color")]
19	+	pub selection_bg: Color,
20	+	#[serde(deserialize_with = "color")]
21	+	pub playing: Color,
22	+	#[serde(deserialize_with = "color")]
23	+	pub marked: Color,
24	+	#[serde(deserialize_with = "color")]
25	+	pub directory: Color,
26	+	#[serde(deserialize_with = "color")]
27	+	pub error: Color,
28	+	#[serde(deserialize_with = "color")]
29	+	pub artist: Color,
30	+	#[serde(deserialize_with = "color")]
31	+	pub track: Color,
32	+	#[serde(deserialize_with = "color")]
33	+	pub album: Color,
34	+	#[serde(deserialize_with = "color")]
35	+	pub duration: Color,
36	+	#[serde(deserialize_with = "color", rename = "progress")]
37	+	pub progress_filled: Color,
38	+	#[serde(deserialize_with = "colors")]
39	+	pub visualizer: Vec<Color>,
40	+	}
41	+
42	+	impl Theme {
43	+	pub fn text(&self) -> Style {
44	+	Style::new().fg(self.text)
45	+	}
46	+
47	+	pub fn dim(&self) -> Style {
48	+	Style::new().fg(self.dim)
49	+	}
50	+
51	+	pub fn border(&self) -> Style {
52	+	Style::new().fg(self.border)
53	+	}
54	+
55	+	/// Titles and column headers.
56	+	pub fn header(&self) -> Style {
57	+	self.text().add_modifier(Modifier::BOLD)
58	+	}
59	+
60	+	/// The selected row of the focused list.
61	+	pub fn selection(&self) -> Style {
62	+	if self.selection_fg == Color::Reset && self.selection_bg == Color::Reset {
63	+	Style::new().add_modifier(Modifier::REVERSED)
64	+	} else {
65	+	Style::new().fg(self.selection_fg).bg(self.selection_bg)
66	+	}
67	+	}
68	+
69	+	/// The selected row of a list without focus.
70	+	pub fn selection_inactive(&self) -> Style {
71	+	self.selection().add_modifier(Modifier::DIM)
72	+	}
73	+
74	+	pub fn playing(&self) -> Style {
75	+	Style::new().fg(self.playing).add_modifier(Modifier::BOLD)
76	+	}
77	+
78	+	pub fn marked(&self) -> Style {
79	+	Style::new().fg(self.marked)
80	+	}
81	+
82	+	pub fn directory(&self) -> Style {
83	+	Style::new().fg(self.directory)
84	+	}
85	+
86	+	pub fn error(&self) -> Style {
87	+	Style::new().fg(self.error)
88	+	}
89	+	}
90	+
91	+	fn parse_color<E: de::Error>(value: &str) -> Result<Color, E> {
92	+	Color::from_str(value).map_err(\|_\| E::custom(format!("invalid color `{value}`")))
93	+	}
94	+
95	+	fn color<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Color, D::Error> {
96	+	parse_color(&String::deserialize(deserializer)?)
97	+	}
98	+
99	+	fn colors<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<Color>, D::Error> {
100	+	Vec::<String>::deserialize(deserializer)?
101	+	.iter()
102	+	.map(\|value\| parse_color(value))
103	+	.collect()
104	+	}

	@@ -0,0 +1,20 @@
1	+	//! Events delivered to the application loop by background tasks.
2	+
3	+	use crate::{lyrics::LookupResult, mpd::MpdEvent};
4	+
5	+	#[derive(Debug)]
6	+	pub enum AppEvent {
7	+	Mpd(MpdEvent),
8	+	Lyrics {
9	+	file: String,
10	+	result: LookupResult,
11	+	},
12	+	/// Tag writes finished: the directories to rescan, or an error.
13	+	TagsWritten(Result<Vec<String>, String>),
14	+	}
15	+
16	+	impl From<MpdEvent> for AppEvent {
17	+	fn from(event: MpdEvent) -> Self {
18	+	Self::Mpd(event)
19	+	}
20	+	}

		@@ -1,15 +1,20 @@
1		−	//! An asynchronous terminal client for Music Player Daemon.
	1	+	//! rmptui — a keyboard-driven MPD client for the terminal.
	2	+	//!
	3	+	//! The crate is split into an MPD client (`mpd`), configuration (`config`),
	4	+	//! the application loop (`app`) and its UI components (`screens`, `popups`,
	5	+	//! `ui`), plus the lyrics and visualizer services.
2	6
	7	+	pub mod action;
3	8		pub mod app;
4		−	pub mod browser;
5	9		pub mod config;
6		−	pub mod connection;
7		−	pub mod event_handler;
8		−	pub mod list;
	10	+	pub mod event;
9	11		pub mod logging;
10		−	pub mod tui;
	12	+	pub mod lyrics;
	13	+	pub mod mpd;
	14	+	pub mod popups;
	15	+	pub mod screens;
	16	+	pub mod state;
	17	+	pub mod tags;
11	18		pub mod ui;
12		−	pub mod utils;
13		−
14		−	/// The application's error type.
15		−	pub type AppResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;
	19	+	pub mod util;
	20	+	pub mod visualizer;

		@@ -1,32 +1,68 @@
1		−	# Copilot instructions for rmptui
	1	+	# Contributor and agent instructions for rmptui
2	2
3	3		## Build, test, and lint
4	4
5	5		- `cargo build` — compile the application.
6		−	- `cargo run` — run against MPD at `127.0.0.1:6600` by default.
7		−	- `cargo fmt --check` — check Rust formatting; use `cargo fmt` to format.
8		−	- `cargo test` — run all unit tests.
9		−	- `cargo test connection::tests::parses_quoted_mpd_values_and_escapes` — run one named test. Replace the filter with a test name or module path to target another test.
10		−	- `cargo clippy --all-targets -- -D warnings` — lint all targets and treat warnings as errors.
	6	+	- `cargo run -- --config FILE` — run with a specific config (MPD at
	7	+	`127.0.0.1:6600` by default; `MPD_HOST`/`MPD_PORT` override it).
	8	+	- `cargo fmt --check`, `cargo clippy --all-targets -- -D warnings`, `cargo test`.
	9	+	- `cargo test mpd::protocol` — run the tests of one module; `tests/mpd_client.rs`
	10	+	exercises the client against a scripted fake MPD server.
11	11
12	12		## Architecture
13	13
14		−	- `src/main.rs` owns the Tokio runtime, reads `MPD_HOST`/`MPD_PORT`, initializes the terminal, and selects between terminal input, redraw ticks, and MPD change notifications. A separate `MpdClient` connection blocks on MPD `idle`, then sends a fresh `MpdSnapshot` to the UI; the app's command connection stays available for user actions.
15		−	- `src/config.rs` loads or creates the TOML configuration at `$CONFIG_HOME/rmptui/config.toml`, falling back to `$XDG_CONFIG_HOME` and then `~/.config`. Its generated TOML documents every option and keybinding. MPD host/port settings can be overridden with `MPD_HOST` and `MPD_PORT`.
16		−	- `src/connection.rs` implements MPD's line-oriented text protocol over Tokio TCP, including command quoting, response/error parsing, and conversion of MPD responses into app models. Keep protocol I/O asynchronous. The client processes a command's complete response before issuing another command on that connection.
17		−	- `src/app.rs` owns UI/application state and coordinates queue, browser, and playlist operations. `src/browser.rs` represents rows as `BrowserEntry::Directory` or `BrowserEntry::Song`, keeping song metadata with its row. Browser paths are MPD library-relative paths, not local filesystem paths. The Playlists view has separate list/song focus and supports stored-playlist track deletion and reordering through MPD's `playlistdelete` and `playlistmove` commands.
18		−	- `src/event_handler/handler.rs` maps Crossterm events to application operations. `src/ui.rs` renders the current app state with Ratatui; it should not perform MPD I/O. `src/tui.rs` owns terminal mode setup, drawing, and restoration.
19		−	- `src/list.rs` contains shared list cursor behavior. `src/utils.rs` provides the built-in audio-extension check used by the browser and directory operations.
	14	+	- `mpd/` is a self-contained MPD client.
	15	+	- `protocol.rs`: pure command encoding (every argument quoted and escaped)
	16	+	and response parsing.
	17	+	- `connection.rs`: async TCP and Unix-socket connections.
	18	+	- `types.rs`: typed models.
	19	+	- `commands.rs`: command constructors.
	20	+	- `worker.rs`: two background tasks. The idle connection reports changed
	21	+	subsystems. The command connection runs `Request`s from an `MpdHandle`
	22	+	and answers `Query`s with `Reply`s. Both reconnect on their own.
	23	+	- `app.rs` owns the state and runs one `tokio::select!` loop over terminal
	24	+	input, `AppEvent`s (MPD, lyrics, tag writes) and visualizer frames. UI code
	25	+	never awaits MPD: it sends requests and reacts to the resulting events.
	26	+	- `state.rs` (`MpdState`) mirrors the server: status, current song, the queue
	27	+	(updated incrementally via `plchanges`), stored playlists, and a database
	28	+	version used to invalidate caches.
	29	+	- `screens/` holds one component per screen behind the `Screen` trait (`draw`,
	30	+	`handle_action`, `on_mpd`, `on_enter`, `on_mouse`, `search`).
	31	+	- Screens receive a `Ctx` with read access to config and state, the
	32	+	`MpdHandle`, and an effect queue (`Effect`) for things only the app can do:
	33	+	notifications, popups, tag writes, lyric reloads.
	34	+	- Every screen sees every `MpdEvent`, so caches stay valid while hidden.
	35	+	- `popups/` holds modal components (`Popup` trait); the topmost popup gets all
	36	+	keys. Destructive actions go through `ConfirmPopup`.
	37	+	- `ui/` holds the ncmpcpp-style frame (title row, progress bar, status line), the
	38	+	virtualized searchable `ListView`, and the `LineInput` editor.
	39	+	- `config/`:
	40	+	- `default.toml` is embedded and is the single source of truth for
	41	+	defaults; user files are merged over it table by table.
	42	+	- `keys.rs` parses key specs and builds the per-context `Keymap`.
	43	+	- `action.rs` defines the `Action`, `Context` and `ScreenId` enums. Each action
	44	+	declares the contexts it may be bound in. Lookup order is: popup or screen
	45	+	context → `navigation` → `global`.
	46	+	- `lyrics/`: LRC parser and the async lookup service (local `.lrc` → cache →
	47	+	LRCLIB). `visualizer/`: fifo reader thread with FFT, plus bar smoothing.
	48	+	`tags.rs`: lofty-based tag writing.
20	49
21		−	## Repository conventions
	50	+	## Conventions
22	51
23		−	- Keep the MPD protocol models and wire-format parsing in `connection.rs`; UI and application code should use those models rather than parse raw MPD responses.
24		−	- Use the crate-level `AppResult<T>` for errors crossing module boundaries. Avoid duplicating state that can be derived from the MPD status or other canonical model data.
25		−	- Keep configuration defaults and validation in `config.rs`, and read tunable behavior from `App.config` rather than adding new hard-coded runtime values. Route keyboard actions through `App.config.keybindings`; keep README controls and the generated defaults in sync. Text typed into search/name fields is content, not a keybinding, except for configured input-editing actions.
26		−	- When adding or changing config options, update all three: the runtime default/config validation, descriptive comments in the generated first-run TOML, and the README example/explanation. Existing partial configs should continue receiving defaults for newly added keybindings.
27		−	- Pass MPD library paths as protocol arguments. The MPD command writer quotes and escapes each argument, so do not construct raw command strings from user-provided names or paths.
28		−	- Preserve async boundaries through event handling and app operations; do not introduce blocking socket reads, polling threads, or synchronous terminal polling.
29		−	- Browser `/` search retains all positive-scoring fuzzy matches in result order. `Enter` returns to normal navigation while retaining browser results; `n` and `N` cycle them. Starting a new search or changing directories resets those results.
30		−	- In the Playlists view, `Left`/`h` and `Right`/`l` switch focus between playlist names and song contents. `Space`/`Enter` load a selected playlist from the playlist list; when song contents are focused, `Enter` plays that song, `d` deletes it from the stored playlist, and `J`/`K` reorder it. `D` deletes the selected stored playlist and `R` renames it. Keep these actions context-aware and all defaults documented in the README/config.
31		−	- When changing key behavior or features, keep the controls documented in `README.md` consistent with `event_handler/handler.rs`.
32		−	- `AppResult<T>` is `Send + Sync` because application errors cross Tokio task boundaries.
	52	+	- Build MPD commands only through `mpd::commands` or `Command::arg`; never
	53	+	format raw command strings from user data. Filter expressions go through
	54	+	`protocol::filter_eq`/`filter_and`.
	55	+	- Prefer position-based commands (`move`, `delete`) for actions users repeat
	56	+	quickly. They stay correct even when sent before the local queue refreshes.
	57	+	- Every new action needs:
	58	+	- an `Action` variant with its contexts and description;
	59	+	- a default binding in `config/default.toml` (a test enforces this);
	60	+	- a README entry.
	61	+	- Every new option needs:
	62	+	- a documented entry in `default.toml`;
	63	+	- a field in the matching config struct (`deny_unknown_fields` catches
	64	+	typos);
	65	+	- validation in `Config::validate` if it has limits;
	66	+	- README documentation.
	67	+	- Screens must not block: do file and network I/O in tasks (see lyrics) or
	68	+	`spawn_blocking` (see tag writes) and report back through `AppEvent`.

		@@ -1,28 +1,39 @@
1	1		[package]
2	2		name = "rmptui"
3	3		authors = ["krolyxon"]
4		−	description = "A fast and minimal terminal MPD client"
	4	+	description = "A fast, keyboard-driven MPD client for the terminal"
5	5		readme = "README.md"
6		−	version = "0.1.6"
7		−	edition = "2021"
	6	+	version = "0.2.0"
	7	+	edition = "2024"
	8	+	rust-version = "1.88"
8	9		license = "AGPL-3.0-only"
9	10		repository = "https://github.com/krolyxon/rmptui"
10	11		keywords = ["mpd", "music", "cli", "tui", "client"]
	12	+	categories = ["command-line-utilities", "multimedia::audio"]
11	13
12	14		[dependencies]
13		−	ratatui = { version = "0.30.2", default-features = false, features = [
14		−	"crossterm_0_29",
15		−	] }
	15	+	anyhow = "1.0.104"
	16	+	clap = { version = "4.6.7", features = ["derive"] }
16	17		crossterm = { version = "0.29.0", features = ["event-stream"] }
17		−	rust-fuzzy-search = "0.1.1"
18	18		futures-util = "0.3.34"
	19	+	libc = "0.2.186"
	20	+	lofty = "0.25.4"
	21	+	nucleo-matcher = "0.3.1"
	22	+	ratatui = { version = "0.30.2", default-features = false, features = ["crossterm_0_29"] }
	23	+	realfft = "3.5.0"
	24	+	reqwest = { version = "0.13.5", default-features = false, features = ["json", "query", "rustls"] }
19	25		serde = { version = "1.0.229", features = ["derive"] }
	26	+	serde_json = "1.0.154"
	27	+	thiserror = "2.0.21"
	28	+	tokio = { version = "1.53.3", features = ["macros", "rt-multi-thread", "net", "io-util", "time", "sync", "fs"] }
20	29		toml = "1.1.8"
21		−	tokio = { version = "1.53.3", features = [
22		−	"macros",
23		−	"rt-multi-thread",
24		−	"net",
25		−	"io-util",
26		−	"time",
27		−	"sync",
28		−	] }
	30	+	tracing = "0.1.44"
	31	+	tracing-subscriber = { version = "0.3.23", default-features = false, features = ["fmt", "std", "env-filter"] }
	32	+	unicode-width = "0.2.2"
	33	+
	34	+	[dev-dependencies]
	35	+	tokio = { version = "1.53.3", features = ["test-util"] }
	36	+
	37	+	[profile.release]
	38	+	lto = "thin"
	39	+	codegen-units = 1

		@@ -5,33 +5,50 @@
5	5
6	6		A fast, keyboard-driven MPD client for your terminal.
7	7
8		−	rmptui is a lightweight music player interface for [Music Player Daemon
9		−	(MPD)](https://www.musicpd.org/). Browse your library, manage the play queue,
10		−	work with playlists, and control playback without leaving the terminal.
11		−
12		−	![rmptui screenshot](https://raw.githubusercontent.com/krolyxon/rmptui/master/assets/ss.png)
13		−
14		−	## Highlights
15		−
16		−	- Three focused views: browse your music library, control the current queue,
17		−	and inspect saved playlists.
18		−	- Metadata at a glance: see artist, track, title, album, and duration in
19		−	the browser and queue.
20		−	- Fuzzy, repeatable search: search the current view with `/`; in the song
21		−	browser, keep the query and cycle matching folders and songs with `n` and
22		−	`N`.
23		−	- Playlist tools: load playlists, add selected tracks or folders to a
24		−	playlist, create playlists, and rename them.
25		−	- Queue control: play, remove, reorder, and append tracks.
26		−	- Responsive MPD updates: the client uses MPD's asynchronous `idle`
27		−	notifications instead of regularly polling the server.
28		−	- Direct MPD connection: speaks MPD's standard text protocol over
29		−	asynchronous TCP; no `mpd` crate or WebSocket proxy is required.
	8	+	rmptui is a terminal interface for [Music Player Daemon
	9	+	(MPD)](https://www.musicpd.org/) that looks and feels like ncmpcpp. Browse your
	10	+	library, manage the queue and playlists, edit tags, read synced lyrics and
	11	+	watch a music visualizer without leaving the terminal.
	12	+
	13	+	![Browse Screen](assets/browse-screen.png)
	14	+	![Playlist Editor Screen](assets/playlist-editor-screen.png)
	15	+	![Lyrics Screen](assets/lyrics-screen.png)
	16	+
	17	+
	18	+	## Screens
	19	+
	20	+	\| Key \| Screen \| What it does \|
	21	+	\| --- \| --- \| --- \|
	22	+	\| `1` \| Playlist \| The play queue as a table (Artist, Track, Title, Album, Time). Play, remove, reorder, mark, shuffle or save it as a playlist. `L` shows a synced lyrics pane next to it. \|
	23	+	\| `2` \| Browse \| Your music folders. Folders (`[name]`) span the whole row, songs use the same columns as the queue, and stored playlists are listed at the bottom of the root folder. \|
	24	+	\| `3` \| Playlist editor \| Stored playlists and their songs: load, play from a song, remove or reorder songs, rename or delete playlists. \|
	25	+	\| `4` \| Media library \| Album artists → albums (with year) → songs. `t` switches between AlbumArtist and Artist. \|
	26	+	\| `5` \| Tag editor \| Directories, tag types and tags, like ncmpcpp: edit Title, Artist, Album Artist, Album, Date, Track, Genre, Composer, Performer, Disc and Comment of one or many songs, rename files, fix letter case, then save. \|
	27	+	\| `6` \| Music visualizer \| ncmpcpp-style wave, filled wave, spectrum and ellipse visualizers fed by an MPD fifo output; `Space` cycles them. \|
	28	+	\| `7` \| Lyrics \| Synced lyrics that follow playback, or plain lyrics you can scroll. \|
	29	+
	30	+	Every screen shares ncmpcpp's frame: the screen title and volume on top
	31	+	(active modes such as `[rz]` appear on the line below), and at the bottom a
	32	+	progress bar above `Playing: "Title" by Artist in Album (Year)` with the
	33	+	bitrate and elapsed/total time.
	34	+
	35	+	Other highlights:
	36	+
	37	+	- Instant controls. All MPD traffic runs in background tasks over MPD's
	38	+	`idle` notifications, so seeking, volume changes and skipping never wait for
	39	+	the UI, and the UI never waits for the server.
	40	+	- Fuzzy search everywhere. `/` searches the focused list; `n`/`N` cycle
	41	+	through the matches.
	42	+	- Marks. `v` marks items; queue removal, add-to-playlist and tag edits
	43	+	then apply to every marked item.
	44	+	- Mouse support. Click to select, double-click to play/open, scroll with
	45	+	the wheel and click the progress bar to seek.
	46	+	- TCP or Unix socket, with password support and automatic reconnection.
30	47
31	48		## Requirements
32	49
33	50		- A running MPD server with its music library configured.
34		−	- Rust and Cargo to build from source.
	51	+	- Rust 1.88 or newer and Cargo to build from source.
35	52
36	53		## Install
37	54
		@@ -42,9 +59,8 @@ copy it to `/usr/local/bin/rmptui`:
42	59		./install.sh
43	60		```
44	61
45		−	The script uses `sudo` for the system-directory operations when needed. It
46		−	requires Rust and Cargo to build from source. To use a different binary
47		−	directory or uninstall rmptui:
	62	+	The script uses `sudo` for the system-directory operations when needed. To use
	63	+	a different binary directory or uninstall rmptui:
48	64
49	65		```sh
50	66		./install.sh --bin-dir "$HOME/.local/bin"
		@@ -63,170 +79,192 @@ cd rmptui
63	79		cargo run --release
64	80		```
65	81
66		−	To build and run without installing, use `cargo run --release`.
	82	+	## Configuration
67	83
68		−	On first launch, rmptui creates a default configuration file at
	84	+	On first launch rmptui writes a fully commented configuration to
69	85		`$CONFIG_HOME/rmptui/config.toml`. If `CONFIG_HOME` is not set, it uses
70	86		`$XDG_CONFIG_HOME/rmptui/config.toml`, then `~/.config/rmptui/config.toml`.
71		−	Edit the file and restart rmptui to apply changes:
	87	+	Use `rmptui --config FILE` to load a different file, and
	88	+	`rmptui --print-default-config` to see every option with its default. Restart
	89	+	rmptui to apply changes.
	90	+
	91	+	You only need to keep the settings you change: anything left out keeps its
	92	+	default, table by table. Unknown options and conflicting key bindings are
	93	+	reported with the file and the offending value.
	94	+
	95	+	> Upgrading from 0.1: the configuration format changed. rmptui refuses to
	96	+	> start with a 0.1 file and tells you so; move the old file aside, start
	97	+	> rmptui to generate the new one, and copy your MPD settings over.
	98	+
	99	+	The main sections:
72	100
73	101		```toml
74	102		[mpd]
75		−	host = "127.0.0.1"
	103	+	host = "127.0.0.1" # or a Unix socket path such as "~/.config/mpd/socket"
76	104		port = 6600
77		−	password = "" # Set this only if your MPD server requires a password.
	105	+	password = ""
	106	+	music_directory = "" # for the tag editor and local .lrc files (see below)
78	107
79	108		[playback]
80		−	seek_seconds = 2
81		−	volume_step = 2
82		−
83		−	[keybindings]
84		−	quit = ["q", "Ctrl+c"]
85		−	clear_queue = ["c", "C"]
86		−	toggle_pause = ["p"]
87		−	pause = ["s"]
88		−	toggle_repeat = ["r"]
89		−	toggle_random = ["z"]
90		−	open_playlist_menu = ["a"]
91		−	seek_forward = ["f"]
92		−	seek_backward = ["b"]
93		−	cycle_tabs = ["Tab"]
94		−	select_queue = ["1"]
95		−	select_browser = ["2"]
96		−	select_playlists = ["3"]
97		−	next_track = [">"]
98		−	previous_track = ["<"]
99		−	volume_up = ["=", "+"]
100		−	volume_down = ["-"]
101		−	toggle_mute = ["m"]
102		−	update_database = ["U"]
103		−	search = ["/"]
104		−	toggle_selected_item = ["Space"]
105		−	search_next = ["n"]
106		−	search_previous = ["N"]
107		−	move_down = ["j", "Down"]
108		−	move_up = ["k", "Up"]
109		−	activate = ["Enter", "l", "Right"]
110		−	go_back = ["h", "Left"]
111		−	go_to_top = ["g"]
112		−	go_to_bottom = ["G"]
113		−	queue_delete = ["d"]
114		−	queue_move_down = ["J"]
115		−	queue_move_up = ["K"]
116		−	playlist_rename = ["R"]
117		−	playlist_focus_contents = ["Right", "l"]
118		−	playlist_focus_list = ["Left", "h"]
119		−	playlist_delete_song = ["d"]
120		−	playlist_move_song_down = ["J"]
121		−	playlist_move_song_up = ["K"]
122		−	playlist_delete = ["D"]
123		−	playlist_load = ["Space", "Enter"]
124		−	popup_close = ["q", "Esc"]
125		−	popup_select = ["Enter"]
126		−	input_cancel = ["Esc"]
127		−	input_backspace = ["Backspace"]
128		−	input_cursor_left = ["Left"]
129		−	input_cursor_right = ["Right"]
130		−	input_submit = ["Enter"]
	109	+	seek_seconds = 5
	110	+	volume_step = 5
	111	+
	112	+	[ui]
	113	+	startup_screen = "queue"
	114	+	mouse = true
	115	+	confirm_clear_queue = false
	116	+	lyrics_pane = false
	117	+	song_columns = [ # queue, browser and playlist editor
	118	+	{ field = "artist", width = 34 },
	119	+	{ field = "track", width = 5 },
	120	+	{ field = "title", width = 33 },
	121	+	{ field = "album", width = 30 },
	122	+	{ field = "duration", width = 5 },
	123	+	]
	124	+
	125	+	[theme] # color names, 256-color indices or "#rrggbb"
	126	+	text = "reset"
	127	+	dim = "darkgray"
	128	+	selection_fg = "reset" # both "reset": reverse video, like ncmpcpp
	129	+	selection_bg = "reset"
	130	+	visualizer = ["blue", "cyan", "green", "yellow", "red"]
	131	+
	132	+	[lyrics]
	133	+	online = true # look up lyrics on lrclib.net
	134	+	cache = true
	135	+
	136	+	[visualizer]
	137	+	fifo = "/tmp/mpd.fifo"
131	138		```
132	139
133		−	Runtime errors and panic details are appended to `/tmp/rmptui.log`. If logging
134		−	cannot be initialized, rmptui prints a warning and continues without a log
135		−	file.
	140	+	The MPD connection can also be set with environment variables, which take
	141	+	precedence over the file:
136	142
137		−	Every listed action is configurable in `[keybindings]`; each value is an array
138		−	so actions can have multiple aliases. Remove an alias or set an action to `[]`
139		−	to disable it. A key can be a single character or a named key such as `Enter`,
140		−	`Esc`, `Tab`, `Space`, `Up`, `Down`, `Left`, `Right`, or `Backspace`. Add
141		−	modifiers with `Ctrl+`, `Alt+`, or `Shift+`, for example `Ctrl+x` or
142		−	`Alt+Enter`. Bindings are matched in the current UI context, so avoid assigning
143		−	the same key to different actions that can be active in the same context.
144		−	Characters typed into search and playlist-name fields remain text unless
145		−	configured as an input action.
	143	+	\| Variable \| Description \|
	144	+	\| --- \| --- \|
	145	+	\| `MPD_HOST` \| Hostname, address or Unix socket path. Use `password@host` to set both host and password. \|
	146	+	\| `MPD_PORT` \| Port; an explicit port in `MPD_HOST` takes precedence. \|
146	147
147		−	`playback.seek_seconds` sets the `seek_forward`/`seek_backward` distance, and
148		−	`playback.volume_step` sets the `volume_up`/`volume_down` amount. Supported
149		−	audio formats remain built in. The config stores an MPD password as plain text;
150		−	newly created config files are restricted to the current user.
	148	+	```sh
	149	+	MPD_HOST=192.168.1.20 MPD_PORT=6600 rmptui
	150	+	MPD_HOST='secret@localhost' rmptui
	151	+	MPD_HOST=~/.config/mpd/socket rmptui
	152	+	```
151	153
152		−	The MPD connection settings can also be overridden with environment variables:
	154	+	Logs (and panic details) are appended to `/tmp/rmptui.log`. Set
	155	+	`RMPTUI_LOG=debug` for more detail.
153	156
154		−	\| Variable \| Default \| Description \|
155		−	\| --- \| --- \| --- \|
156		−	\| `MPD_HOST` \| Config file \| MPD hostname or address. Use `password@host` to set both host and password. \|
157		−	\| `MPD_PORT` \| Config file \| MPD port; an explicit port in `MPD_HOST` takes precedence. \|
	157	+	### Visualizer
158	158
159		−	For example:
	159	+	The visualizer reads raw audio from an MPD fifo output. Add this to
	160	+	`mpd.conf` and restart MPD:
160	161
161		−	```sh
162		−	MPD_HOST=192.168.1.20 MPD_PORT=6600 ./target/release/rmptui
	162	+	```
	163	+	audio_output {
	164	+	type "fifo"
	165	+	name "Visualizer feed"
	166	+	path "/tmp/mpd.fifo"
	167	+	format "44100:16:2"
	168	+	}
163	169		```
164	170
165		−	Or, for a password-protected local server:
	171	+	`[visualizer]` must match the `path` and `format`. The fifo is only read while
	172	+	the Visualizer screen is visible.
166	173
167		−	```sh
168		−	MPD_HOST='secret@localhost' ./target/release/rmptui
169		−	```
	174	+	Like ncmpcpp, there are four styles: `wave` (the default), `wave_filled`,
	175	+	`spectrum` and `ellipse`. Set the startup one with `style` and press `Space` on
	176	+	the screen to cycle through them. With `stereo = true` the wave styles draw the
	177	+	left channel in the top half and the right channel in the bottom half.
170	178
171		−	## Controls
	179	+	### Lyrics
172	180
173		−	The keys below are the defaults; edit the `[keybindings]` table above to change
174		−	them.
	181	+	Lyrics are looked up in this order:
175	182
176		−	### Navigation
	183	+	1. An `.lrc` file next to the song (`Song.flac` → `Song.lrc`), when the music
	184	+	directory is known.
	185	+	2. The cache in `$XDG_CACHE_HOME/rmptui/lyrics` (`~/.cache` by default).
	186	+	3. [LRCLIB](https://lrclib.net), a free lyrics database. Results are cached.
177	187
178		−	\| Key \| Action \|
179		−	\| --- \| --- \|
180		−	\| `Tab` \| Cycle between Queue, Browser, and Playlists \|
181		−	\| `1` / `2` / `3` \| Open Queue / Browser / Playlists \|
182		−	\| `j` / `Down` \| Move selection down \|
183		−	\| `k` / `Up` \| Move selection up \|
184		−	\| `g` / `G` \| Jump to the top / bottom of the current list \|
185		−	\| `Enter` / `l` / `Right` \| Activate the selected item \|
186		−	\| `h` / `Left` \| Go to the parent directory in the browser \|
187		−	\| `q` / `Ctrl+C` \| Quit \|
	188	+	Set `lyrics.online = false` to stay offline. `F5` on the Lyrics screen fetches
	189	+	the lyrics of the current song again.
	190	+
	191	+	### Tag editor
188	192
189		−	### Search
	193	+	MPD cannot change tags, so the tag editor writes the files directly, which
	194	+	requires the music files to be on this machine. rmptui finds the music
	195	+	directory in this order: `mpd.music_directory` in its config, MPD itself (only
	196	+	answered over a Unix socket), and finally `music_directory` from the local
	197	+	MPD's `mpd.conf` (`$XDG_CONFIG_HOME/mpd/mpd.conf`, `~/.config/mpd/mpd.conf`,
	198	+	`~/.mpdconf`, `~/.mpd/mpd.conf` or `/etc/mpd.conf`) when MPD runs on this
	199	+	machine.
190	200
191		−	1. Press `/` and type a query.
192		−	2. In the browser, press `Enter` to keep the query and return to the list.
193		−	3. Press `n` for the next fuzzy match or `N` for the previous match. Results
194		−	wrap around when you reach either end.
195		−	4. Press `/` to start a new search, or `Esc` to cancel search input.
	201	+	Highlight a directory to see its songs in the `Tags` column, which shows the
	202	+	tag selected in `Tag types`. `Enter` on a tag type edits it for all marked
	203	+	songs (or all songs), `Enter` on a song edits it for that song only, and
	204	+	`Filename` renames files. Changes stay pending until you choose `Save` (or
	205	+	press `w`); `Reset` (or `u`) discards them. After saving, rmptui asks MPD to
	206	+	rescan the folder.
196	207
197		−	Search matches the names shown in the current view. Browser search includes
198		−	both folders and songs.
	208	+	## Key bindings
199	209
200		−	### Playback and queue
	210	+	These are the defaults; every binding is configurable in the `[keys.*]` tables
	211	+	of the config. `?` shows the active bindings inside rmptui.
	212	+
	213	+	Bindings are grouped by context. A key is looked up in the focused popup or
	214	+	screen first, then in `navigation`, then in `global`, so screen bindings
	215	+	shadow global ones on that screen (for example `R` renames a playlist on the
	216	+	Playlists screen and toggles consume elsewhere).
	217	+
	218	+	### Global
201	219
202	220		\| Key \| Action \|
203	221		\| --- \| --- \|
	222	+	\| `1`–`7` \| Switch screen \|
	223	+	\| `Tab` / `Shift+Tab` \| Next / previous screen \|
204	224		\| `p` \| Toggle play/pause \|
205		−	\| `s` \| Pause \|
206		−	\| `>` / `<` \| Play next / previous track \|
207		−	\| `f` / `b` \| Seek forward / backward by two seconds \|
208		−	\| `+` / `=` / `-` \| Increase / decrease volume \|
	225	+	\| `s` / `x` \| Pause / stop \|
	226	+	\| `>` / `<` \| Next / previous track \|
	227	+	\| `f` / `b` \| Seek forward / backward \|
	228	+	\| `+` `=` / `-` \| Volume up / down \|
209	229		\| `m` \| Toggle mute \|
210		−	\| `r` / `z` \| Toggle repeat / random \|
211		−	\| `d` \| Remove the selected queue item \|
212		−	\| `Space` \| Remove a queue item; toggle a browser song in the queue \|
213		−	\| `J` / `K` \| Move the selected queue item down / up \|
	230	+	\| `r` `z` `y` `R` \| Toggle repeat, random, single, consume \|
214	231		\| `c` \| Clear the queue \|
215		−	\| `a` \| Open the add-to-playlist menu \|
216		−	\| `U` \| Rescan the MPD music database \|
217		−
218		−	### Playlists
	232	+	\| `U` \| Rescan the music database \|
	233	+	\| `?` `F1` \| Show key bindings \|
	234	+	\| `q` `Ctrl+c` \| Quit \|
219	235
220		−	The Playlists view has a playlist pane and a contents pane. Select a playlist
221		−	with `j`/`k` and press `Space` or `Enter` to load it into the queue and start
222		−	playback. Press `Right` or `l` to focus its songs and `Left` or `h` to return
223		−	to the playlist pane. In the contents pane, `j`/`k` selects a song, `Enter`
224		−	plays it, `d` removes it from the saved playlist, and `J`/`K` moves it
225		−	down/up. `D` deletes the selected saved playlist. `R` renames a playlist.
	236	+	### Lists
226	237
227		−	Press `a` to open the add-to-playlist menu; choose Current Playlist, **New
228		−	Playlist**, or a saved playlist. When creating a playlist, type its name and
229		−	press `Enter` to save. Playlist contents update after each edit.
	238	+	\| Key \| Action \|
	239	+	\| --- \| --- \|
	240	+	\| `j` `k` / arrows \| Move down / up \|
	241	+	\| `g` `G` / `Home` `End` \| Top / bottom \|
	242	+	\| `Ctrl+d` `Ctrl+u`, `PageDown` `PageUp` \| Half page / page \|
	243	+	\| `h` `l` / arrows \| Back or previous column / open or next column \|
	244	+	\| `Enter` \| Play or open the selected item \|
	245	+	\| `Space` \| Add to the queue (toggles songs in the browser) \|
	246	+	\| `a` \| Add to the queue, a new playlist or an existing one \|
	247	+	\| `v` / `V` \| Mark item / clear marks \|
	248	+	\| `/`, `n` / `N` \| Search, next / previous match \|
	249	+
	250	+	### Screens
	251	+
	252	+	\| Screen \| Key \| Action \|
	253	+	\| --- \| --- \| --- \|
	254	+	\| Queue \| `d` `Delete` \| Remove the song (or all marked songs) \|
	255	+	\| Queue \| `J` / `K` \| Move the song down / up \|
	256	+	\| Queue \| `Z` / `S` \| Shuffle / save as playlist \|
	257	+	\| Queue \| `o` \| Jump to the playing song \|
	258	+	\| Queue \| `L` \| Toggle the lyrics pane \|
	259	+	\| Playlists \| `d`, `J` / `K` \| Remove / move the selected song \|
	260	+	\| Playlists \| `R` / `D` \| Rename / delete the playlist \|
	261	+	\| Library \| `t` \| Switch between AlbumArtist and Artist \|
	262	+	\| Tags \| `Enter` \| Edit a tag, rename a file, or run the highlighted action \|
	263	+	\| Tags \| `w` / `u` \| Write / discard pending changes \|
	264	+	\| Lyrics \| `F5` \| Fetch lyrics again \|
	265	+
	266	+	In text fields, `Enter` submits, `Esc` cancels, `Ctrl+w` deletes a word and
	267	+	`Ctrl+a` / `Ctrl+e` jump to the start / end.
230	268
231	269		## License
232	270

	@@ -0,0 +1,323 @@
1	+	//! Every user-triggerable action and the key contexts they are bound in.
2	+
3	+	use std::{fmt, str::FromStr};
4	+
5	+	use serde::{Deserialize, Deserializer, de};
6	+
7	+	macro_rules! named_enum {
8	+	(
9	+	$(#[$meta:meta])*
10	+	pub enum $name:ident { $($variant:ident = $str:literal),* $(,)? }
11	+	) => {
12	+	$(#[$meta])*
13	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
14	+	pub enum $name { $($variant),* }
15	+
16	+	impl $name {
17	+	pub const ALL: &[Self] = &[$(Self::$variant),*];
18	+
19	+	pub fn name(self) -> &'static str {
20	+	match self { $(Self::$variant => $str),* }
21	+	}
22	+	}
23	+
24	+	impl fmt::Display for $name {
25	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
26	+	f.write_str(self.name())
27	+	}
28	+	}
29	+
30	+	impl FromStr for $name {
31	+	type Err = String;
32	+
33	+	fn from_str(s: &str) -> Result<Self, Self::Err> {
34	+	Self::ALL
35	+	.iter()
36	+	.copied()
37	+	.find(\|v\| v.name() == s)
38	+	.ok_or_else(\|\| {
39	+	let names: Vec<_> = Self::ALL.iter().map(\|v\| v.name()).collect();
40	+	format!("unknown value `{s}`, expected one of: {}", names.join(", "))
41	+	})
42	+	}
43	+	}
44	+
45	+	impl<'de> Deserialize<'de> for $name {
46	+	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
47	+	let s = String::deserialize(deserializer)?;
48	+	s.parse().map_err(de::Error::custom)
49	+	}
50	+	}
51	+	};
52	+	}
53	+
54	+	named_enum! {
55	+	/// A set of bindings that is active in a certain part of the UI.
56	+	///
57	+	/// Lookups go from the most specific context (popup or screen) through
58	+	/// `navigation` to `global`, so specific bindings shadow general ones.
59	+	pub enum Context {
60	+	Global = "global",
61	+	Navigation = "navigation",
62	+	Queue = "queue",
63	+	Browser = "browser",
64	+	Playlists = "playlists",
65	+	Library = "library",
66	+	TagEditor = "tag_editor",
67	+	Visualizer = "visualizer",
68	+	Lyrics = "lyrics",
69	+	Popup = "popup",
70	+	Input = "input",
71	+	}
72	+	}
73	+
74	+	named_enum! {
75	+	pub enum Action {
76	+	// Global
77	+	Quit = "quit",
78	+	Help = "help",
79	+	TogglePause = "toggle_pause",
80	+	Pause = "pause",
81	+	Stop = "stop",
82	+	NextTrack = "next_track",
83	+	PreviousTrack = "previous_track",
84	+	SeekForward = "seek_forward",
85	+	SeekBackward = "seek_backward",
86	+	VolumeUp = "volume_up",
87	+	VolumeDown = "volume_down",
88	+	ToggleMute = "toggle_mute",
89	+	ToggleRepeat = "toggle_repeat",
90	+	ToggleRandom = "toggle_random",
91	+	ToggleSingle = "toggle_single",
92	+	ToggleConsume = "toggle_consume",
93	+	UpdateDatabase = "update_database",
94	+	NextScreen = "next_screen",
95	+	PreviousScreen = "previous_screen",
96	+	ScreenQueue = "screen_queue",
97	+	ScreenBrowser = "screen_browser",
98	+	ScreenPlaylists = "screen_playlists",
99	+	ScreenLibrary = "screen_library",
100	+	ScreenTagEditor = "screen_tag_editor",
101	+	ScreenVisualizer = "screen_visualizer",
102	+	ScreenLyrics = "screen_lyrics",
103	+	// Navigation (lists)
104	+	Up = "up",
105	+	Down = "down",
106	+	Top = "top",
107	+	Bottom = "bottom",
108	+	PageUp = "page_up",
109	+	PageDown = "page_down",
110	+	HalfPageUp = "half_page_up",
111	+	HalfPageDown = "half_page_down",
112	+	Left = "left",
113	+	Right = "right",
114	+	Activate = "activate",
115	+	ToggleMark = "toggle_mark",
116	+	ClearMarks = "clear_marks",
117	+	Search = "search",
118	+	SearchNext = "search_next",
119	+	SearchPrevious = "search_previous",
120	+	AddToQueue = "add_to_queue",
121	+	AddToPlaylist = "add_to_playlist",
122	+	// Screen specific
123	+	Delete = "delete",
124	+	MoveItemUp = "move_item_up",
125	+	MoveItemDown = "move_item_down",
126	+	ClearQueue = "clear_queue",
127	+	ShuffleQueue = "shuffle_queue",
128	+	SaveQueue = "save_queue",
129	+	JumpToCurrent = "jump_to_current",
130	+	ToggleLyricsPane = "toggle_lyrics_pane",
131	+	DeletePlaylist = "delete_playlist",
132	+	RenamePlaylist = "rename_playlist",
133	+	ToggleArtistTag = "toggle_artist_tag",
134	+	SaveTags = "save_tags",
135	+	RevertTags = "revert_tags",
136	+	CycleVisualizer = "cycle_visualizer",
137	+	ReloadLyrics = "reload_lyrics",
138	+	// Popups and text input
139	+	Close = "close",
140	+	Submit = "submit",
141	+	Cancel = "cancel",
142	+	Backspace = "backspace",
143	+	DeleteChar = "delete_char",
144	+	DeleteWord = "delete_word",
145	+	CursorLeft = "cursor_left",
146	+	CursorRight = "cursor_right",
147	+	CursorHome = "cursor_home",
148	+	CursorEnd = "cursor_end",
149	+	}
150	+	}
151	+
152	+	named_enum! {
153	+	/// The screens, in tab order.
154	+	pub enum ScreenId {
155	+	Queue = "queue",
156	+	Browser = "browser",
157	+	Playlists = "playlists",
158	+	Library = "library",
159	+	TagEditor = "tag_editor",
160	+	Visualizer = "visualizer",
161	+	Lyrics = "lyrics",
162	+	}
163	+	}
164	+
165	+	impl ScreenId {
166	+	pub fn title(self) -> &'static str {
167	+	match self {
168	+	Self::Queue => "Queue",
169	+	Self::Browser => "Browse",
170	+	Self::Playlists => "Playlists",
171	+	Self::Library => "Library",
172	+	Self::TagEditor => "Tags",
173	+	Self::Visualizer => "Visualizer",
174	+	Self::Lyrics => "Lyrics",
175	+	}
176	+	}
177	+
178	+	/// The key context that is active while the screen is focused.
179	+	pub fn context(self) -> Context {
180	+	match self {
181	+	Self::Queue => Context::Queue,
182	+	Self::Browser => Context::Browser,
183	+	Self::Playlists => Context::Playlists,
184	+	Self::Library => Context::Library,
185	+	Self::TagEditor => Context::TagEditor,
186	+	Self::Visualizer => Context::Visualizer,
187	+	Self::Lyrics => Context::Lyrics,
188	+	}
189	+	}
190	+
191	+	fn index(self) -> usize {
192	+	Self::ALL.iter().position(\|&s\| s == self).unwrap_or(0)
193	+	}
194	+
195	+	pub fn next(self) -> Self {
196	+	Self::ALL[(self.index() + 1) % Self::ALL.len()]
197	+	}
198	+
199	+	pub fn previous(self) -> Self {
200	+	Self::ALL[(self.index() + Self::ALL.len() - 1) % Self::ALL.len()]
201	+	}
202	+	}
203	+
204	+	impl Action {
205	+	/// The contexts this action may be bound in.
206	+	pub fn contexts(self) -> &'static [Context] {
207	+	use Action::*;
208	+	use Context as C;
209	+	match self {
210	+	Quit \| Help \| TogglePause \| Pause \| Stop \| NextTrack \| PreviousTrack \| SeekForward
211	+	\| SeekBackward \| VolumeUp \| VolumeDown \| ToggleMute \| ToggleRepeat \| ToggleRandom
212	+	\| ToggleSingle \| ToggleConsume \| UpdateDatabase \| NextScreen \| PreviousScreen
213	+	\| ScreenQueue \| ScreenBrowser \| ScreenPlaylists \| ScreenLibrary \| ScreenTagEditor
214	+	\| ScreenVisualizer \| ScreenLyrics \| ClearQueue => &[C::Global],
215	+	Up \| Down \| Top \| Bottom \| PageUp \| PageDown \| HalfPageUp \| HalfPageDown \| Left
216	+	\| Right \| Activate \| ToggleMark \| ClearMarks \| Search \| SearchNext \| SearchPrevious
217	+	\| AddToQueue \| AddToPlaylist => &[C::Navigation],
218	+	Delete \| MoveItemUp \| MoveItemDown => &[C::Queue, C::Playlists],
219	+	ShuffleQueue \| SaveQueue \| JumpToCurrent \| ToggleLyricsPane => &[C::Queue],
220	+	DeletePlaylist \| RenamePlaylist => &[C::Playlists],
221	+	ToggleArtistTag => &[C::Library],
222	+	SaveTags \| RevertTags => &[C::TagEditor],
223	+	CycleVisualizer => &[C::Visualizer],
224	+	ReloadLyrics => &[C::Lyrics],
225	+	Close => &[C::Popup],
226	+	Submit \| Cancel \| Backspace \| DeleteChar \| DeleteWord \| CursorLeft \| CursorRight
227	+	\| CursorHome \| CursorEnd => &[C::Input],
228	+	}
229	+	}
230	+
231	+	/// A short human-readable description for the help popup.
232	+	pub fn description(self) -> &'static str {
233	+	use Action::*;
234	+	match self {
235	+	Quit => "Quit rmptui",
236	+	Help => "Show key bindings",
237	+	TogglePause => "Toggle play/pause",
238	+	Pause => "Pause",
239	+	Stop => "Stop playback",
240	+	NextTrack => "Play next track",
241	+	PreviousTrack => "Play previous track",
242	+	SeekForward => "Seek forward",
243	+	SeekBackward => "Seek backward",
244	+	VolumeUp => "Increase volume",
245	+	VolumeDown => "Decrease volume",
246	+	ToggleMute => "Toggle mute",
247	+	ToggleRepeat => "Toggle repeat",
248	+	ToggleRandom => "Toggle random",
249	+	ToggleSingle => "Toggle single",
250	+	ToggleConsume => "Toggle consume",
251	+	UpdateDatabase => "Rescan the music database",
252	+	NextScreen => "Next screen",
253	+	PreviousScreen => "Previous screen",
254	+	ScreenQueue => "Show the queue",
255	+	ScreenBrowser => "Show the song browser",
256	+	ScreenPlaylists => "Show the playlist editor",
257	+	ScreenLibrary => "Show the media library",
258	+	ScreenTagEditor => "Show the tag editor",
259	+	ScreenVisualizer => "Show the visualizer",
260	+	ScreenLyrics => "Show the lyrics",
261	+	Up => "Move up",
262	+	Down => "Move down",
263	+	Top => "Go to top",
264	+	Bottom => "Go to bottom",
265	+	PageUp => "Page up",
266	+	PageDown => "Page down",
267	+	HalfPageUp => "Half page up",
268	+	HalfPageDown => "Half page down",
269	+	Left => "Go back / previous column",
270	+	Right => "Open / next column",
271	+	Activate => "Play or open the selected item",
272	+	ToggleMark => "Mark or unmark the item",
273	+	ClearMarks => "Clear all marks",
274	+	Search => "Search the current list",
275	+	SearchNext => "Next search match",
276	+	SearchPrevious => "Previous search match",
277	+	AddToQueue => "Add to (or toggle in) the queue",
278	+	AddToPlaylist => "Add to a playlist",
279	+	Delete => "Remove the item",
280	+	MoveItemUp => "Move the item up",
281	+	MoveItemDown => "Move the item down",
282	+	ClearQueue => "Clear the queue",
283	+	ShuffleQueue => "Shuffle the queue",
284	+	SaveQueue => "Save the queue as a playlist",
285	+	JumpToCurrent => "Jump to the playing song",
286	+	ToggleLyricsPane => "Toggle the lyrics pane",
287	+	DeletePlaylist => "Delete the playlist",
288	+	RenamePlaylist => "Rename the playlist",
289	+	ToggleArtistTag => "Switch between AlbumArtist and Artist",
290	+	SaveTags => "Write pending tag changes",
291	+	RevertTags => "Discard pending tag changes",
292	+	CycleVisualizer => "Switch to the next visualizer style",
293	+	ReloadLyrics => "Fetch lyrics again",
294	+	Close => "Close the popup",
295	+	Submit => "Submit",
296	+	Cancel => "Cancel",
297	+	Backspace => "Delete previous character",
298	+	DeleteChar => "Delete next character",
299	+	DeleteWord => "Delete previous word",
300	+	CursorLeft => "Cursor left",
301	+	CursorRight => "Cursor right",
302	+	CursorHome => "Cursor to start",
303	+	CursorEnd => "Cursor to end",
304	+	}
305	+	}
306	+	}
307	+
308	+	#[cfg(test)]
309	+	mod tests {
310	+	use super::*;
311	+
312	+	#[test]
313	+	fn names_round_trip() {
314	+	for action in Action::ALL {
315	+	assert_eq!(action.name().parse::<Action>().unwrap(), *action);
316	+	assert!(!action.contexts().is_empty());
317	+	}
318	+	for context in Context::ALL {
319	+	assert_eq!(context.name().parse::<Context>().unwrap(), *context);
320	+	}
321	+	assert!("nope".parse::<Action>().is_err());
322	+	}
323	+	}

	@@ -1,164 +0,0 @@
1	−	use std::path::Path;
2	−
3	−	use crate::{
4	−	connection::{Connection, Song},
5	−	utils::is_audio_file,
6	−	AppResult,
7	−	};
8	−
9	−	#[derive(Debug, Default)]
10	−	pub struct FileBrowser {
11	−	pub entries: Vec<BrowserEntry>,
12	−	pub selected: usize,
13	−	pub prev_selected: usize,
14	−	pub path: String,
15	−	}
16	−
17	−	#[derive(Clone, Debug, PartialEq, Eq)]
18	−	pub enum BrowserEntry {
19	−	Directory(String),
20	−	Song(Song),
21	−	}
22	−
23	−	impl BrowserEntry {
24	−	pub fn name(&self) -> &str {
25	−	match self {
26	−	Self::Directory(path) => Path::new(path)
27	−	.file_name()
28	−	.and_then(\|name\| name.to_str())
29	−	.unwrap_or(path),
30	−	Self::Song(song) => Path::new(&song.file)
31	−	.file_name()
32	−	.and_then(\|name\| name.to_str())
33	−	.unwrap_or(&song.file),
34	−	}
35	−	}
36	−	}
37	−
38	−	impl FileBrowser {
39	−	pub fn new() -> Self {
40	−	Self {
41	−	path: ".".to_string(),
42	−	..Self::default()
43	−	}
44	−	}
45	−
46	−	pub async fn update_directory(&mut self, conn: &mut Connection) -> AppResult<()> {
47	−	let query_path = self.path.trim_start_matches("./").trim_matches('/');
48	−	let (directories, songs) = conn.ls_info(query_path).await?;
49	−	let mut entries = Vec::new();
50	−	for directory in directories {
51	−	if let Some(name) = Path::new(&directory)
52	−	.file_name()
53	−	.and_then(\|name\| name.to_str())
54	−	{
55	−	if !name.starts_with('.') {
56	−	entries.push(BrowserEntry::Directory(directory));
57	−	}
58	−	}
59	−	}
60	−
61	−	for song in songs {
62	−	let Some(name) = Path::new(&song.file)
63	−	.file_name()
64	−	.and_then(\|name\| name.to_str())
65	−	else {
66	−	continue;
67	−	};
68	−	if is_audio_file(name) {
69	−	entries.push(BrowserEntry::Song(song));
70	−	}
71	−	}
72	−
73	−	entries.sort_by(\|a, b\| {
74	−	let kind_order = \|entry: &BrowserEntry\| match entry {
75	−	BrowserEntry::Directory(_) => 0,
76	−	BrowserEntry::Song(_) => 1,
77	−	};
78	−	kind_order(a).cmp(&kind_order(b)).then_with(\|\| {
79	−	let name_a = a.name();
80	−	let name_b = b.name();
81	−	let number_a = name_a.parse::<u32>().unwrap_or(u32::MAX);
82	−	let number_b = name_b.parse::<u32>().unwrap_or(u32::MAX);
83	−	number_a
84	−	.cmp(&number_b)
85	−	.then_with(\|\| name_a.to_lowercase().cmp(&name_b.to_lowercase()))
86	−	})
87	−	});
88	−
89	−	self.entries = entries;
90	−	self.selected = self.selected.min(self.entries.len().saturating_sub(1));
91	−	Ok(())
92	−	}
93	−
94	−	pub fn next(&mut self) {
95	−	if self.selected < self.entries.len().saturating_sub(1) {
96	−	self.selected += 1;
97	−	}
98	−	}
99	−
100	−	pub fn prev(&mut self) {
101	−	self.selected = self.selected.saturating_sub(1);
102	−	}
103	−
104	−	pub async fn handle_go_back(&mut self, conn: &mut Connection) -> AppResult<()> {
105	−	if self.path != "." {
106	−	self.path = Path::new(&self.path)
107	−	.parent()
108	−	.and_then(Path::to_str)
109	−	.filter(\|path\| !path.is_empty())
110	−	.unwrap_or(".")
111	−	.to_string();
112	−	self.update_directory(conn).await?;
113	−	}
114	−	self.selected = self.prev_selected.min(self.entries.len().saturating_sub(1));
115	−	Ok(())
116	−	}
117	−	}
118	−
119	−	#[cfg(test)]
120	−	mod tests {
121	−	use super::*;
122	−	use tokio::{
123	−	io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
124	−	net::TcpListener,
125	−	};
126	−
127	−	#[tokio::test]
128	−	async fn preserves_mpd_directory_uris_and_displays_their_basename() {
129	−	let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
130	−	let address = listener.local_addr().unwrap();
131	−	let server = tokio::spawn(async move {
132	−	let (stream, _) = listener.accept().await.unwrap();
133	−	let mut stream = BufReader::new(stream);
134	−	stream
135	−	.get_mut()
136	−	.write_all(b"OK MPD 0.23.0\n")
137	−	.await
138	−	.unwrap();
139	−
140	−	for response in ["OK\n", "OK\n", "OK\n", "directory: library/Artist\nOK\n"] {
141	−	let mut command = String::new();
142	−	stream.read_line(&mut command).await.unwrap();
143	−	stream
144	−	.get_mut()
145	−	.write_all(response.as_bytes())
146	−	.await
147	−	.unwrap();
148	−	}
149	−	});
150	−
151	−	let mut conn = Connection::connect(&address.to_string(), None)
152	−	.await
153	−	.unwrap();
154	−	let mut browser = FileBrowser::new();
155	−	browser.update_directory(&mut conn).await.unwrap();
156	−
157	−	assert_eq!(
158	−	browser.entries,
159	−	vec![BrowserEntry::Directory("library/Artist".to_string())]
160	−	);
161	−	assert_eq!(browser.entries[0].name(), "Artist");
162	−	server.await.unwrap();
163	−	}
164	−	}

	@@ -0,0 +1,221 @@
1	+	# rmptui configuration
2	+	#
3	+	# Every option is shown with its default value. Settings you leave out keep
4	+	# their defaults, so you can trim this file down to the parts you change.
5	+	# Restart rmptui to apply changes.
6	+
7	+	[mpd]
8	+	# Hostname, IP address, or the path of MPD's Unix socket (starting with `/`
9	+	# or `~`). Overridden by the MPD_HOST environment variable, which also accepts
10	+	# `password@host`.
11	+	host = "127.0.0.1"
12	+	# Overridden by MPD_PORT. Ignored for Unix sockets.
13	+	port = 6600
14	+	# Set this only if your MPD server requires a password. It is stored in plain
15	+	# text; rmptui creates this file readable only by you.
16	+	password = ""
17	+	# The music directory on this machine, required by the tag editor and for
18	+	# `.lrc` files stored next to songs. Leave empty to ask MPD, which only answers
19	+	# over a Unix socket.
20	+	music_directory = ""
21	+
22	+	[playback]
23	+	# Seconds moved by seek_forward / seek_backward.
24	+	seek_seconds = 5
25	+	# Percent changed by volume_up / volume_down.
26	+	volume_step = 5
27	+
28	+	[ui]
29	+	# Screen shown on startup: queue, browser, playlists, library, tag_editor,
30	+	# visualizer or lyrics.
31	+	startup_screen = "queue"
32	+	# Enable mouse support (click to select, double-click to play/open, wheel to
33	+	# scroll, click the progress bar to seek).
34	+	mouse = true
35	+	# Ask before clearing the queue.
36	+	confirm_clear_queue = false
37	+	# Show the lyrics pane next to the queue on startup (toggle with `L`).
38	+	lyrics_pane = false
39	+	# Width of the lyrics pane in percent of the screen.
40	+	lyrics_pane_width = 40
41	+	# Seconds a status message stays visible.
42	+	message_timeout = 4
43	+	# Columns of the song tables (queue, browser, playlist contents). `field` is
44	+	# one of artist, album_artist, title, album, track, disc, date, genre,
45	+	# duration or file. `width` is a relative weight, except for track, disc and
46	+	# duration, where it is a fixed number of characters.
47	+	song_columns = [
48	+	{ field = "artist", width = 34 },
49	+	{ field = "track", width = 5 },
50	+	{ field = "title", width = 33 },
51	+	{ field = "album", width = 30 },
52	+	{ field = "duration", width = 5 },
53	+	]
54	+
55	+	[theme]
56	+	# Colors are names (black, red, green, yellow, blue, magenta, cyan, gray,
57	+	# darkgray, lightred, …, white, reset), 256-color indices ("208") or hex
58	+	# values ("#c694ff"). "reset" is your terminal's default color.
59	+	text = "reset"
60	+	dim = "darkgray"
61	+	# Horizontal and vertical separator lines.
62	+	border = "gray"
63	+	# The selected row. With both set to "reset", the row is shown in reverse
64	+	# video like ncmpcpp.
65	+	selection_fg = "reset"
66	+	selection_bg = "reset"
67	+	playing = "reset"
68	+	marked = "yellow"
69	+	directory = "reset"
70	+	error = "red"
71	+	# Song table columns.
72	+	artist = "reset"
73	+	track = "darkgray"
74	+	album = "reset"
75	+	duration = "reset"
76	+	# The filled part of the progress bar.
77	+	progress = "gray"
78	+	# Visualizer bar gradient, from the bottom of the screen to the top.
79	+	visualizer = ["blue", "cyan", "green", "yellow", "red"]
80	+
81	+	[lyrics]
82	+	# Look up lyrics on https://lrclib.net when no local `.lrc` file exists.
83	+	online = true
84	+	# Keep fetched lyrics in $XDG_CACHE_HOME/rmptui/lyrics (~/.cache by default).
85	+	cache = true
86	+	lrclib_url = "https://lrclib.net"
87	+
88	+	[visualizer]
89	+	# Path of an MPD fifo output. Add this to mpd.conf:
90	+	#
91	+	# audio_output {
92	+	# type "fifo"
93	+	# name "Visualizer feed"
94	+	# path "/tmp/mpd.fifo"
95	+	# format "44100:16:2"
96	+	# }
97	+	fifo = "/tmp/mpd.fifo"
98	+	# Startup style: wave, wave_filled, spectrum or ellipse. Press
99	+	# `cycle_visualizer` (Space) on the visualizer screen to switch.
100	+	style = "wave"
101	+	# Draw the left channel in the top half and the right one in the bottom half
102	+	# (wave styles only).
103	+	stereo = true
104	+	# Character used to draw the wave and ellipse styles.
105	+	wave_symbol = "●"
106	+	# Must match the `format` of the fifo output.
107	+	sample_rate = 44100
108	+	channels = 2
109	+	framerate = 60
110	+	bar_width = 2
111	+	bar_gap = 1
112	+	min_frequency = 40
113	+	max_frequency = 16000
114	+	# How fast bars fall, in screen heights per second.
115	+	falloff = 1.5
116	+
117	+	# Key bindings
118	+	#
119	+	# Each table is a context. Lookups start with the context of the focused
120	+	# popup or screen, then `navigation`, then `global`, so a key bound in a
121	+	# screen context shadows the same key in `global` on that screen.
122	+	#
123	+	# Each action takes a list of keys. A key is a character or one of Enter,
124	+	# Esc, Tab, Backspace, Delete, Insert, Space, Up, Down, Left, Right, Home,
125	+	# End, PageUp, PageDown and F1–F24, optionally prefixed by Ctrl+, Alt+ or
126	+	# Shift+ (e.g. "Ctrl+x", "Alt+Enter", "Shift+Tab"). Set an action to [] to
127	+	# unbind it; a key may only be used once per context.
128	+
129	+	[keys.global]
130	+	quit = ["q", "Ctrl+c"]
131	+	help = ["?", "F1"]
132	+	toggle_pause = ["p"]
133	+	pause = ["s"]
134	+	stop = ["x"]
135	+	next_track = [">"]
136	+	previous_track = ["<"]
137	+	seek_forward = ["f"]
138	+	seek_backward = ["b"]
139	+	volume_up = ["+", "="]
140	+	volume_down = ["-"]
141	+	toggle_mute = ["m"]
142	+	toggle_repeat = ["r"]
143	+	toggle_random = ["z"]
144	+	toggle_single = ["y"]
145	+	toggle_consume = ["R"]
146	+	update_database = ["U"]
147	+	clear_queue = ["c"]
148	+	next_screen = ["Tab"]
149	+	previous_screen = ["Shift+Tab"]
150	+	screen_queue = ["1"]
151	+	screen_browser = ["2"]
152	+	screen_playlists = ["3"]
153	+	screen_library = ["4"]
154	+	screen_tag_editor = ["5"]
155	+	screen_visualizer = ["6"]
156	+	screen_lyrics = ["7"]
157	+
158	+	[keys.navigation]
159	+	up = ["k", "Up"]
160	+	down = ["j", "Down"]
161	+	top = ["g", "Home"]
162	+	bottom = ["G", "End"]
163	+	page_up = ["PageUp"]
164	+	page_down = ["PageDown"]
165	+	half_page_up = ["Ctrl+u"]
166	+	half_page_down = ["Ctrl+d"]
167	+	left = ["h", "Left", "Backspace"]
168	+	right = ["l", "Right"]
169	+	activate = ["Enter"]
170	+	toggle_mark = ["v", "Insert"]
171	+	clear_marks = ["V"]
172	+	search = ["/"]
173	+	search_next = ["n"]
174	+	search_previous = ["N"]
175	+	add_to_queue = ["Space"]
176	+	add_to_playlist = ["a"]
177	+
178	+	[keys.queue]
179	+	delete = ["d", "Delete"]
180	+	move_item_up = ["K"]
181	+	move_item_down = ["J"]
182	+	shuffle_queue = ["Z"]
183	+	save_queue = ["S"]
184	+	jump_to_current = ["o"]
185	+	toggle_lyrics_pane = ["L"]
186	+
187	+	[keys.browser]
188	+
189	+	[keys.playlists]
190	+	delete = ["d", "Delete"]
191	+	move_item_up = ["K"]
192	+	move_item_down = ["J"]
193	+	delete_playlist = ["D"]
194	+	rename_playlist = ["R"]
195	+
196	+	[keys.library]
197	+	toggle_artist_tag = ["t"]
198	+
199	+	[keys.tag_editor]
200	+	save_tags = ["w"]
201	+	revert_tags = ["u"]
202	+
203	+	[keys.visualizer]
204	+	cycle_visualizer = ["Space"]
205	+
206	+	[keys.lyrics]
207	+	reload_lyrics = ["F5"]
208	+
209	+	[keys.popup]
210	+	close = ["q", "Esc"]
211	+
212	+	[keys.input]
213	+	submit = ["Enter"]
214	+	cancel = ["Esc"]
215	+	backspace = ["Backspace"]
216	+	delete_char = ["Delete"]
217	+	delete_word = ["Ctrl+w"]
218	+	cursor_left = ["Left"]
219	+	cursor_right = ["Right"]
220	+	cursor_home = ["Home", "Ctrl+a"]
221	+	cursor_end = ["End", "Ctrl+e"]

	@@ -0,0 +1,305 @@
1	+	//! Key specifications (`Ctrl+x`, `Space`, `F5`, …) and the context keymap.
2	+
3	+	use std::{
4	+	collections::{BTreeMap, HashMap},
5	+	fmt,
6	+	str::FromStr,
7	+	};
8	+
9	+	use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
10	+	use serde::{Deserialize, Deserializer, de};
11	+
12	+	use crate::action::{Action, Context};
13	+
14	+	/// A key with modifiers, normalized so that lookups ignore how terminals
15	+	/// report shifted characters.
16	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
17	+	pub struct KeyCombo {
18	+	pub code: KeyCode,
19	+	pub modifiers: KeyModifiers,
20	+	}
21	+
22	+	impl KeyCombo {
23	+	pub fn new(code: KeyCode, modifiers: KeyModifiers) -> Self {
24	+	let mut modifiers =
25	+	modifiers & (KeyModifiers::CONTROL \| KeyModifiers::ALT \| KeyModifiers::SHIFT);
26	+	let code = match code {
27	+	// `Shift+a` and `A` are the same key; the case carries the shift.
28	+	KeyCode::Char(c) if modifiers.contains(KeyModifiers::SHIFT) => {
29	+	modifiers.remove(KeyModifiers::SHIFT);
30	+	KeyCode::Char(c.to_uppercase().next().unwrap_or(c))
31	+	}
32	+	KeyCode::Tab if modifiers.contains(KeyModifiers::SHIFT) => {
33	+	modifiers.remove(KeyModifiers::SHIFT);
34	+	KeyCode::BackTab
35	+	}
36	+	KeyCode::BackTab => {
37	+	modifiers.remove(KeyModifiers::SHIFT);
38	+	KeyCode::BackTab
39	+	}
40	+	other => other,
41	+	};
42	+	Self { code, modifiers }
43	+	}
44	+
45	+	/// Whether this is a printable character without Ctrl/Alt, i.e. text.
46	+	pub fn as_text(&self) -> Option<char> {
47	+	match self.code {
48	+	KeyCode::Char(c)
49	+	if !self
50	+	.modifiers
51	+	.intersects(KeyModifiers::CONTROL \| KeyModifiers::ALT) =>
52	+	{
53	+	Some(c)
54	+	}
55	+	_ => None,
56	+	}
57	+	}
58	+	}
59	+
60	+	impl From<KeyEvent> for KeyCombo {
61	+	fn from(event: KeyEvent) -> Self {
62	+	Self::new(event.code, event.modifiers)
63	+	}
64	+	}
65	+
66	+	impl FromStr for KeyCombo {
67	+	type Err = String;
68	+
69	+	fn from_str(spec: &str) -> Result<Self, Self::Err> {
70	+	let mut modifiers = KeyModifiers::NONE;
71	+	let mut rest = spec;
72	+	// A lone `+` (or a trailing one, as in `Ctrl++`) is the plus key.
73	+	while let Some((modifier, tail)) = rest.split_once('+').filter(\|(m, _)\| !m.is_empty()) {
74	+	match modifier.to_ascii_lowercase().as_str() {
75	+	"ctrl" \| "control" => modifiers \|= KeyModifiers::CONTROL,
76	+	"alt" \| "meta" => modifiers \|= KeyModifiers::ALT,
77	+	"shift" => modifiers \|= KeyModifiers::SHIFT,
78	+	_ => return Err(format!("unknown modifier `{modifier}` in `{spec}`")),
79	+	}
80	+	rest = tail;
81	+	}
82	+	if rest.is_empty() {
83	+	return Err(format!("missing key in `{spec}`"));
84	+	}
85	+	let lower = rest.to_ascii_lowercase();
86	+	let code = match lower.as_str() {
87	+	"esc" \| "escape" => KeyCode::Esc,
88	+	"enter" \| "return" => KeyCode::Enter,
89	+	"tab" => KeyCode::Tab,
90	+	"backtab" => KeyCode::BackTab,
91	+	"backspace" => KeyCode::Backspace,
92	+	"delete" \| "del" => KeyCode::Delete,
93	+	"insert" \| "ins" => KeyCode::Insert,
94	+	"up" => KeyCode::Up,
95	+	"down" => KeyCode::Down,
96	+	"left" => KeyCode::Left,
97	+	"right" => KeyCode::Right,
98	+	"home" => KeyCode::Home,
99	+	"end" => KeyCode::End,
100	+	"pageup" \| "pgup" => KeyCode::PageUp,
101	+	"pagedown" \| "pgdn" => KeyCode::PageDown,
102	+	"space" => KeyCode::Char(' '),
103	+	_ => {
104	+	if let Some(n) = lower.strip_prefix('f').and_then(\|n\| n.parse::<u8>().ok()) {
105	+	if (1..=24).contains(&n) {
106	+	KeyCode::F(n)
107	+	} else {
108	+	return Err(format!("unknown key `{rest}` in `{spec}`"));
109	+	}
110	+	} else {
111	+	let mut chars = rest.chars();
112	+	match (chars.next(), chars.next()) {
113	+	(Some(c), None) => KeyCode::Char(c),
114	+	_ => return Err(format!("unknown key `{rest}` in `{spec}`")),
115	+	}
116	+	}
117	+	}
118	+	};
119	+	Ok(Self::new(code, modifiers))
120	+	}
121	+	}
122	+
123	+	impl fmt::Display for KeyCombo {
124	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
125	+	if self.modifiers.contains(KeyModifiers::CONTROL) {
126	+	f.write_str("Ctrl+")?;
127	+	}
128	+	if self.modifiers.contains(KeyModifiers::ALT) {
129	+	f.write_str("Alt+")?;
130	+	}
131	+	if self.modifiers.contains(KeyModifiers::SHIFT) {
132	+	f.write_str("Shift+")?;
133	+	}
134	+	match self.code {
135	+	KeyCode::Char(' ') => f.write_str("Space"),
136	+	KeyCode::Char(c) => write!(f, "{c}"),
137	+	KeyCode::F(n) => write!(f, "F{n}"),
138	+	KeyCode::BackTab => f.write_str("Shift+Tab"),
139	+	KeyCode::PageUp => f.write_str("PageUp"),
140	+	KeyCode::PageDown => f.write_str("PageDown"),
141	+	other => write!(f, "{other:?}"),
142	+	}
143	+	}
144	+	}
145	+
146	+	impl<'de> Deserialize<'de> for KeyCombo {
147	+	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
148	+	let s = String::deserialize(deserializer)?;
149	+	s.parse().map_err(de::Error::custom)
150	+	}
151	+	}
152	+
153	+	/// The `[keys.*]` tables as written in the config file.
154	+	pub type Bindings = BTreeMap<Context, BTreeMap<Action, Vec<KeyCombo>>>;
155	+
156	+	/// Resolved bindings: one lookup table per context.
157	+	#[derive(Clone, Debug, Default)]
158	+	pub struct Keymap {
159	+	contexts: HashMap<Context, HashMap<KeyCombo, Action>>,
160	+	bindings: Bindings,
161	+	}
162	+
163	+	impl Keymap {
164	+	/// Builds the keymap, rejecting actions bound in the wrong context and
165	+	/// keys bound twice within one context.
166	+	pub fn new(bindings: Bindings) -> Result<Self, String> {
167	+	let mut contexts: HashMap<Context, HashMap<KeyCombo, Action>> = HashMap::new();
168	+	for (&context, actions) in &bindings {
169	+	let table = contexts.entry(context).or_default();
170	+	for (&action, keys) in actions {
171	+	if !action.contexts().contains(&context) {
172	+	let allowed: Vec<_> = action.contexts().iter().map(\|c\| c.name()).collect();
173	+	return Err(format!(
174	+	"action `{action}` cannot be bound in [keys.{context}] (allowed in: {})",
175	+	allowed.join(", ")
176	+	));
177	+	}
178	+	for &key in keys {
179	+	if let Some(previous) = table.insert(key, action)
180	+	&& previous != action
181	+	{
182	+	return Err(format!(
183	+	"key `{key}` is bound to both `{previous}` and `{action}` in [keys.{context}]; \
184	+	unbind one of them (an action can be disabled with `action = []`)"
185	+	));
186	+	}
187	+	}
188	+	}
189	+	}
190	+	Ok(Self { contexts, bindings })
191	+	}
192	+
193	+	/// Finds the action for `key`, searching `contexts` in order.
194	+	pub fn resolve(&self, contexts: &[Context], key: KeyCombo) -> Option<Action> {
195	+	contexts
196	+	.iter()
197	+	.find_map(\|context\| self.contexts.get(context)?.get(&key).copied())
198	+	}
199	+
200	+	/// The keys bound to `action` in `context`, for help texts.
201	+	pub fn keys_for(&self, context: Context, action: Action) -> &[KeyCombo] {
202	+	self.bindings
203	+	.get(&context)
204	+	.and_then(\|actions\| actions.get(&action))
205	+	.map_or(&[], Vec::as_slice)
206	+	}
207	+
208	+	pub fn bindings(&self) -> &Bindings {
209	+	&self.bindings
210	+	}
211	+	}
212	+
213	+	#[cfg(test)]
214	+	mod tests {
215	+	use super::*;
216	+
217	+	fn key(spec: &str) -> KeyCombo {
218	+	spec.parse().unwrap()
219	+	}
220	+
221	+	#[test]
222	+	fn parses_specs() {
223	+	assert_eq!(
224	+	key("q"),
225	+	KeyCombo::new(KeyCode::Char('q'), KeyModifiers::NONE)
226	+	);
227	+	assert_eq!(
228	+	key("Ctrl+c"),
229	+	KeyCombo::new(KeyCode::Char('c'), KeyModifiers::CONTROL)
230	+	);
231	+	assert_eq!(
232	+	key("+"),
233	+	KeyCombo::new(KeyCode::Char('+'), KeyModifiers::NONE)
234	+	);
235	+	assert_eq!(
236	+	key("Ctrl++"),
237	+	KeyCombo::new(KeyCode::Char('+'), KeyModifiers::CONTROL)
238	+	);
239	+	assert_eq!(key("Space").code, KeyCode::Char(' '));
240	+	assert_eq!(key("F5").code, KeyCode::F(5));
241	+	assert_eq!(key("Shift+Tab").code, KeyCode::BackTab);
242	+	assert_eq!(key("Shift+g"), key("G"));
243	+	assert!("Hyper+x".parse::<KeyCombo>().is_err());
244	+	assert!("abc".parse::<KeyCombo>().is_err());
245	+	assert!("F99".parse::<KeyCombo>().is_err());
246	+	}
247	+
248	+	#[test]
249	+	fn normalizes_terminal_events() {
250	+	// Terminals report `G` with or without SHIFT.
251	+	let shifted = KeyCombo::from(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT));
252	+	assert_eq!(shifted, key("G"));
253	+	let backtab = KeyCombo::from(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
254	+	assert_eq!(backtab, key("Shift+Tab"));
255	+	}
256	+
257	+	#[test]
258	+	fn displays_specs() {
259	+	for spec in ["q", "Ctrl+c", "Space", "F5", "Enter", "Shift+Tab", "PageUp"] {
260	+	assert_eq!(key(spec).to_string(), spec);
261	+	}
262	+	}
263	+
264	+	#[test]
265	+	fn resolves_by_context_priority() {
266	+	let mut bindings = Bindings::new();
267	+	bindings
268	+	.entry(Context::Global)
269	+	.or_default()
270	+	.insert(Action::ToggleConsume, vec![key("R")]);
271	+	bindings
272	+	.entry(Context::Playlists)
273	+	.or_default()
274	+	.insert(Action::RenamePlaylist, vec![key("R")]);
275	+	let keymap = Keymap::new(bindings).unwrap();
276	+	assert_eq!(
277	+	keymap.resolve(&[Context::Playlists, Context::Global], key("R")),
278	+	Some(Action::RenamePlaylist)
279	+	);
280	+	assert_eq!(
281	+	keymap.resolve(&[Context::Queue, Context::Global], key("R")),
282	+	Some(Action::ToggleConsume)
283	+	);
284	+	}
285	+
286	+	#[test]
287	+	fn rejects_conflicts_and_misplaced_actions() {
288	+	let mut bindings = Bindings::new();
289	+	let global = bindings.entry(Context::Global).or_default();
290	+	global.insert(Action::Quit, vec![key("q")]);
291	+	global.insert(Action::Pause, vec![key("q")]);
292	+	assert!(Keymap::new(bindings).unwrap_err().contains("bound to both"));
293	+
294	+	let mut bindings = Bindings::new();
295	+	bindings
296	+	.entry(Context::Queue)
297	+	.or_default()
298	+	.insert(Action::Quit, vec![key("q")]);
299	+	assert!(
300	+	Keymap::new(bindings)
301	+	.unwrap_err()
302	+	.contains("cannot be bound")
303	+	);
304	+	}
305	+	}

	@@ -0,0 +1,554 @@
1	+	//! Configuration: loading, defaults, validation and the MPD address.
2	+	//!
3	+	//! `default.toml` is the single source of truth for defaults. A user file is
4	+	//! merged over it table by table, so partial files keep every default they
5	+	//! leave out.
6	+
7	+	mod keys;
8	+	mod mpd_conf;
9	+	mod theme;
10	+
11	+	use std::{
12	+	env,
13	+	fs::{self, OpenOptions},
14	+	io::{self, Write},
15	+	net::Ipv6Addr,
16	+	path::{Path, PathBuf},
17	+	time::Duration,
18	+	};
19	+
20	+	use serde::Deserialize;
21	+
22	+	pub use keys::{Bindings, KeyCombo, Keymap};
23	+	pub use mpd_conf::local_music_directory;
24	+	pub use theme::Theme;
25	+
26	+	use crate::{action::ScreenId, mpd::Address, util::expand_tilde};
27	+
28	+	pub const DEFAULT_CONFIG: &str = include_str!("default.toml");
29	+
30	+	#[derive(Debug, thiserror::Error)]
31	+	pub enum ConfigError {
32	+	#[error("cannot access {}: {source}", path.display())]
33	+	Io { path: PathBuf, source: io::Error },
34	+	#[error("invalid configuration in {}: {message}", path.display())]
35	+	Parse { path: PathBuf, message: String },
36	+	#[error("invalid configuration: {0}")]
37	+	Invalid(String),
38	+	#[error(
39	+	"{} uses the rmptui 0.1 format, which 0.2 no longer reads.\n\
40	+	Move it aside (e.g. to config.toml.old) and start rmptui again to \
41	+	generate a documented 0.2 configuration, then copy your settings over.",
42	+	.0.display()
43	+	)]
44	+	Legacy(PathBuf),
45	+	}
46	+
47	+	#[derive(Clone, Debug, Deserialize)]
48	+	#[serde(deny_unknown_fields)]
49	+	pub struct MpdConfig {
50	+	pub host: String,
51	+	pub port: u16,
52	+	pub password: String,
53	+	pub music_directory: String,
54	+	}
55	+
56	+	#[derive(Clone, Debug, Deserialize)]
57	+	#[serde(deny_unknown_fields)]
58	+	pub struct PlaybackConfig {
59	+	pub seek_seconds: u32,
60	+	pub volume_step: u8,
61	+	}
62	+
63	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
64	+	#[serde(rename_all = "snake_case")]
65	+	pub enum ColumnField {
66	+	Artist,
67	+	AlbumArtist,
68	+	Title,
69	+	Album,
70	+	Track,
71	+	Disc,
72	+	Date,
73	+	Genre,
74	+	Duration,
75	+	File,
76	+	}
77	+
78	+	impl ColumnField {
79	+	pub fn title(self) -> &'static str {
80	+	match self {
81	+	Self::Artist => "Artist",
82	+	Self::AlbumArtist => "Album Artist",
83	+	Self::Title => "Title",
84	+	Self::Album => "Album",
85	+	Self::Track => "Track",
86	+	Self::Disc => "Disc",
87	+	Self::Date => "Date",
88	+	Self::Genre => "Genre",
89	+	Self::Duration => "Time",
90	+	Self::File => "File",
91	+	}
92	+	}
93	+	}
94	+
95	+	#[derive(Clone, Copy, Debug, Deserialize)]
96	+	#[serde(deny_unknown_fields)]
97	+	pub struct Column {
98	+	pub field: ColumnField,
99	+	pub width: u16,
100	+	}
101	+
102	+	#[derive(Clone, Debug, Deserialize)]
103	+	#[serde(deny_unknown_fields)]
104	+	pub struct UiConfig {
105	+	pub startup_screen: ScreenId,
106	+	pub mouse: bool,
107	+	pub confirm_clear_queue: bool,
108	+	pub lyrics_pane: bool,
109	+	pub lyrics_pane_width: u16,
110	+	pub message_timeout: u64,
111	+	pub song_columns: Vec<Column>,
112	+	}
113	+
114	+	#[derive(Clone, Debug, Deserialize)]
115	+	#[serde(deny_unknown_fields)]
116	+	pub struct LyricsConfig {
117	+	pub online: bool,
118	+	pub cache: bool,
119	+	pub lrclib_url: String,
120	+	}
121	+
122	+	#[derive(Clone, Debug, Deserialize)]
123	+	#[serde(deny_unknown_fields)]
124	+	pub struct VisualizerConfig {
125	+	pub fifo: PathBuf,
126	+	pub style: VisualizerStyle,
127	+	pub stereo: bool,
128	+	pub wave_symbol: String,
129	+	pub sample_rate: u32,
130	+	pub channels: u16,
131	+	pub framerate: u32,
132	+	pub bar_width: u16,
133	+	pub bar_gap: u16,
134	+	pub min_frequency: f32,
135	+	pub max_frequency: f32,
136	+	pub falloff: f32,
137	+	}
138	+
139	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
140	+	#[serde(rename_all = "snake_case")]
141	+	pub enum VisualizerStyle {
142	+	Wave,
143	+	WaveFilled,
144	+	Spectrum,
145	+	Ellipse,
146	+	}
147	+
148	+	impl VisualizerStyle {
149	+	pub fn next(self) -> Self {
150	+	match self {
151	+	Self::Wave => Self::WaveFilled,
152	+	Self::WaveFilled => Self::Spectrum,
153	+	Self::Spectrum => Self::Ellipse,
154	+	Self::Ellipse => Self::Wave,
155	+	}
156	+	}
157	+
158	+	pub fn name(self) -> &'static str {
159	+	match self {
160	+	Self::Wave => "wave",
161	+	Self::WaveFilled => "wave filled",
162	+	Self::Spectrum => "spectrum",
163	+	Self::Ellipse => "ellipse",
164	+	}
165	+	}
166	+	}
167	+
168	+	#[derive(Debug, Deserialize)]
169	+	#[serde(deny_unknown_fields)]
170	+	struct RawConfig {
171	+	mpd: MpdConfig,
172	+	playback: PlaybackConfig,
173	+	ui: UiConfig,
174	+	theme: Theme,
175	+	lyrics: LyricsConfig,
176	+	visualizer: VisualizerConfig,
177	+	keys: Bindings,
178	+	}
179	+
180	+	#[derive(Clone, Debug)]
181	+	pub struct Config {
182	+	pub mpd: MpdConfig,
183	+	pub playback: PlaybackConfig,
184	+	pub ui: UiConfig,
185	+	pub theme: Theme,
186	+	pub lyrics: LyricsConfig,
187	+	pub visualizer: VisualizerConfig,
188	+	pub keymap: Keymap,
189	+	}
190	+
191	+	impl Default for Config {
192	+	fn default() -> Self {
193	+	Self::from_toml(DEFAULT_CONFIG).expect("the built-in default configuration is valid")
194	+	}
195	+	}
196	+
197	+	impl Config {
198	+	/// Loads the config at `path`, or at the default location. A missing
199	+	/// file at the default location is created from the documented defaults.
200	+	pub fn load(path: Option<&Path>) -> Result<(Self, PathBuf), ConfigError> {
201	+	let (path, create) = match path {
202	+	Some(path) => (path.to_path_buf(), false),
203	+	None => (default_path(), true),
204	+	};
205	+	let io_error = \|source\| ConfigError::Io {
206	+	path: path.clone(),
207	+	source,
208	+	};
209	+	let contents = match fs::read_to_string(&path) {
210	+	Ok(contents) => contents,
211	+	Err(error) if error.kind() == io::ErrorKind::NotFound && create => {
212	+	write_default(&path).map_err(io_error)?;
213	+	DEFAULT_CONFIG.to_owned()
214	+	}
215	+	Err(error) => return Err(io_error(error)),
216	+	};
217	+	let user: toml::Table = toml::from_str(&contents).map_err(\|error\| ConfigError::Parse {
218	+	path: path.clone(),
219	+	message: error.to_string(),
220	+	})?;
221	+	if user.contains_key("keybindings") {
222	+	return Err(ConfigError::Legacy(path));
223	+	}
224	+	let config = Self::from_table(user).map_err(\|error\| match error {
225	+	ConfigError::Invalid(message) => ConfigError::Parse {
226	+	path: path.clone(),
227	+	message,
228	+	},
229	+	other => other,
230	+	})?;
231	+	Ok((config, path))
232	+	}
233	+
234	+	/// Parses a (partial) config, filling in defaults.
235	+	pub fn from_toml(contents: &str) -> Result<Self, ConfigError> {
236	+	let user: toml::Table =
237	+	toml::from_str(contents).map_err(\|error\| ConfigError::Invalid(error.to_string()))?;
238	+	Self::from_table(user)
239	+	}
240	+
241	+	fn from_table(user: toml::Table) -> Result<Self, ConfigError> {
242	+	let mut merged: toml::Table =
243	+	toml::from_str(DEFAULT_CONFIG).expect("the built-in default configuration is TOML");
244	+	merge(&mut merged, user);
245	+	let raw: RawConfig = toml::Value::Table(merged)
246	+	.try_into()
247	+	.map_err(\|error: toml::de::Error\| ConfigError::Invalid(error.to_string()))?;
248	+	let config = Self {
249	+	keymap: Keymap::new(raw.keys).map_err(ConfigError::Invalid)?,
250	+	mpd: raw.mpd,
251	+	playback: raw.playback,
252	+	ui: raw.ui,
253	+	theme: raw.theme,
254	+	lyrics: raw.lyrics,
255	+	visualizer: raw.visualizer,
256	+	};
257	+	config.validate()?;
258	+	Ok(config)
259	+	}
260	+
261	+	fn validate(&self) -> Result<(), ConfigError> {
262	+	let check = \|ok: bool, message: &str\| {
263	+	if ok {
264	+	Ok(())
265	+	} else {
266	+	Err(ConfigError::Invalid(message.to_owned()))
267	+	}
268	+	};
269	+	check(!self.mpd.host.trim().is_empty(), "mpd.host cannot be empty")?;
270	+	check(self.mpd.port != 0, "mpd.port must be between 1 and 65535")?;
271	+	check(
272	+	self.playback.seek_seconds > 0,
273	+	"playback.seek_seconds must be greater than zero",
274	+	)?;
275	+	check(
276	+	(1..=100).contains(&self.playback.volume_step),
277	+	"playback.volume_step must be between 1 and 100",
278	+	)?;
279	+	check(
280	+	(10..=90).contains(&self.ui.lyrics_pane_width),
281	+	"ui.lyrics_pane_width must be between 10 and 90",
282	+	)?;
283	+	check(
284	+	!self.ui.song_columns.is_empty(),
285	+	"ui.song_columns cannot be empty",
286	+	)?;
287	+	let vis = &self.visualizer;
288	+	check(
289	+	vis.sample_rate > 0,
290	+	"visualizer.sample_rate must be greater than zero",
291	+	)?;
292	+	check(
293	+	matches!(vis.channels, 1 \| 2),
294	+	"visualizer.channels must be 1 or 2",
295	+	)?;
296	+	check(
297	+	(1..=240).contains(&vis.framerate),
298	+	"visualizer.framerate must be between 1 and 240",
299	+	)?;
300	+	check(
301	+	vis.bar_width > 0,
302	+	"visualizer.bar_width must be greater than zero",
303	+	)?;
304	+	check(
305	+	vis.min_frequency > 0.0 && vis.min_frequency < vis.max_frequency,
306	+	"visualizer.min_frequency must be positive and below max_frequency",
307	+	)?;
308	+	check(
309	+	vis.wave_symbol.chars().count() == 1,
310	+	"visualizer.wave_symbol must be a single character",
311	+	)?;
312	+	check(
313	+	vis.falloff > 0.0,
314	+	"visualizer.falloff must be greater than zero",
315	+	)?;
316	+	check(
317	+	!self.theme.visualizer.is_empty(),
318	+	"theme.visualizer needs at least one color",
319	+	)?;
320	+	Ok(())
321	+	}
322	+
323	+	/// The music directory from the config, if set.
324	+	pub fn music_directory(&self) -> Option<PathBuf> {
325	+	let dir = self.mpd.music_directory.trim();
326	+	(!dir.is_empty()).then(\|\| expand_tilde(dir))
327	+	}
328	+
329	+	pub fn message_timeout(&self) -> Duration {
330	+	Duration::from_secs(self.ui.message_timeout)
331	+	}
332	+
333	+	/// The MPD address and password, honoring `MPD_HOST` and `MPD_PORT`.
334	+	pub fn mpd_connection(&self) -> Result<(Address, Option<String>), ConfigError> {
335	+	resolve_connection(
336	+	&self.mpd,
337	+	env::var("MPD_HOST").ok().filter(\|h\| !h.is_empty()),
338	+	env::var("MPD_PORT").ok().filter(\|p\| !p.is_empty()),
339	+	)
340	+	}
341	+	}
342	+
343	+	/// Recursively merges `user` into `base`. Tables merge; other values replace.
344	+	fn merge(base: &mut toml::Table, user: toml::Table) {
345	+	for (key, value) in user {
346	+	match (base.get_mut(&key), value) {
347	+	(Some(toml::Value::Table(base)), toml::Value::Table(user)) => merge(base, user),
348	+	(_, value) => {
349	+	base.insert(key, value);
350	+	}
351	+	}
352	+	}
353	+	}
354	+
355	+	/// `$CONFIG_HOME/rmptui/config.toml`, falling back to `$XDG_CONFIG_HOME`
356	+	/// and then `~/.config`.
357	+	pub fn default_path() -> PathBuf {
358	+	env::var_os("CONFIG_HOME")
359	+	.or_else(\|\| env::var_os("XDG_CONFIG_HOME"))
360	+	.filter(\|dir\| !dir.is_empty())
361	+	.map(PathBuf::from)
362	+	.unwrap_or_else(\|\| expand_tilde("~/.config"))
363	+	.join("rmptui")
364	+	.join("config.toml")
365	+	}
366	+
367	+	fn write_default(path: &Path) -> io::Result<()> {
368	+	if let Some(parent) = path.parent() {
369	+	fs::create_dir_all(parent)?;
370	+	}
371	+	let mut options = OpenOptions::new();
372	+	options.write(true).create_new(true);
373	+	#[cfg(unix)]
374	+	{
375	+	use std::os::unix::fs::OpenOptionsExt;
376	+	// The file may hold the MPD password.
377	+	options.mode(0o600);
378	+	}
379	+	match options.open(path) {
380	+	Ok(mut file) => file.write_all(DEFAULT_CONFIG.as_bytes()),
381	+	// Another instance created it in the meantime.
382	+	Err(error) if error.kind() == io::ErrorKind::AlreadyExists => Ok(()),
383	+	Err(error) => Err(error),
384	+	}
385	+	}
386	+
387	+	fn resolve_connection(
388	+	mpd: &MpdConfig,
389	+	env_host: Option<String>,
390	+	env_port: Option<String>,
391	+	) -> Result<(Address, Option<String>), ConfigError> {
392	+	let configured_password = (!mpd.password.is_empty()).then(\|\| mpd.password.clone());
393	+	let (host, password) = match env_host {
394	+	Some(host) => match host.split_once('@') {
395	+	Some((password, host)) => (host.to_owned(), Some(password.to_owned())),
396	+	None => (host, configured_password),
397	+	},
398	+	None => (mpd.host.clone(), configured_password),
399	+	};
400	+	if host.is_empty() {
401	+	return Err(ConfigError::Invalid("MPD host cannot be empty".into()));
402	+	}
403	+	if host.starts_with('/') \|\| host.starts_with('~') {
404	+	return Ok((Address::Unix(expand_tilde(&host)), password));
405	+	}
406	+	let port = match env_port {
407	+	Some(port) => port
408	+	.parse::<u16>()
409	+	.ok()
410	+	.filter(\|&p\| p != 0)
411	+	.ok_or_else(\|\| ConfigError::Invalid(format!("invalid MPD_PORT value `{port}`")))?,
412	+	None => mpd.port,
413	+	};
414	+	Ok((Address::Tcp(tcp_address(&host, port)), password))
415	+	}
416	+
417	+	/// Formats `host` and `port` for connecting, keeping an explicit port in
418	+	/// `host` and bracketing IPv6 addresses.
419	+	fn tcp_address(host: &str, port: u16) -> String {
420	+	if host.starts_with('[') && host.contains("]:") {
421	+	host.to_owned()
422	+	} else if let Some(ipv6) = host
423	+	.strip_prefix('[')
424	+	.and_then(\|h\| h.strip_suffix(']'))
425	+	.filter(\|h\| h.parse::<Ipv6Addr>().is_ok())
426	+	{
427	+	format!("[{ipv6}]:{port}")
428	+	} else if host.parse::<Ipv6Addr>().is_ok() {
429	+	format!("[{host}]:{port}")
430	+	} else if host
431	+	.rsplit_once(':')
432	+	.is_some_and(\|(_, suffix)\| suffix.parse::<u16>().is_ok())
433	+	{
434	+	host.to_owned()
435	+	} else {
436	+	format!("{host}:{port}")
437	+	}
438	+	}
439	+
440	+	#[cfg(test)]
441	+	mod tests {
442	+	use super::*;
443	+	use crate::action::{Action, Context};
444	+
445	+	#[test]
446	+	fn default_config_is_valid_and_binds_every_action() {
447	+	let config = Config::default();
448	+	for &action in Action::ALL {
449	+	let bound = action
450	+	.contexts()
451	+	.iter()
452	+	.any(\|&context\| !config.keymap.keys_for(context, action).is_empty());
453	+	assert!(bound, "action `{action}` has no default binding");
454	+	}
455	+	assert_eq!(config.mpd.port, 6600);
456	+	assert_eq!(config.ui.startup_screen, ScreenId::Queue);
457	+	}
458	+
459	+	#[test]
460	+	fn partial_config_keeps_defaults() {
461	+	let config = Config::from_toml(
462	+	r#"
463	+	[playback]
464	+	volume_step = 10
465	+	[keys.global]
466	+	quit = ["Q"]
467	+	"#,
468	+	)
469	+	.unwrap();
470	+	assert_eq!(config.playback.volume_step, 10);
471	+	assert_eq!(config.playback.seek_seconds, 5);
472	+	let quit = config.keymap.keys_for(Context::Global, Action::Quit);
473	+	assert_eq!(quit, ["Q".parse::<KeyCombo>().unwrap()]);
474	+	// Other global bindings are untouched.
475	+	assert!(
476	+	!config
477	+	.keymap
478	+	.keys_for(Context::Global, Action::TogglePause)
479	+	.is_empty()
480	+	);
481	+	}
482	+
483	+	#[test]
484	+	fn rejects_bad_values() {
485	+	for bad in [
486	+	"[mpd]\nport = 0",
487	+	"[playback]\nvolume_step = 0",
488	+	"[mpd]\nhots = \"typo\"",
489	+	"[theme]\ntext = \"notacolor\"",
490	+	"[keys.global]\nquit = [\"Hyper+q\"]",
491	+	"[keys.global]\nnot_an_action = [\"x\"]",
492	+	// `p` is already bound to toggle_pause.
493	+	"[keys.global]\nquit = [\"p\"]",
494	+	] {
495	+	assert!(Config::from_toml(bad).is_err(), "accepted `{bad}`");
496	+	}
497	+	}
498	+
499	+	#[test]
500	+	fn detects_legacy_config() {
501	+	let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
502	+	.join("target/test-tmp")
503	+	.join(format!("config-{}", std::process::id()));
504	+	fs::create_dir_all(&dir).unwrap();
505	+	let path = dir.join("legacy.toml");
506	+	fs::write(&path, "[keybindings]\nquit = [\"q\"]\n").unwrap();
507	+	let result = Config::load(Some(&path));
508	+	fs::remove_dir_all(&dir).unwrap();
509	+	assert!(matches!(result, Err(ConfigError::Legacy(_))));
510	+	}
511	+
512	+	fn mpd_config(host: &str, password: &str) -> MpdConfig {
513	+	MpdConfig {
514	+	host: host.into(),
515	+	port: 6600,
516	+	password: password.into(),
517	+	music_directory: String::new(),
518	+	}
519	+	}
520	+
521	+	#[test]
522	+	fn resolves_connection() {
523	+	let resolve = \|host: &str, env_host: Option<&str>, env_port: Option<&str>\| {
524	+	resolve_connection(
525	+	&mpd_config(host, "cfg"),
526	+	env_host.map(Into::into),
527	+	env_port.map(Into::into),
528	+	)
529	+	.unwrap()
530	+	};
531	+	assert_eq!(
532	+	resolve("localhost", None, None),
533	+	(Address::Tcp("localhost:6600".into()), Some("cfg".into()))
534	+	);
535	+	assert_eq!(
536	+	resolve("x", Some("secret@host"), Some("6601")),
537	+	(Address::Tcp("host:6601".into()), Some("secret".into()))
538	+	);
539	+	assert_eq!(
540	+	resolve("/run/mpd/socket", None, None).0,
541	+	Address::Unix("/run/mpd/socket".into())
542	+	);
543	+	assert!(resolve_connection(&mpd_config("x", ""), None, Some("nope".into())).is_err());
544	+	}
545	+
546	+	#[test]
547	+	fn formats_tcp_addresses() {
548	+	assert_eq!(tcp_address("localhost", 6600), "localhost:6600");
549	+	assert_eq!(tcp_address("localhost:6601", 6600), "localhost:6601");
550	+	assert_eq!(tcp_address("[::1]", 6600), "[::1]:6600");
551	+	assert_eq!(tcp_address("[::1]:6601", 6600), "[::1]:6601");
552	+	assert_eq!(tcp_address("::1", 6600), "[::1]:6600");
553	+	}
554	+	}

	@@ -1,473 +0,0 @@
1	−	use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEvent, MouseEventKind};
2	−	use rust_fuzzy_search::fuzzy_search_sorted;
3	−
4	−	use crate::{
5	−	app::{App, PlaylistFocus, SelectedTab},
6	−	connection::VolumeStatus,
7	−	ui::InputMode,
8	−	AppResult,
9	−	};
10	−
11	−	pub async fn handle_key_events(key: KeyEvent, app: &mut App) -> AppResult<()> {
12	−	if app.inputmode != InputMode::Normal {
13	−	if key
14	−	.modifiers
15	−	.intersects(KeyModifiers::CONTROL \| KeyModifiers::ALT)
16	−	&& is_bound(app, "quit", key)
17	−	{
18	−	app.quit();
19	−	return Ok(());
20	−	}
21	−	return handle_input_key(key, app).await;
22	−	}
23	−	if app.playlist_popup {
24	−	if is_bound(app, "popup_close", key) {
25	−	app.playlist_popup = false;
26	−	} else if is_bound(app, "move_down", key) {
27	−	app.append_list.next();
28	−	} else if is_bound(app, "move_up", key) {
29	−	app.append_list.prev();
30	−	} else if is_bound(app, "popup_select", key) {
31	−	app.append_selected_to().await?;
32	−	}
33	−	return Ok(());
34	−	}
35	−	if app.selected_tab == SelectedTab::DirectoryBrowser && !app.browser_search_results.is_empty() {
36	−	if is_bound(app, "search_next", key) {
37	−	cycle_browser_search(app, true);
38	−	return Ok(());
39	−	} else if is_bound(app, "search_previous", key) {
40	−	cycle_browser_search(app, false);
41	−	return Ok(());
42	−	}
43	−	}
44	−
45	−	if is_bound(app, "quit", key) {
46	−	app.quit();
47	−	} else if is_bound(app, "clear_queue", key) {
48	−	app.conn.clear().await?;
49	−	app.update_queue().await?;
50	−	app.conn.update_status().await?;
51	−	} else if is_bound(app, "toggle_pause", key) {
52	−	app.conn.toggle_pause().await?;
53	−	} else if is_bound(app, "pause", key) {
54	−	app.conn.pause().await?;
55	−	} else if is_bound(app, "toggle_repeat", key) {
56	−	app.conn.toggle_repeat().await?;
57	−	} else if is_bound(app, "toggle_random", key) {
58	−	app.conn.toggle_random().await?;
59	−	} else if is_bound(app, "open_playlist_menu", key) {
60	−	app.playlist_popup = true;
61	−	} else if is_bound(app, "seek_forward", key) \|\| is_bound(app, "seek_backward", key) {
62	−	if let Some(position) = app.conn.status.song {
63	−	let current = app.conn.status.elapsed.as_secs();
64	−	let target = if is_bound(app, "seek_forward", key) {
65	−	current.saturating_add(app.config.playback.seek_seconds)
66	−	} else {
67	−	current.saturating_sub(app.config.playback.seek_seconds)
68	−	};
69	−	app.conn
70	−	.seek(position.pos, std::time::Duration::from_secs(target))
71	−	.await?;
72	−	app.conn.update_status().await?;
73	−	}
74	−	} else if is_bound(app, "cycle_tabs", key) {
75	−	app.cycle_tabs();
76	−	if app.selected_tab == SelectedTab::Playlists {
77	−	app.refresh_playlist_view().await?;
78	−	}
79	−	} else if is_bound(app, "select_queue", key) {
80	−	app.selected_tab = SelectedTab::Queue;
81	−	} else if is_bound(app, "select_browser", key) {
82	−	app.selected_tab = SelectedTab::DirectoryBrowser;
83	−	} else if is_bound(app, "select_playlists", key) {
84	−	app.selected_tab = SelectedTab::Playlists;
85	−	app.refresh_playlist_view().await?;
86	−	} else if is_bound(app, "next_track", key) {
87	−	if !app.queue_list.list.is_empty() {
88	−	app.conn.next().await?;
89	−	app.update_queue().await?;
90	−	app.conn.update_status().await?;
91	−	}
92	−	} else if is_bound(app, "previous_track", key) {
93	−	if !app.queue_list.list.is_empty() {
94	−	app.conn.previous().await?;
95	−	app.update_queue().await?;
96	−	app.conn.update_status().await?;
97	−	}
98	−	} else if is_bound(app, "volume_up", key) {
99	−	app.conn
100	−	.inc_volume(app.config.playback.volume_step as i8)
101	−	.await?;
102	−	} else if is_bound(app, "volume_down", key) {
103	−	app.conn
104	−	.dec_volume(app.config.playback.volume_step as i8)
105	−	.await?;
106	−	} else if is_bound(app, "toggle_mute", key) {
107	−	match app.conn.volume_status {
108	−	VolumeStatus::Muted(volume) => {
109	−	app.conn.set_volume(volume).await?;
110	−	app.conn.volume_status = VolumeStatus::Unmuted;
111	−	}
112	−	VolumeStatus::Unmuted => {
113	−	app.conn.set_volume(0).await?;
114	−	app.conn.volume_status = VolumeStatus::Muted(app.conn.status.volume);
115	−	}
116	−	}
117	−	app.conn.update_status().await?;
118	−	} else if is_bound(app, "update_database", key) {
119	−	app.conn.update_database().await?;
120	−	app.should_update_song_list = true;
121	−	app.conn.update_status().await?;
122	−	} else if is_bound(app, "search", key) {
123	−	app.inputmode = InputMode::Editing;
124	−	app.search_input.clear();
125	−	app.search_cursor_pos = 0;
126	−	app.browser_search_results.clear();
127	−	app.browser_search_index = 0;
128	−	} else if is_bound(app, "toggle_selected_item", key) {
129	−	app.toggle_selected_item().await?;
130	−	}
131	−
132	−	match app.selected_tab {
133	−	SelectedTab::Queue => handle_queue_key(key, app).await?,
134	−	SelectedTab::DirectoryBrowser => handle_browser_key(key, app).await?,
135	−	SelectedTab::Playlists => handle_playlists_key(key, app).await?,
136	−	}
137	−	Ok(())
138	−	}
139	−
140	−	fn is_bound(app: &App, action: &str, key: KeyEvent) -> bool {
141	−	app.config.keybindings.matches(action, key)
142	−	}
143	−
144	−	async fn handle_queue_key(key: KeyEvent, app: &mut App) -> AppResult<()> {
145	−	if is_bound(app, "move_down", key) {
146	−	app.queue_list.next();
147	−	} else if is_bound(app, "move_up", key) {
148	−	app.queue_list.prev();
149	−	} else if is_bound(app, "activate", key) {
150	−	if app.queue_list.index < app.queue_list.list.len() {
151	−	app.conn.play(Some(app.queue_list.index as u32)).await?;
152	−	app.conn.update_status().await?;
153	−	}
154	−	} else if is_bound(app, "queue_delete", key) {
155	−	if app.queue_list.index < app.queue_list.list.len() {
156	−	app.conn.delete(app.queue_list.index as u32).await?;
157	−	app.update_queue().await?;
158	−	app.conn.update_status().await?;
159	−	}
160	−	} else if is_bound(app, "queue_move_down", key) {
161	−	let position = app.queue_list.index;
162	−	if position + 1 < app.queue_list.list.len() {
163	−	app.conn
164	−	.swap(position as u32, (position + 1) as u32)
165	−	.await?;
166	−	app.queue_list.index += 1;
167	−	app.update_queue().await?;
168	−	}
169	−	} else if is_bound(app, "queue_move_up", key) {
170	−	let position = app.queue_list.index;
171	−	if position > 0 && position < app.queue_list.list.len() {
172	−	app.conn
173	−	.swap(position as u32, (position - 1) as u32)
174	−	.await?;
175	−	app.queue_list.index -= 1;
176	−	app.update_queue().await?;
177	−	}
178	−	} else if is_bound(app, "go_to_top", key) {
179	−	app.queue_list.index = 0;
180	−	} else if is_bound(app, "go_to_bottom", key) {
181	−	app.queue_list.index = app.queue_list.list.len().saturating_sub(1);
182	−	}
183	−	Ok(())
184	−	}
185	−
186	−	async fn handle_browser_key(key: KeyEvent, app: &mut App) -> AppResult<()> {
187	−	if is_bound(app, "move_down", key) {
188	−	app.browser.next();
189	−	} else if is_bound(app, "move_up", key) {
190	−	app.browser.prev();
191	−	} else if is_bound(app, "activate", key) {
192	−	let previous_path = app.browser.path.clone();
193	−	app.handle_enter().await?;
194	−	if app.browser.path != previous_path {
195	−	app.browser_search_results.clear();
196	−	app.search_input.clear();
197	−	}
198	−	} else if is_bound(app, "go_back", key) {
199	−	app.browser.handle_go_back(&mut app.conn).await?;
200	−	app.browser_search_results.clear();
201	−	app.search_input.clear();
202	−	} else if is_bound(app, "go_to_top", key) {
203	−	app.browser.selected = 0;
204	−	} else if is_bound(app, "go_to_bottom", key) {
205	−	app.browser.selected = app.browser.entries.len().saturating_sub(1);
206	−	}
207	−	Ok(())
208	−	}
209	−
210	−	async fn handle_playlists_key(key: KeyEvent, app: &mut App) -> AppResult<()> {
211	−	if is_bound(app, "playlist_focus_contents", key) {
212	−	app.playlist_focus = PlaylistFocus::Songs;
213	−	return Ok(());
214	−	}
215	−	if is_bound(app, "playlist_focus_list", key) {
216	−	app.playlist_focus = PlaylistFocus::List;
217	−	return Ok(());
218	−	}
219	−
220	−	if app.playlist_focus == PlaylistFocus::Songs {
221	−	if is_bound(app, "move_down", key) {
222	−	app.playlist_song_index = app
223	−	.playlist_song_index
224	−	.saturating_add(1)
225	−	.min(app.playlist_contents.len().saturating_sub(1));
226	−	} else if is_bound(app, "move_up", key) {
227	−	app.playlist_song_index = app.playlist_song_index.saturating_sub(1);
228	−	} else if is_bound(app, "go_to_top", key) {
229	−	app.playlist_song_index = 0;
230	−	} else if is_bound(app, "go_to_bottom", key) {
231	−	app.playlist_song_index = app.playlist_contents.len().saturating_sub(1);
232	−	} else if is_bound(app, "playlist_delete_song", key) {
233	−	app.delete_selected_playlist_song().await?;
234	−	} else if is_bound(app, "playlist_move_song_down", key) {
235	−	app.move_selected_playlist_song(true).await?;
236	−	} else if is_bound(app, "playlist_move_song_up", key) {
237	−	app.move_selected_playlist_song(false).await?;
238	−	} else if is_bound(app, "activate", key) {
239	−	app.play_selected_playlist_song().await?;
240	−	} else if is_bound(app, "playlist_delete", key) {
241	−	app.delete_selected_playlist().await?;
242	−	}
243	−	return Ok(());
244	−	}
245	−
246	−	let previous_index = app.pl_list.index;
247	−	if is_bound(app, "move_down", key) {
248	−	app.pl_list.next();
249	−	} else if is_bound(app, "move_up", key) {
250	−	app.pl_list.prev();
251	−	} else if is_bound(app, "go_to_top", key) {
252	−	app.pl_list.index = 0;
253	−	} else if is_bound(app, "go_to_bottom", key) {
254	−	app.pl_list.index = app.pl_list.list.len().saturating_sub(1);
255	−	} else if is_bound(app, "playlist_rename", key) && !app.pl_list.list.is_empty() {
256	−	app.inputmode = InputMode::PlaylistRename;
257	−	app.pl_newname_input.clear();
258	−	app.pl_cursor_pos = 0;
259	−	} else if is_bound(app, "playlist_delete", key) {
260	−	app.delete_selected_playlist().await?;
261	−	} else if is_bound(app, "playlist_load", key) {
262	−	if let Some(playlist) = app.pl_list.list.get(app.pl_list.index) {
263	−	app.conn.load_playlist(playlist).await?;
264	−	app.update_queue().await?;
265	−	}
266	−	}
267	−	if previous_index != app.pl_list.index {
268	−	app.playlist_song_index = 0;
269	−	app.refresh_playlist_view().await?;
270	−	}
271	−	Ok(())
272	−	}
273	−
274	−	async fn handle_input_key(key: KeyEvent, app: &mut App) -> AppResult<()> {
275	−	if is_bound(app, "input_cancel", key) {
276	−	match app.inputmode {
277	−	InputMode::Editing => {
278	−	app.search_input.clear();
279	−	app.browser_search_results.clear();
280	−	app.inputmode = InputMode::Normal;
281	−	}
282	−	InputMode::PlaylistRename => {
283	−	app.pl_newname_input.clear();
284	−	app.inputmode = InputMode::Normal;
285	−	}
286	−	InputMode::NewPlaylist => {
287	−	app.pl_new_pl_input.clear();
288	−	app.inputmode = InputMode::Normal;
289	−	}
290	−	InputMode::Normal => {}
291	−	}
292	−	app.reset_cursor();
293	−	} else if is_bound(app, "input_backspace", key) {
294	−	app.delete_char();
295	−	if app.inputmode == InputMode::Editing {
296	−	update_search_selection(app);
297	−	}
298	−	} else if is_bound(app, "input_cursor_left", key) {
299	−	app.move_cursor_left();
300	−	} else if is_bound(app, "input_cursor_right", key) {
301	−	app.move_cursor_right();
302	−	} else if is_bound(app, "input_submit", key) {
303	−	match app.inputmode {
304	−	InputMode::Editing => {
305	−	update_search_selection(app);
306	−	if app.selected_tab != SelectedTab::DirectoryBrowser {
307	−	app.search_input.clear();
308	−	}
309	−	if app.selected_tab == SelectedTab::Playlists {
310	−	app.refresh_playlist_view().await?;
311	−	}
312	−	app.reset_cursor();
313	−	app.inputmode = InputMode::Normal;
314	−	}
315	−	InputMode::PlaylistRename => {
316	−	if let Some(old_name) = app.pl_list.list.get(app.pl_list.index).cloned() {
317	−	if !app.pl_newname_input.trim().is_empty() {
318	−	app.conn
319	−	.rename_playlist(&old_name, &app.pl_newname_input)
320	−	.await?;
321	−	app.refresh_playlists().await?;
322	−	}
323	−	}
324	−	app.pl_newname_input.clear();
325	−	app.reset_cursor();
326	−	app.inputmode = InputMode::Normal;
327	−	}
328	−	InputMode::NewPlaylist => {
329	−	if !app.pl_new_pl_input.trim().is_empty() {
330	−	for song in &app.pl_new_pl_songs_buffer {
331	−	app.conn.add_to_playlist(&app.pl_new_pl_input, song).await?;
332	−	}
333	−	app.refresh_playlists().await?;
334	−	}
335	−	app.pl_new_pl_input.clear();
336	−	app.reset_cursor();
337	−	app.inputmode = InputMode::Normal;
338	−	}
339	−	InputMode::Normal => {}
340	−	}
341	−	} else if let KeyCode::Char(character) = key.code {
342	−	if !key
343	−	.modifiers
344	−	.intersects(KeyModifiers::CONTROL \| KeyModifiers::ALT)
345	−	{
346	−	app.enter_char(character);
347	−	if app.inputmode == InputMode::Editing {
348	−	update_search_selection(app);
349	−	}
350	−	}
351	−	}
352	−	Ok(())
353	−	}
354	−
355	−	fn update_search_selection(app: &mut App) {
356	−	if app.search_input.is_empty() {
357	−	return;
358	−	}
359	−	match app.selected_tab {
360	−	SelectedTab::Queue => {
361	−	let items: Vec<&str> = app
362	−	.queue_list
363	−	.list
364	−	.iter()
365	−	.map(\|song\| song.file.as_str())
366	−	.collect();
367	−	if let Some((best, _)) = fuzzy_search_sorted(&app.search_input, &items).first() {
368	−	if let Some(index) = app
369	−	.queue_list
370	−	.list
371	−	.iter()
372	−	.position(\|song\| song.file == *best)
373	−	{
374	−	app.queue_list.index = index;
375	−	}
376	−	}
377	−	}
378	−	SelectedTab::DirectoryBrowser => {
379	−	let items: Vec<String> = app
380	−	.browser
381	−	.entries
382	−	.iter()
383	−	.map(\|entry\| entry.name().to_string())
384	−	.collect();
385	−	app.browser_search_results = fuzzy_indices(&app.search_input, &items);
386	−	app.browser_search_index = 0;
387	−	if let Some(index) = app.browser_search_results.first() {
388	−	app.browser.selected = *index;
389	−	}
390	−	}
391	−	SelectedTab::Playlists => {
392	−	let items: Vec<&str> = app.pl_list.list.iter().map(String::as_str).collect();
393	−	if let Some((best, _)) = fuzzy_search_sorted(&app.search_input, &items).first() {
394	−	if let Some(index) = app.pl_list.list.iter().position(\|name\| name == *best) {
395	−	app.pl_list.index = index;
396	−	}
397	−	}
398	−	}
399	−	}
400	−	}
401	−
402	−	fn cycle_browser_search(app: &mut App, forward: bool) {
403	−	let len = app.browser_search_results.len();
404	−	if len == 0 {
405	−	return;
406	−	}
407	−	app.browser_search_index = if forward {
408	−	(app.browser_search_index + 1) % len
409	−	} else {
410	−	app.browser_search_index.checked_sub(1).unwrap_or(len - 1)
411	−	};
412	−	app.browser.selected = app.browser_search_results[app.browser_search_index];
413	−	}
414	−
415	−	fn fuzzy_indices(query: &str, items: &[String]) -> Vec<usize> {
416	−	if query.is_empty() {
417	−	return Vec::new();
418	−	}
419	−	let candidates: Vec<&str> = items.iter().map(String::as_str).collect();
420	−	let ranked = fuzzy_search_sorted(query, &candidates);
421	−	let mut used = vec![false; items.len()];
422	−	ranked
423	−	.into_iter()
424	−	.filter(\|(_, score)\| *score > 0.0)
425	−	.filter_map(\|(name, _)\| {
426	−	let index = items
427	−	.iter()
428	−	.enumerate()
429	−	.find(\|(index, item)\| !used[*index] && item.as_str() == name)
430	−	.map(\|(index, _)\| index)?;
431	−	used[index] = true;
432	−	Some(index)
433	−	})
434	−	.collect()
435	−	}
436	−
437	−	pub async fn handle_mouse_events(mouse: MouseEvent, app: &mut App) -> AppResult<()> {
438	−	let previous_playlist = app.pl_list.index;
439	−	match mouse.kind {
440	−	MouseEventKind::ScrollUp => app.handle_scroll_up(),
441	−	MouseEventKind::ScrollDown => app.handle_scroll_down(),
442	−	_ => {}
443	−	}
444	−	if app.selected_tab == SelectedTab::Playlists && app.pl_list.index != previous_playlist {
445	−	app.playlist_song_index = 0;
446	−	app.refresh_playlist_view().await?;
447	−	}
448	−	Ok(())
449	−	}
450	−
451	−	#[cfg(test)]
452	−	mod tests {
453	−	use super::fuzzy_indices;
454	−
455	−	#[test]
456	−	fn fuzzy_search_returns_all_matches_and_keeps_duplicate_names() {
457	−	let items = vec![
458	−	"mr-robot-vol1".to_string(),
459	−	"mr-robot-vol2".to_string(),
460	−	"mr-robot-vol3".to_string(),
461	−	"other-album".to_string(),
462	−	];
463	−	let results = fuzzy_indices("robot", &items);
464	−	assert_eq!(results.len(), 3);
465	−	assert_eq!(
466	−	results
467	−	.iter()
468	−	.map(\|index\| items[*index].as_str())
469	−	.collect::<Vec<_>>(),
470	−	vec!["mr-robot-vol1", "mr-robot-vol2", "mr-robot-vol3"]
471	−	);
472	−	}
473	−	}

	@@ -1,30 +0,0 @@
1	−	#[derive(Debug)]
2	−	pub struct ContentList<T> {
3	−	pub list: Vec<T>,
4	−	pub index: usize,
5	−	}
6	−
7	−	impl<T> ContentList<T> {
8	−	pub fn new() -> Self {
9	−	Self {
10	−	list: Vec::new(),
11	−	index: 0,
12	−	}
13	−	}
14	−
15	−	pub fn next(&mut self) {
16	−	if let Some(last) = self.list.len().checked_sub(1) {
17	−	self.index = self.index.saturating_add(1).min(last);
18	−	}
19	−	}
20	−
21	−	pub fn prev(&mut self) {
22	−	self.index = self.index.saturating_sub(1);
23	−	}
24	−	}
25	−
26	−	impl<T> Default for ContentList<T> {
27	−	fn default() -> Self {
28	−	Self::new()
29	−	}
30	−	}

		@@ -2,12 +2,83 @@
2	2		# It is not intended for manual editing.
3	3		version = 4
4	4
	5	+	[[package]]
	6	+	name = "adler2"
	7	+	version = "2.0.1"
	8	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	9	+	checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
	10	+
	11	+	[[package]]
	12	+	name = "aho-corasick"
	13	+	version = "1.1.5"
	14	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	15	+	checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
	16	+	dependencies = [
	17	+	"memchr",
	18	+	]
	19	+
5	20		[[package]]
6	21		name = "allocator-api2"
7	22		version = "0.2.21"
8	23		source = "registry+https://github.com/rust-lang/crates.io-index"
9	24		checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
10	25
	26	+	[[package]]
	27	+	name = "anstream"
	28	+	version = "1.0.0"
	29	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	30	+	checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
	31	+	dependencies = [
	32	+	"anstyle",
	33	+	"anstyle-parse",
	34	+	"anstyle-query",
	35	+	"anstyle-wincon",
	36	+	"colorchoice",
	37	+	"is_terminal_polyfill",
	38	+	"utf8parse",
	39	+	]
	40	+

	@@ -0,0 +1,16 @@
1	+	//! MPD client: protocol, connection, typed models and background workers.
2	+
3	+	pub mod commands;
4	+	mod connection;
5	+	mod error;
6	+	pub mod protocol;
7	+	mod selection;
8	+	mod types;
9	+	mod worker;
10	+
11	+	pub use connection::{Address, Connection};
12	+	pub use error::{Ack, MpdError, MpdResult};
13	+	pub use protocol::Command;
14	+	pub use selection::Selection;
15	+	pub use types::{Album, DirEntry, OnOff, PlayState, PlaylistInfo, Song, Status, Subsystem};
16	+	pub use worker::{MpdEvent, MpdHandle, Query, Reply, Request, spawn};

	@@ -0,0 +1,114 @@
1	+	use ratatui::{
2	+	Frame,
3	+	layout::{Constraint, Rect},
4	+	text::Span,
5	+	widgets::Row,
6	+	};
7	+
8	+	use super::{InputPopup, InputPurpose, Popup, PopupState, frame_popup};
9	+	use crate::{
10	+	action::{Action, Context},
11	+	config::KeyCombo,
12	+	mpd::Selection,
13	+	screens::Ctx,
14	+	ui::list::ListView,
15	+	};
16	+
17	+	enum Choice {
18	+	Queue,
19	+	NewPlaylist,
20	+	Playlist(String),
21	+	}
22	+
23	+	/// Chooses where to add a selection: the queue, a new or an existing playlist.
24	+	pub struct AddToPlaylistPopup {
25	+	selection: Selection,
26	+	choices: Vec<Choice>,
27	+	list: ListView,
28	+	}
29	+
30	+	impl AddToPlaylistPopup {
31	+	pub fn new(selection: Selection, ctx: &Ctx) -> Self {
32	+	let mut choices = vec![Choice::Queue, Choice::NewPlaylist];
33	+	choices.extend(
34	+	ctx.mpd
35	+	.playlists
36	+	.iter()
37	+	.map(\|p\| Choice::Playlist(p.name.clone())),
38	+	);
39	+	Self {

	@@ -0,0 +1,69 @@
1	+	use crossterm::event::KeyCode;
2	+	use ratatui::{
3	+	Frame,
4	+	layout::{Alignment, Rect},
5	+	text::{Line, Span},
6	+	widgets::{Paragraph, Wrap},
7	+	};
8	+
9	+	use super::{Popup, PopupState, frame_popup};
10	+	use crate::{
11	+	action::{Action, Context},
12	+	config::KeyCombo,
13	+	mpd::Command,
14	+	screens::Ctx,
15	+	};
16	+
17	+	/// Asks before running destructive commands.
18	+	pub struct ConfirmPopup {
19	+	message: String,
20	+	commands: Vec<Command>,
21	+	}
22	+
23	+	impl ConfirmPopup {
24	+	pub fn new(message: impl Into<String>, commands: Vec<Command>) -> Self {
25	+	Self {
26	+	message: message.into(),
27	+	commands,
28	+	}
29	+	}
30	+	}
31	+
32	+	impl Popup for ConfirmPopup {
33	+	fn draw(&mut self, frame: &mut Frame, area: Rect, ctx: &Ctx) {
34	+	let inner = frame_popup(frame, area, 50, 5, "Confirm", ctx);
35	+	let theme = ctx.theme();
36	+	let text = vec![
37	+	Line::from(self.message.as_str()),
38	+	Line::default(),
39	+	Line::from(vec![

		@@ -1,20 +1,19 @@
	1	+	//! File logging. The terminal belongs to the UI, so diagnostics go to a file.
	2	+
1	3		use std::{
2		−	fs::{self, OpenOptions},
3		−	io::{self, Write},
4		−	path::{Path, PathBuf},
5		−	sync::{Mutex, OnceLock},
6		−	time::{SystemTime, UNIX_EPOCH},
	4	+	fs::OpenOptions,
	5	+	io,
	6	+	path::Path,
	7	+	sync::{Arc, Mutex},
7	8		};
8	9
9		−	use crate::AppResult;
10		−
11		−	static LOG_FILE: OnceLock<Mutex<fs::File>> = OnceLock::new();
	10	+	use tracing_subscriber::{EnvFilter, fmt};
12	11
13		−	pub fn init(path: &Path) -> AppResult<PathBuf> {
14		−	if let Some(parent) = path.parent() {
15		−	fs::create_dir_all(parent)?;
16		−	}
	12	+	pub const LOG_PATH: &str = "/tmp/rmptui.log";
17	13
	14	+	/// Appends logs to `path`. The level can be set with `RMPTUI_LOG`
	15	+	/// (e.g. `RMPTUI_LOG=debug`); the default is `info`.
	16	+	pub fn init(path: &Path) -> io::Result<()> {
18	17		let mut options = OpenOptions::new();
19	18		options.create(true).append(true);
20	19		#[cfg(unix)]
		@@ -22,65 +21,38 @@ pub fn init(path: &Path) -> AppResult<PathBuf> {
22	21		use std::os::unix::fs::OpenOptionsExt;
23	22		options.mode(0o600);
24	23		}
25		−	let file = options.open(path)?;
26		−	let _ = LOG_FILE.set(Mutex::new(file));
27		−
28		−	let panic_hook = std::panic::take_hook();
29		−	std::panic::set_hook(Box::new(move \|panic\| {
30		−	let message = panic
31		−	.payload()
32		−	.downcast_ref::<&str>()
33		−	.copied()
34		−	.or_else(\|\| panic.payload().downcast_ref::<String>().map(String::as_str))
35		−	.unwrap_or("non-string panic payload");
36		−	let location = panic
37		−	.location()
38		−	.map(\|location\| {
39		−	format!(
40		−	" at {}:{}:{}",
41		−	location.file(),
42		−	location.line(),
43		−	location.column()
44		−	)
45		−	})
46		−	.unwrap_or_default();
47		−	error(&format!("panic: {message}{location}"));
48		−	panic_hook(panic);
	24	+	let file = Arc::new(Mutex::new(options.open(path)?));
	25	+	let filter = EnvFilter::try_from_env("RMPTUI_LOG").unwrap_or_else(\|_\| EnvFilter::new("info"));
	26	+	fmt()
	27	+	.with_env_filter(filter)
	28	+	.with_ansi(false)
	29	+	.with_writer(move \|\| MutexWriter(Arc::clone(&file)))
	30	+	.try_init()
	31	+	.map_err(io::Error::other)?;
	32	+
	33	+	// Record panics in the log as well as on the (restored) terminal.
	34	+	let previous = std::panic::take_hook();
	35	+	std::panic::set_hook(Box::new(move \|info\| {
	36	+	tracing::error!("panic: {info}");
	37	+	previous(info);
49	38		}));
50		−
51		−	info(&format!("logging initialized: {}", path.display()));
52		−	Ok(path.to_path_buf())
	39	+	Ok(())
53	40		}
54	41
55		−	pub fn info(message: &str) {
56		−	write("INFO", message);
57		−	}
	42	+	struct MutexWriter(Arc<Mutex<std::fs::File>>);
58	43
59		−	pub fn error(message: &str) {
60		−	write("ERROR", message);
61		−	}
62		−
63		−	fn write(level: &str, message: &str) {
64		−	let Some(file) = LOG_FILE.get() else {
65		−	return;
66		−	};
67		−
68		−	let timestamp = SystemTime::now()
69		−	.duration_since(UNIX_EPOCH)
70		−	.unwrap_or_default();
71		−	let line = format!(
72		−	"[{}.{:03}] {level} {message}",
73		−	timestamp.as_secs(),
74		−	timestamp.subsec_millis()
75		−	);
76		−	let mut file = file
77		−	.lock()
78		−	.unwrap_or_else(std::sync::PoisonError::into_inner);
79		−	if let Err(error) = writeln!(file, "{line}") {
80		−	report_write_error(error);
	44	+	impl io::Write for MutexWriter {
	45	+	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	46	+	self.0
	47	+	.lock()
	48	+	.unwrap_or_else(std::sync::PoisonError::into_inner)
	49	+	.write(buf)
81	50		}
82		−	}
83	51
84		−	fn report_write_error(error: io::Error) {
85		−	eprintln!("failed to write rmptui log: {error}");
	52	+	fn flush(&mut self) -> io::Result<()> {
	53	+	self.0
	54	+	.lock()
	55	+	.unwrap_or_else(std::sync::PoisonError::into_inner)
	56	+	.flush()
	57	+	}
86	58		}

	@@ -0,0 +1,165 @@
1	+	//! Parser for LRC (synced lyrics) files.
2	+
3	+	use std::time::Duration;
4	+
5	+	#[derive(Clone, Debug, PartialEq, Eq)]
6	+	pub struct LyricLine {
7	+	pub time: Duration,
8	+	pub text: String,
9	+	}
10	+
11	+	#[derive(Clone, Debug, PartialEq, Eq)]
12	+	pub enum Lyrics {
13	+	/// Lines with timestamps, sorted by time.
14	+	Synced(Vec<LyricLine>),
15	+	Plain(Vec<String>),
16	+	}
17	+
18	+	impl Lyrics {
19	+	/// Parses LRC text. Text without any timestamps is treated as plain
20	+	/// lyrics.
21	+	pub fn parse(text: &str) -> Self {
22	+	let mut offset_ms: i64 = 0;
23	+	let mut synced = Vec::new();
24	+	for raw in text.lines() {
25	+	let mut rest = raw.trim();
26	+	let mut times = Vec::new();
27	+	while let Some(tag) = rest.strip_prefix('[').and_then(\|r\| r.split_once(']')) {
28	+	let (inner, tail) = tag;
29	+	if let Some(time) = parse_timestamp(inner) {
30	+	times.push(time);
31	+	} else if let Some(value) = inner.strip_prefix("offset:") {
32	+	offset_ms = value.trim().parse().unwrap_or(0);
33	+	} else if !is_id_tag(inner) {
34	+	break;
35	+	}
36	+	rest = tail;
37	+	}
38	+	let text = rest.trim().to_owned();
39	+	synced.extend(times.into_iter().map(\|time\| (time, text.clone())));
40	+	}
41	+	if synced.is_empty() {
42	+	return Self::Plain(text.lines().map(\|l\| l.trim_end().to_owned()).collect());
43	+	}
44	+	// A positive offset makes lyrics appear sooner.
45	+	let mut lines: Vec<LyricLine> = synced
46	+	.into_iter()
47	+	.map(\|(time, text)\| LyricLine {
48	+	time: shift(time, -offset_ms),
49	+	text,
50	+	})
51	+	.collect();
52	+	lines.sort_by_key(\|line\| line.time);
53	+	Self::Synced(lines)
54	+	}
55	+
56	+	pub fn is_empty(&self) -> bool {
57	+	match self {
58	+	Self::Synced(lines) => lines.is_empty(),
59	+	Self::Plain(lines) => lines.iter().all(\|l\| l.trim().is_empty()),
60	+	}
61	+	}
62	+
63	+	pub fn len(&self) -> usize {
64	+	match self {
65	+	Self::Synced(lines) => lines.len(),
66	+	Self::Plain(lines) => lines.len(),
67	+	}
68	+	}
69	+
70	+	/// The index of the line being sung at `elapsed`.
71	+	pub fn current_line(&self, elapsed: Duration) -> Option<usize> {
72	+	match self {
73	+	Self::Synced(lines) => lines
74	+	.partition_point(\|line\| line.time <= elapsed)
75	+	.checked_sub(1),
76	+	Self::Plain(_) => None,
77	+	}
78	+	}
79	+
80	+	pub fn line(&self, index: usize) -> &str {
81	+	match self {
82	+	Self::Synced(lines) => lines.get(index).map_or("", \|l\| l.text.as_str()),
83	+	Self::Plain(lines) => lines.get(index).map_or("", String::as_str),
84	+	}
85	+	}
86	+	}
87	+
88	+	/// `mm:ss`, `mm:ss.xx` or `mm:ss.xxx`.
89	+	fn parse_timestamp(tag: &str) -> Option<Duration> {
90	+	let (minutes, seconds) = tag.split_once(':')?;
91	+	let minutes: u64 = minutes.trim().parse().ok()?;
92	+	let (secs, fraction) = seconds.split_once(['.', ':']).unwrap_or((seconds, "0"));
93	+	let secs: u64 = secs.trim().parse().ok()?;
94	+	if secs >= 60 \|\| fraction.is_empty() \|\| !fraction.chars().all(\|c\| c.is_ascii_digit()) {
95	+	return None;
96	+	}
97	+	let millis = match fraction.len() {
98	+	1 => fraction.parse::<u64>().ok()? * 100,
99	+	2 => fraction.parse::<u64>().ok()? * 10,
100	+	_ => fraction[..3].parse::<u64>().ok()?,
101	+	};
102	+	Some(Duration::from_millis((minutes * 60 + secs) * 1000 + millis))
103	+	}
104	+
105	+	fn is_id_tag(tag: &str) -> bool {
106	+	tag.split_once(':')
107	+	.is_some_and(\|(key, _)\| !key.is_empty() && key.chars().all(\|c\| c.is_ascii_alphabetic()))
108	+	}
109	+
110	+	fn shift(time: Duration, ms: i64) -> Duration {
111	+	let shifted = time.as_millis() as i64 + ms;
112	+	Duration::from_millis(shifted.max(0) as u64)
113	+	}
114	+
115	+	#[cfg(test)]
116	+	mod tests {
117	+	use super::*;
118	+
119	+	fn ms(ms: u64) -> Duration {
120	+	Duration::from_millis(ms)
121	+	}
122	+
123	+	#[test]
124	+	fn parses_synced_lyrics() {
125	+	let lyrics = Lyrics::parse(
126	+	"[ar:Someone]\n[ti:Song]\n[00:12.50]First\n[00:05.1][01:00.000]Chorus\n\n[00:20]Last",
127	+	);
128	+	let Lyrics::Synced(lines) = &lyrics else {
129	+	panic!("expected synced lyrics");
130	+	};
131	+	let times: Vec<_> = lines.iter().map(\|l\| l.time).collect();
132	+	assert_eq!(times, [ms(5_100), ms(12_500), ms(20_000), ms(60_000)]);
133	+	assert_eq!(lines[0].text, "Chorus");
134	+	assert_eq!(lyrics.current_line(ms(0)), None);
135	+	assert_eq!(lyrics.current_line(ms(12_500)), Some(1));
136	+	assert_eq!(lyrics.current_line(ms(90_000)), Some(3));
137	+	}
138	+
139	+	#[test]
140	+	fn applies_offset() {
141	+	let lyrics = Lyrics::parse("[offset:+500]\n[00:01.00]a\n[00:00.20]b");
142	+	let Lyrics::Synced(lines) = lyrics else {
143	+	panic!("expected synced lyrics");
144	+	};
145	+	assert_eq!(lines[0].time, ms(0));
146	+	assert_eq!(lines[1].time, ms(500));
147	+	}
148	+
149	+	#[test]
150	+	fn falls_back_to_plain() {
151	+	let lyrics = Lyrics::parse("Just some\nwords [not a tag]\n");
152	+	assert_eq!(
153	+	lyrics,
154	+	Lyrics::Plain(vec!["Just some".into(), "words [not a tag]".into()])
155	+	);
156	+	assert_eq!(lyrics.current_line(ms(1000)), None);
157	+	}
158	+
159	+	#[test]
160	+	fn rejects_bad_timestamps() {
161	+	assert_eq!(parse_timestamp("1:75.00"), None);
162	+	assert_eq!(parse_timestamp("ab:10"), None);
163	+	assert_eq!(parse_timestamp("02:03.4567"), Some(ms(123_456)));
164	+	}
165	+	}

	@@ -0,0 +1,373 @@
1	+	//! Finding lyrics for the current song.
2	+	//!
3	+	//! Sources, in order: an `.lrc` file next to the song, the on-disk cache, and
4	+	//! [LRCLIB](https://lrclib.net).
5	+
6	+	mod lrc;
7	+
8	+	use std::{
9	+	collections::HashMap,
10	+	path::{Path, PathBuf},
11	+	time::Duration,
12	+	};
13	+
14	+	pub use lrc::{LyricLine, Lyrics};
15	+	use serde::Deserialize;
16	+	use tokio::{sync::mpsc, task::JoinHandle};
17	+	use tracing::{debug, warn};
18	+
19	+	use crate::{config::LyricsConfig, event::AppEvent, mpd::Song, util};
20	+
21	+	/// What the UI knows about the lyrics of the current song.
22	+	#[derive(Clone, Debug, Default)]
23	+	pub enum LyricsStatus {
24	+	#[default]
25	+	Idle,
26	+	Loading,
27	+	Found(Lyrics),
28	+	NotFound,
29	+	Failed(String),
30	+	}
31	+
32	+	#[derive(Debug, Default)]
33	+	pub struct LyricsState {
34	+	/// The song the status belongs to.
35	+	pub file: Option<String>,
36	+	pub status: LyricsStatus,
37	+	}
38	+
39	+	impl LyricsState {
40	+	pub fn lyrics(&self) -> Option<&Lyrics> {
41	+	match &self.status {
42	+	LyricsStatus::Found(lyrics) => Some(lyrics),
43	+	_ => None,
44	+	}
45	+	}
46	+	}
47	+
48	+	/// The result of a lookup, sent back as an [`AppEvent::Lyrics`].
49	+	pub type LookupResult = Result<Option<Lyrics>, String>;
50	+
51	+	pub struct LyricsService {
52	+	config: LyricsConfig,
53	+	http: reqwest::Client,
54	+	events: mpsc::UnboundedSender<AppEvent>,
55	+	task: Option<JoinHandle<()>>,
56	+	/// Results of this session, including misses, to avoid repeated lookups.
57	+	memory: HashMap<String, Option<Lyrics>>,
58	+	pub state: LyricsState,
59	+	}
60	+
61	+	impl LyricsService {
62	+	pub fn new(config: LyricsConfig, events: mpsc::UnboundedSender<AppEvent>) -> Self {
63	+	let http = reqwest::Client::builder()
64	+	.user_agent(concat!(
65	+	"rmptui/",
66	+	env!("CARGO_PKG_VERSION"),
67	+	" (https://github.com/krolyxon/rmptui)"
68	+	))
69	+	.timeout(Duration::from_secs(10))
70	+	.build()
71	+	.unwrap_or_default();
72	+	Self {
73	+	config,
74	+	http,
75	+	events,
76	+	task: None,
77	+	memory: HashMap::new(),
78	+	state: LyricsState::default(),
79	+	}
80	+	}
81	+
82	+	/// Makes sure lyrics for `song` are loaded or being loaded. With `force`,
83	+	/// skips the session memory and the cache.
84	+	pub fn ensure(&mut self, song: Option<&Song>, music_dir: Option<&Path>, force: bool) {
85	+	let Some(song) = song else {
86	+	self.cancel();
87	+	self.state = LyricsState::default();
88	+	return;
89	+	};
90	+	if !force && self.state.file.as_deref() == Some(song.file.as_str()) {
91	+	return;
92	+	}
93	+	self.cancel();
94	+	self.state.file = Some(song.file.clone());
95	+	if !force && let Some(known) = self.memory.get(&song.file) {
96	+	self.state.status = known
97	+	.clone()
98	+	.map_or(LyricsStatus::NotFound, LyricsStatus::Found);
99	+	return;
100	+	}
101	+	self.state.status = LyricsStatus::Loading;
102	+	let request = Lookup {
103	+	file: song.file.clone(),
104	+	artist: song.artist().map(str::to_owned),
105	+	title: lookup_title(song),
106	+	album: song.album().map(str::to_owned),
107	+	duration: song.duration,
108	+	local: music_dir.map(\|dir\| dir.join(&song.file).with_extension("lrc")),
109	+	use_cache: self.config.cache && !force,
110	+	write_cache: self.config.cache,
111	+	online: self.config.online,
112	+	base_url: self.config.lrclib_url.trim_end_matches('/').to_owned(),
113	+	};
114	+	let http = self.http.clone();
115	+	let events = self.events.clone();
116	+	self.task = Some(tokio::spawn(async move {
117	+	let file = request.file.clone();
118	+	let result = request.run(&http).await;
119	+	let _ = events.send(AppEvent::Lyrics { file, result });
120	+	}));
121	+	}
122	+
123	+	/// Applies a finished lookup. Returns whether it was for the current song.
124	+	pub fn finish(&mut self, file: String, result: LookupResult) -> bool {
125	+	match &result {
126	+	Ok(found) => {
127	+	self.memory.insert(file.clone(), found.clone());
128	+	}
129	+	Err(error) => warn!("lyrics lookup for {file} failed: {error}"),
130	+	}
131	+	if self.state.file.as_deref() != Some(file.as_str()) {
132	+	return false;
133	+	}
134	+	self.task = None;
135	+	self.state.status = match result {
136	+	Ok(Some(lyrics)) => LyricsStatus::Found(lyrics),
137	+	Ok(None) => LyricsStatus::NotFound,
138	+	Err(error) => LyricsStatus::Failed(error),
139	+	};
140	+	true
141	+	}
142	+
143	+	fn cancel(&mut self) {
144	+	if let Some(task) = self.task.take() {
145	+	task.abort();
146	+	}
147	+	}
148	+	}
149	+
150	+	struct Lookup {
151	+	file: String,
152	+	artist: Option<String>,
153	+	title: Option<String>,
154	+	album: Option<String>,
155	+	duration: Option<Duration>,
156	+	local: Option<PathBuf>,
157	+	use_cache: bool,
158	+	write_cache: bool,
159	+	online: bool,
160	+	base_url: String,
161	+	}
162	+
163	+	impl Lookup {
164	+	async fn run(self, http: &reqwest::Client) -> LookupResult {
165	+	if let Some(path) = &self.local
166	+	&& let Some(lyrics) = read_lyrics(path).await
167	+	{
168	+	debug!("lyrics for {} from {}", self.file, path.display());
169	+	return Ok(Some(lyrics));
170	+	}
171	+	let (Some(artist), Some(title)) = (&self.artist, &self.title) else {
172	+	return Ok(None);
173	+	};
174	+	let cache_path = cache_path(artist, title);
175	+	if self.use_cache
176	+	&& let Some(lyrics) = read_lyrics(&cache_path).await
177	+	{
178	+	return Ok(Some(lyrics));
179	+	}
180	+	if !self.online {
181	+	return Ok(None);
182	+	}
183	+	let Some(text) = self.fetch(http, artist, title).await? else {
184	+	return Ok(None);
185	+	};
186	+	if self.write_cache {
187	+	if let Some(parent) = cache_path.parent() {
188	+	let _ = tokio::fs::create_dir_all(parent).await;
189	+	}
190	+	if let Err(error) = tokio::fs::write(&cache_path, &text).await {
191	+	warn!(
192	+	"cannot write lyrics cache {}: {error}",
193	+	cache_path.display()
194	+	);
195	+	}
196	+	}
197	+	let lyrics = Lyrics::parse(&text);
198	+	Ok((!lyrics.is_empty()).then_some(lyrics))
199	+	}
200	+
201	+	/// Asks LRCLIB for an exact match first, then falls back to a search.
202	+	async fn fetch(
203	+	&self,
204	+	http: &reqwest::Client,
205	+	artist: &str,
206	+	title: &str,
207	+	) -> Result<Option<String>, String> {
208	+	let mut query = vec![
209	+	("artist_name", artist.to_owned()),
210	+	("track_name", title.to_owned()),
211	+	];
212	+	if let Some(album) = &self.album {
213	+	query.push(("album_name", album.clone()));
214	+	}
215	+	if let Some(duration) = self.duration {
216	+	query.push(("duration", duration.as_secs().to_string()));
217	+	}
218	+	let response = http
219	+	.get(format!("{}/api/get", self.base_url))
220	+	.query(&query)
221	+	.send()
222	+	.await
223	+	.map_err(\|e\| e.to_string())?;
224	+	if response.status().is_success() {
225	+	let record: Record = response.json().await.map_err(\|e\| e.to_string())?;
226	+	if let Some(text) = record.text() {
227	+	return Ok(Some(text));
228	+	}
229	+	} else if response.status() != reqwest::StatusCode::NOT_FOUND {
230	+	return Err(format!("LRCLIB answered {}", response.status()));
231	+	}
232	+
233	+	let records: Vec<Record> = http
234	+	.get(format!("{}/api/search", self.base_url))
235	+	.query(&[("artist_name", artist), ("track_name", title)])
236	+	.send()
237	+	.await
238	+	.and_then(reqwest::Response::error_for_status)
239	+	.map_err(\|e\| e.to_string())?
240	+	.json()
241	+	.await
242	+	.map_err(\|e\| e.to_string())?;
243	+	// Prefer synced lyrics, then plain ones.
244	+	let synced = records
245	+	.iter()
246	+	.find_map(\|r\| r.synced_lyrics.clone().filter(\|s\| !s.trim().is_empty()));
247	+	Ok(synced.or_else(\|\| records.iter().find_map(Record::text)))
248	+	}
249	+	}
250	+
251	+	#[derive(Debug, Deserialize)]
252	+	#[serde(rename_all = "camelCase")]
253	+	struct Record {
254	+	#[serde(default)]
255	+	instrumental: bool,
256	+	plain_lyrics: Option<String>,
257	+	synced_lyrics: Option<String>,
258	+	}
259	+
260	+	impl Record {
261	+	fn text(&self) -> Option<String> {
262	+	if self.instrumental {
263	+	return Some("♪ Instrumental ♪".to_owned());
264	+	}
265	+	self.synced_lyrics
266	+	.clone()
267	+	.filter(\|s\| !s.trim().is_empty())
268	+	.or_else(\|\| self.plain_lyrics.clone().filter(\|s\| !s.trim().is_empty()))
269	+	}
270	+	}
271	+
272	+	/// The title to look lyrics up by: the Title tag, or a title derived from
273	+	/// the file name (`05. Artist - Title (Explicit).mp3` → `Title`), without
274	+	/// markers that lyric databases do not include.
275	+	fn lookup_title(song: &Song) -> Option<String> {
276	+	let mut title = song
277	+	.title()
278	+	.map_or_else(\|\| title_from_file_name(song), str::to_owned);
279	+	for marker in [
280	+	"(Explicit)",
281	+	"[Explicit]",
282	+	"(explicit)",
283	+	"[explicit]",
284	+	"(Clean)",
285	+	"[Clean]",
286	+	] {
287	+	title = title.replace(marker, "");
288	+	}
289	+	let title = title.trim().to_owned();
290	+	// A bare track number is not a title.
291	+	(!title.chars().all(\|c\| c.is_ascii_digit())).then_some(title)
292	+	}
293	+
294	+	/// Strips a leading track number (`05. `, `05 - `, `05_`) and `Artist - `.
295	+	fn title_from_file_name(song: &Song) -> String {
296	+	let stem = song.display_title();
297	+	let without_artist = \|s: &str\| -> Option<String> {
298	+	let rest = s.strip_prefix(song.artist()?)?;
299	+	Some(rest.trim_start_matches([' ', '-']).to_owned())
300	+	};
301	+	let digits = stem.len() - stem.trim_start_matches(\|c: char\| c.is_ascii_digit()).len();
302	+	let without_track = (digits > 0 && stem[digits..].starts_with(['.', '-', '_', ' ']))
303	+	.then(\|\| stem[digits..].trim_start_matches(['.', '-', '_', ' ']));
304	+	without_artist(stem)
305	+	.or_else(\|\| without_track.and_then(without_artist))
306	+	.or_else(\|\| without_track.map(str::to_owned))
307	+	.unwrap_or_else(\|\| stem.to_owned())
308	+	}
309	+
310	+	async fn read_lyrics(path: &Path) -> Option<Lyrics> {
311	+	let text = tokio::fs::read_to_string(path).await.ok()?;
312	+	let lyrics = Lyrics::parse(&text);
313	+	(!lyrics.is_empty()).then_some(lyrics)
314	+	}
315	+
316	+	fn cache_path(artist: &str, title: &str) -> PathBuf {
317	+	let name: String = format!("{artist} - {title}")
318	+	.chars()
319	+	.map(\|c\| {
320	+	if matches!(c, '/' \| '\\' \| '\0') \|\| c.is_control() {
321	+	'_'
322	+	} else {
323	+	c
324	+	}
325	+	})
326	+	.take(200)
327	+	.collect();
328	+	util::cache_dir().join("lyrics").join(format!("{name}.lrc"))
329	+	}
330	+
331	+	#[cfg(test)]
332	+	mod tests {
333	+	use super::*;
334	+
335	+	#[test]
336	+	fn derives_lookup_titles() {
337	+	let song = \|file: &str, tags: &[(&str, &str)]\| Song {
338	+	file: file.into(),
339	+	tags: tags
340	+	.iter()
341	+	.map(\|(k, v)\| ((k).into(), (v).into()))
342	+	.collect(),
343	+	..Song::default()
344	+	};
345	+	let untagged = song(
346	+	"x/05. 50 Cent - Candy Shop (Explicit).mp3",
347	+	&[("Artist", "50 Cent")],
348	+	);
349	+	assert_eq!(lookup_title(&untagged).as_deref(), Some("Candy Shop"));
350	+	let tagged = song("x/a.flac", &[("Title", "Song [Explicit]")]);
351	+	assert_eq!(lookup_title(&tagged).as_deref(), Some("Song"));
352	+	assert_eq!(lookup_title(&song("x/01.mp3", &[])), None);
353	+	}
354	+
355	+	#[test]
356	+	fn sanitizes_cache_names() {
357	+	let path = cache_path("AC/DC", "T.N.T.");
358	+	assert_eq!(path.file_name().unwrap(), "AC_DC - T.N.T..lrc");
359	+	}
360	+
361	+	#[test]
362	+	fn prefers_synced_record_text() {
363	+	let record: Record = serde_json::from_str(
364	+	r#"{"instrumental":false,"plainLyrics":"plain","syncedLyrics":"[00:01.00]synced"}"#,
365	+	)
366	+	.unwrap();
367	+	assert_eq!(record.text().as_deref(), Some("[00:01.00]synced"));
368	+	let record: Record =
369	+	serde_json::from_str(r#"{"instrumental":true,"plainLyrics":null,"syncedLyrics":null}"#)
370	+	.unwrap();
371	+	assert!(record.text().unwrap().contains("Instrumental"));
372	+	}
373	+	}

		@@ -1,188 +1,59 @@
1		−	use std::{env, io, net::Ipv6Addr, str::FromStr, time::Duration};
	1	+	use std::{io, path::PathBuf, process::ExitCode};
2	2
3		−	use crossterm::event::{Event as CrosstermEvent, EventStream, KeyEventKind};
4		−	use futures_util::StreamExt;
5		−	use ratatui::prelude::*;
6		−	use rmptui::{
7		−	app::App,
8		−	config::Config,
9		−	connection::{Connection, MpdSnapshot},
10		−	event_handler::handler,
11		−	logging, tui, AppResult,
	3	+	use clap::Parser;
	4	+	use crossterm::{
	5	+	event::{DisableMouseCapture, EnableMouseCapture},
	6	+	execute,
12	7		};
13		−	use tokio::{sync::mpsc, time};
14		−
15		−	#[tokio::main]
16		−	async fn main() -> AppResult<()> {
17		−	let log_path = std::path::Path::new("/tmp/rmptui.log");
18		−	if let Err(error) = logging::init(log_path) {
19		−	eprintln!(
20		−	"Could not initialize logging at {}: {error}",
21		−	log_path.display()
22		−	);
23		−	}
24		−
25		−	let result = run().await;
26		−	if let Err(error) = &result {
27		−	logging::error(&format!("application exited with error: {error}"));
28		−	}
29		−	result
	8	+	use rmptui::{app::App, config::Config, logging};
	9	+
	10	+	/// A fast, keyboard-driven MPD client for the terminal.
	11	+	#[derive(Debug, Parser)]
	12	+	#[command(version, about)]
	13	+	struct Args {
	14	+	/// Use this configuration file instead of the default location.
	15	+	#[arg(short, long, value_name = "FILE")]
	16	+	config: Option<PathBuf>,
	17	+	/// Print the default configuration and exit.
	18	+	#[arg(long)]
	19	+	print_default_config: bool,
30	20		}
31	21
32		−	async fn run() -> AppResult<()> {
33		−	let (config, config_path) = Config::load_or_create()?;
34		−	eprintln!("Using configuration: {}", config_path.display());
35		−
36		−	let configured_host = env::var("MPD_HOST").unwrap_or_else(\|_\| config.mpd.host.clone());
37		−	let (host, password) = configured_host
38		−	.split_once('@')
39		−	.map(\|(password, host)\| (host, Some(password.to_string())))
40		−	.unwrap_or_else(\|\| {
41		−	(
42		−	configured_host.as_str(),
43		−	(!config.mpd.password.is_empty()).then(\|\| config.mpd.password.clone()),
44		−	)
45		−	});
46		−	if host.is_empty() {
47		−	return Err(io::Error::new(io::ErrorKind::InvalidInput, "MPD host cannot be empty").into());
48		−	}
49		−	let port = env::var("MPD_PORT")
50		−	.map(\|port\| {
51		−	port.parse::<u16>().map_err(\|error\| {
52		−	io::Error::new(
53		−	std::io::ErrorKind::InvalidInput,
54		−	format!("invalid MPD_PORT value `{port}`: {error}"),
55		−	)
56		−	})
57		−	})
58		−	.unwrap_or(Ok(config.mpd.port))?;
59		−	if port == 0 {
60		−	return Err(io::Error::new(
61		−	std::io::ErrorKind::InvalidInput,
62		−	"MPD port must be between 1 and 65535",
63		−	)
64		−	.into());
65		−	}
66		−	let address = mpd_address(host, port);
67		−	let mut app = App::new(&address, password.as_deref(), config).await?;
68		−
69		−	let backend = CrosstermBackend::new(io::stderr());
70		−	let terminal = Terminal::new(backend)?;
71		−	let mut tui = tui::Tui::new(terminal);
72		−	tui.init()?;
73		−
74		−	let (updates_tx, mut updates_rx) = mpsc::channel(16);
75		−	let watcher_address = address.clone();
76		−	let watcher_password = password.clone();
77		−	let watcher = tokio::spawn(async move {
78		−	let result = watch_mpd(watcher_address, watcher_password, updates_tx).await;
79		−	if let Err(error) = &result {
80		−	logging::error(&format!("MPD change watcher failed: {error}"));
81		−	}
82		−	result
83		−	});
84		−	let mut terminal_events = EventStream::new();
85		−	let mut redraw = time::interval(Duration::from_millis(50));
86		−	redraw.set_missed_tick_behavior(time::MissedTickBehavior::Skip);
87		−
88		−	let run_result: AppResult<()> = async {
89		−	while app.running {
90		−	tui.draw(&mut app)?;
91		−	tokio::select! {
92		−	event = terminal_events.next() => {
93		−	match event {
94		−	Some(Ok(CrosstermEvent::Key(key)))
95		−	if key.kind != KeyEventKind::Release =>
96		−	{
97		−	handler::handle_key_events(key, &mut app).await?;
98		−	}
99		−	Some(Ok(CrosstermEvent::Key(_))) => {}
100		−	Some(Ok(CrosstermEvent::Mouse(mouse))) => {
101		−	handler::handle_mouse_events(mouse, &mut app).await?;
102		−	}
103		−	Some(Ok(CrosstermEvent::Resize(_, _)))
104		−	\| Some(Ok(CrosstermEvent::FocusGained))
105		−	\| Some(Ok(CrosstermEvent::FocusLost))
106		−	\| Some(Ok(CrosstermEvent::Paste(_))) => {}
107		−	Some(Err(error)) => {
108		−	return Err(Box::new(error) as Box<dyn std::error::Error + Send + Sync>);
109		−	}
110		−	None => {
111		−	return Err(std::io::Error::other("terminal event stream ended").into());
112		−	}
113		−	}
114		−	}
115		−	_ = redraw.tick() => {}
116		−	snapshot = updates_rx.recv() => {
117		−	match snapshot {
118		−	Some(snapshot) => app.apply_snapshot(snapshot).await?,
119		−	None => {
120		−	return Err(std::io::Error::other(
121		−	"MPD change watcher stopped unexpectedly",
122		−	)
123		−	.into());
124		−	}
125		−	}
126		−	}
127		−	}
	22	+	#[tokio::main]
	23	+	async fn main() -> ExitCode {
	24	+	let args = Args::parse();
	25	+	if args.print_default_config {
	26	+	print!("{}", rmptui::config::DEFAULT_CONFIG);
	27	+	return ExitCode::SUCCESS;
	28	+	}
	29	+	if let Err(error) = logging::init(logging::LOG_PATH.as_ref()) {
	30	+	eprintln!("rmptui: cannot log to {}: {error}", logging::LOG_PATH);
	31	+	}
	32	+	match run(args).await {
	33	+	Ok(()) => ExitCode::SUCCESS,
	34	+	Err(error) => {
	35	+	tracing::error!("exiting: {error:#}");
	36	+	eprintln!("rmptui: {error:#}");
	37	+	ExitCode::FAILURE
128	38		}
129		−	Ok(())
130	39		}
131		−	.await;
132		−
133		−	watcher.abort();
134		−	let exit_result = tui.exit();
135		−	run_result?;
136		−	exit_result?;
137		−	Ok(())
138	40		}
139	41
140		−	async fn watch_mpd(
141		−	address: String,
142		−	password: Option<String>,
143		−	updates: mpsc::Sender<MpdSnapshot>,
144		−	) -> AppResult<()> {
145		−	let mut client = Connection::connect(&address, password.as_deref()).await?;
146		−	loop {
147		−	client.idle().await?;
148		−	let snapshot = client.snapshot().await?;
149		−	if updates.send(snapshot).await.is_err() {
150		−	return Ok(());
151		−	}
152		−	}
153		−	}
	42	+	async fn run(args: Args) -> anyhow::Result<()> {
	43	+	let (config, path) = Config::load(args.config.as_deref())?;
	44	+	tracing::info!("using configuration {}", path.display());
	45	+	let mouse = config.ui.mouse;
	46	+	let app = App::new(config)?;
154	47
155		−	fn mpd_address(host: &str, port: u16) -> String {
156		−	if host.starts_with('[') && host.contains("]:") {
157		−	host.to_string()
158		−	} else if let Some(ipv6) = host
159		−	.strip_prefix('[')
160		−	.and_then(\|host\| host.strip_suffix(']'))
161		−	.filter(\|host\| Ipv6Addr::from_str(host).is_ok())
162		−	{
163		−	format!("[{ipv6}]:{port}")
164		−	} else if host.contains(':') && Ipv6Addr::from_str(host).is_ok() {
165		−	format!("[{host}]:{port}")
166		−	} else if host
167		−	.rsplit_once(':')
168		−	.is_some_and(\|(_, suffix)\| suffix.parse::<u16>().is_ok())
169		−	{
170		−	host.to_string()
171		−	} else {
172		−	format!("{host}:{port}")
	48	+	// `init` installs a panic hook that restores the terminal.
	49	+	let mut terminal = ratatui::init();
	50	+	if mouse {
	51	+	execute!(io::stdout(), EnableMouseCapture)?;
173	52		}
174		−	}
175		−
176		−	#[cfg(test)]
177		−	mod tests {
178		−	use super::mpd_address;
179		−
180		−	#[test]
181		−	fn formats_mpd_host_addresses() {
182		−	assert_eq!(mpd_address("localhost", 6600), "localhost:6600");
183		−	assert_eq!(mpd_address("localhost:6601", 6600), "localhost:6601");
184		−	assert_eq!(mpd_address("[::1]", 6600), "[::1]:6600");
185		−	assert_eq!(mpd_address("[::1]:6601", 6600), "[::1]:6601");
186		−	assert_eq!(mpd_address("::1", 6600), "[::1]:6600");
	53	+	let result = app.run(&mut terminal).await;
	54	+	if mouse {
	55	+	let _ = execute!(io::stdout(), DisableMouseCapture);
187	56		}
	57	+	ratatui::restore();
	58	+	result
188	59		}

	@@ -0,0 +1,168 @@
1	+	//! Constructors for the commands rmptui sends.
2	+
3	+	use super::protocol::Command;
4	+
5	+	fn bool_arg(value: bool) -> &'static str {
6	+	if value { "1" } else { "0" }
7	+	}
8	+
9	+	pub fn play() -> Command {
10	+	Command::new("play")
11	+	}
12	+
13	+	pub fn play_pos(pos: u32) -> Command {
14	+	Command::new("play").arg(pos.to_string())
15	+	}
16	+
17	+	pub fn play_id(id: u32) -> Command {
18	+	Command::new("playid").arg(id.to_string())
19	+	}
20	+
21	+	pub fn pause(paused: bool) -> Command {
22	+	Command::new("pause").arg(bool_arg(paused))
23	+	}
24	+
25	+	pub fn stop() -> Command {
26	+	Command::new("stop")
27	+	}
28	+
29	+	pub fn next() -> Command {
30	+	Command::new("next")
31	+	}
32	+
33	+	pub fn previous() -> Command {
34	+	Command::new("previous")
35	+	}
36	+
37	+	/// Seeks relative to the current position.
38	+	pub fn seek_relative(seconds: i64) -> Command {
39	+	Command::new("seekcur").arg(format!("{seconds:+}"))
40	+	}
41	+
42	+	pub fn seek_to(seconds: f64) -> Command {
43	+	Command::new("seekcur").arg(format!("{seconds:.3}"))
44	+	}
45	+
46	+	/// Changes the volume relative to the current level. The server applies the
47	+	/// change atomically, so fast repeated key presses are never lost.
48	+	pub fn change_volume(delta: i32) -> Command {
49	+	Command::new("volume").arg(format!("{delta:+}"))
50	+	}
51	+
52	+	pub fn set_volume(volume: u8) -> Command {
53	+	Command::new("setvol").arg(volume.min(100).to_string())
54	+	}
55	+
56	+	pub fn repeat(on: bool) -> Command {
57	+	Command::new("repeat").arg(bool_arg(on))
58	+	}
59	+
60	+	pub fn random(on: bool) -> Command {
61	+	Command::new("random").arg(bool_arg(on))
62	+	}
63	+
64	+	pub fn single(on: bool) -> Command {
65	+	Command::new("single").arg(bool_arg(on))
66	+	}
67	+
68	+	pub fn consume(on: bool) -> Command {
69	+	Command::new("consume").arg(bool_arg(on))
70	+	}
71	+
72	+	pub fn update(path: Option<&str>) -> Command {
73	+	let command = Command::new("update");
74	+	match path {
75	+	Some(path) if !path.is_empty() => command.arg(path),
76	+	_ => command,
77	+	}
78	+	}
79	+
80	+	pub fn clear() -> Command {
81	+	Command::new("clear")
82	+	}
83	+
84	+	pub fn shuffle() -> Command {
85	+	Command::new("shuffle")
86	+	}
87	+
88	+	/// Adds a song or (recursively) a directory to the queue.
89	+	pub fn add(uri: &str) -> Command {
90	+	Command::new("add").arg(uri)
91	+	}
92	+
93	+	pub fn add_id(uri: &str) -> Command {
94	+	Command::new("addid").arg(uri)
95	+	}
96	+
97	+	pub fn delete_pos(pos: u32) -> Command {
98	+	Command::new("delete").arg(pos.to_string())
99	+	}
100	+
101	+	pub fn delete_id(id: u32) -> Command {
102	+	Command::new("deleteid").arg(id.to_string())
103	+	}
104	+
105	+	/// Moves the song at queue position `from` to `to`. Positions (unlike ids)
106	+	/// stay correct when several moves are sent before the queue is refreshed.
107	+	pub fn move_pos(from: u32, to: u32) -> Command {
108	+	Command::new("move")
109	+	.arg(from.to_string())
110	+	.arg(to.to_string())
111	+	}
112	+
113	+	pub fn find_add(filter: &str) -> Command {
114	+	Command::new("findadd").arg(filter)
115	+	}
116	+
117	+	pub fn load(playlist: &str) -> Command {
118	+	Command::new("load").arg(playlist)
119	+	}
120	+
121	+	pub fn save(playlist: &str) -> Command {
122	+	Command::new("save").arg(playlist)
123	+	}
124	+
125	+	pub fn rename(from: &str, to: &str) -> Command {
126	+	Command::new("rename").arg(from).arg(to)
127	+	}
128	+
129	+	pub fn remove_playlist(playlist: &str) -> Command {
130	+	Command::new("rm").arg(playlist)
131	+	}
132	+
133	+	/// Adds a song or directory to a stored playlist, creating it if needed.
134	+	pub fn playlist_add(playlist: &str, uri: &str) -> Command {
135	+	Command::new("playlistadd").arg(playlist).arg(uri)
136	+	}
137	+
138	+	/// Adds every song matching `filter` to a stored playlist.
139	+	pub fn playlist_add_filter(playlist: &str, filter: &str) -> Command {
140	+	Command::new("searchaddpl").arg(playlist).arg(filter)
141	+	}
142	+
143	+	pub fn playlist_delete(playlist: &str, pos: u32) -> Command {
144	+	Command::new("playlistdelete")
145	+	.arg(playlist)
146	+	.arg(pos.to_string())
147	+	}
148	+
149	+	pub fn playlist_move(playlist: &str, from: u32, to: u32) -> Command {
150	+	Command::new("playlistmove")
151	+	.arg(playlist)
152	+	.arg(from.to_string())
153	+	.arg(to.to_string())
154	+	}
155	+
156	+	#[cfg(test)]
157	+	mod tests {
158	+	use super::*;
159	+
160	+	#[test]
161	+	fn formats_relative_arguments() {
162	+	assert_eq!(seek_relative(5).as_str(), r#"seekcur "+5""#);
163	+	assert_eq!(seek_relative(-5).as_str(), r#"seekcur "-5""#);
164	+	assert_eq!(change_volume(-2).as_str(), r#"volume "-2""#);
165	+	assert_eq!(update(None).as_str(), "update");
166	+	assert_eq!(set_volume(140).as_str(), r#"setvol "100""#);
167	+	}
168	+	}

	@@ -0,0 +1,173 @@
1	+	//! An asynchronous MPD connection over TCP or a Unix socket.
2	+
3	+	use std::{fmt, path::PathBuf};
4	+
5	+	use tokio::{
6	+	io::{AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, BufStream},
7	+	net::TcpStream,
8	+	};
9	+
10	+	use super::{
11	+	error::{MpdError, MpdResult},
12	+	protocol::{self, Command, Line, Pair},
13	+	};
14	+
15	+	/// Where the server listens.
16	+	#[derive(Clone, Debug, PartialEq, Eq)]
17	+	pub enum Address {
18	+	/// `host:port`, with IPv6 hosts in brackets.
19	+	Tcp(String),
20	+	Unix(PathBuf),
21	+	}
22	+
23	+	impl Address {
24	+	/// Whether the server runs on this machine.
25	+	pub fn is_local(&self) -> bool {
26	+	match self {
27	+	Self::Unix(_) => true,
28	+	Self::Tcp(addr) => {
29	+	let host = addr
30	+	.rsplit_once(':')
31	+	.map_or(addr.as_str(), \|(host, _)\| host)
32	+	.trim_start_matches('[')
33	+	.trim_end_matches(']');
34	+	matches!(host, "localhost" \| "127.0.0.1" \| "::1") \|\| host.starts_with("127.")
35	+	}
36	+	}
37	+	}
38	+	}
39	+
40	+	impl fmt::Display for Address {
41	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42	+	match self {
43	+	Self::Tcp(addr) => f.write_str(addr),
44	+	Self::Unix(path) => write!(f, "{}", path.display()),
45	+	}
46	+	}
47	+	}
48	+
49	+	trait Socket: AsyncRead + AsyncWrite + Unpin + Send {}
50	+	impl<T: AsyncRead + AsyncWrite + Unpin + Send> Socket for T {}
51	+
52	+	pub struct Connection {
53	+	stream: BufStream<Box<dyn Socket>>,
54	+	version: String,
55	+	line: Vec<u8>,
56	+	}
57	+
58	+	impl fmt::Debug for Connection {
59	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
60	+	f.debug_struct("Connection")
61	+	.field("version", &self.version)
62	+	.finish_non_exhaustive()
63	+	}
64	+	}
65	+
66	+	impl Connection {
67	+	/// Connects, reads the greeting and authenticates if `password` is set.
68	+	pub async fn connect(address: &Address, password: Option<&str>) -> MpdResult<Self> {
69	+	let socket: Box<dyn Socket> = match address {
70	+	Address::Tcp(addr) => {
71	+	let stream = TcpStream::connect(addr).await?;
72	+	stream.set_nodelay(true)?;
73	+	Box::new(stream)
74	+	}
75	+	#[cfg(unix)]
76	+	Address::Unix(path) => Box::new(tokio::net::UnixStream::connect(path).await?),
77	+	#[cfg(not(unix))]
78	+	Address::Unix(_) => {
79	+	return Err(MpdError::Protocol(
80	+	"Unix sockets are not supported on this platform".into(),
81	+	));
82	+	}
83	+	};
84	+	let mut conn = Self {
85	+	stream: BufStream::new(socket),
86	+	version: String::new(),
87	+	line: Vec::new(),
88	+	};
89	+	let greeting = conn.read_line().await?;
90	+	conn.version = protocol::parse_greeting(&greeting)?;
91	+	if let Some(password) = password.filter(\|p\| !p.is_empty()) {
92	+	conn.execute(&Command::new("password").arg(password))
93	+	.await?;
94	+	}
95	+	Ok(conn)
96	+	}
97	+
98	+	/// The protocol version announced by the server.
99	+	pub fn version(&self) -> &str {
100	+	&self.version
101	+	}
102	+
103	+	/// Runs one command and collects its response.
104	+	pub async fn execute(&mut self, command: &Command) -> MpdResult<Vec<Pair>> {
105	+	self.send(command.as_str()).await?;
106	+	self.read_response().await
107	+	}
108	+
109	+	/// Runs commands atomically as a command list, returning one response per
110	+	/// command.
111	+	pub async fn execute_list(&mut self, commands: &[Command]) -> MpdResult<Vec<Vec<Pair>>> {
112	+	let mut request = String::from("command_list_ok_begin\n");
113	+	for command in commands {
114	+	request.push_str(command.as_str());
115	+	request.push('\n');
116	+	}
117	+	request.push_str("command_list_end");
118	+	self.send(&request).await?;
119	+
120	+	let mut responses = Vec::with_capacity(commands.len());
121	+	let mut current = Vec::new();
122	+	loop {
123	+	let line = self.read_line().await?;
124	+	match protocol::parse_line(&line)? {
125	+	Line::Pair(pair) => current.push(pair),
126	+	Line::ListOk => responses.push(std::mem::take(&mut current)),
127	+	Line::Ok => return Ok(responses),
128	+	}
129	+	}
130	+	}
131	+
132	+	/// Runs commands as a list when there is more than one, discarding output.
133	+	pub async fn execute_all(&mut self, commands: &[Command]) -> MpdResult<()> {
134	+	match commands {
135	+	[] => Ok(()),
136	+	[command] => self.execute(command).await.map(drop),
137	+	_ => self.execute_list(commands).await.map(drop),
138	+	}
139	+	}
140	+
141	+	async fn send(&mut self, request: &str) -> MpdResult<()> {
142	+	self.stream.write_all(request.as_bytes()).await?;
143	+	self.stream.write_all(b"\n").await?;
144	+	self.stream.flush().await?;
145	+	Ok(())
146	+	}
147	+
148	+	async fn read_response(&mut self) -> MpdResult<Vec<Pair>> {
149	+	let mut pairs = Vec::new();
150	+	loop {
151	+	let line = self.read_line().await?;
152	+	match protocol::parse_line(&line)? {
153	+	Line::Pair(pair) => pairs.push(pair),
154	+	Line::Ok => return Ok(pairs),
155	+	Line::ListOk => {
156	+	return Err(MpdError::Protocol("unexpected list_OK".into()));
157	+	}
158	+	}
159	+	}
160	+	}
161	+
162	+	async fn read_line(&mut self) -> MpdResult<String> {
163	+	self.line.clear();
164	+	if self.stream.read_until(b'\n', &mut self.line).await? == 0 {
165	+	return Err(MpdError::Closed);
166	+	}
167	+	if self.line.last() == Some(&b'\n') {
168	+	self.line.pop();
169	+	}
170	+	// Tags are UTF-8 by protocol; tolerate broken files instead of failing.
171	+	Ok(String::from_utf8_lossy(&self.line).into_owned())
172	+	}
173	+	}

	@@ -0,0 +1,42 @@
1	+	use std::{fmt, io};
2	+
3	+	/// An `ACK` error returned by the server.
4	+	#[derive(Clone, Debug, PartialEq, Eq)]
5	+	pub struct Ack {
6	+	pub code: u32,
7	+	/// Index of the failing command inside a command list.
8	+	pub index: u32,
9	+	pub command: String,
10	+	pub message: String,
11	+	}
12	+
13	+	impl fmt::Display for Ack {
14	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15	+	if self.command.is_empty() {
16	+	write!(f, "{}", self.message)
17	+	} else {
18	+	write!(f, "{}: {}", self.command, self.message)
19	+	}
20	+	}
21	+	}
22	+
23	+	#[derive(Debug, thiserror::Error)]
24	+	pub enum MpdError {
25	+	#[error("connection error: {0}")]
26	+	Io(#[from] io::Error),
27	+	#[error("MPD error: {0}")]
28	+	Ack(Ack),
29	+	#[error("protocol error: {0}")]
30	+	Protocol(String),
31	+	#[error("connection closed by server")]
32	+	Closed,
33	+	}
34	+
35	+	impl MpdError {
36	+	/// Whether the connection is unusable after this error.
37	+	pub fn is_fatal(&self) -> bool {
38	+	!matches!(self, Self::Ack(_))
39	+	}
40	+	}
41	+
42	+	pub type MpdResult<T> = Result<T, MpdError>;

	@@ -0,0 +1,227 @@
1	+	//! Wire format of MPD's text protocol: command encoding and response parsing.
2	+	//!
3	+	//! Everything here is pure so it can be tested without a server.
4	+
5	+	use std::fmt;
6	+
7	+	use super::error::{Ack, MpdError};
8	+
9	+	/// A single key/value line of an MPD response.
10	+	pub type Pair = (String, String);
11	+
12	+	/// A command ready to be written to the socket.
13	+	///
14	+	/// Arguments are always quoted and escaped, so user-provided names and paths
15	+	/// can never inject additional commands.
16	+	#[derive(Clone, Debug, PartialEq, Eq)]
17	+	pub struct Command {
18	+	line: String,
19	+	}
20	+
21	+	impl Command {
22	+	pub fn new(name: &str) -> Self {
23	+	Self {
24	+	line: name.to_owned(),
25	+	}
26	+	}
27	+
28	+	/// Appends a quoted argument.
29	+	#[must_use]
30	+	pub fn arg(mut self, value: impl AsRef<str>) -> Self {
31	+	self.line.push(' ');
32	+	push_quoted(&mut self.line, value.as_ref());
33	+	self
34	+	}
35	+
36	+	/// The encoded command line, without the trailing newline.
37	+	pub fn as_str(&self) -> &str {
38	+	&self.line
39	+	}
40	+
41	+	/// The command name, used in error messages.
42	+	pub fn name(&self) -> &str {
43	+	self.line.split(' ').next().unwrap_or_default()
44	+	}
45	+	}
46	+
47	+	impl fmt::Display for Command {
48	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
49	+	f.write_str(&self.line)
50	+	}
51	+	}
52	+
53	+	fn push_quoted(out: &mut String, value: &str) {
54	+	out.push('"');
55	+	out.push_str(&escape(value));
56	+	out.push('"');
57	+	}
58	+
59	+	/// Escapes `\` and `"` so that `value` can be placed inside double quotes.
60	+	pub fn escape(value: &str) -> String {
61	+	let mut escaped = String::with_capacity(value.len());
62	+	for ch in value.chars() {
63	+	if matches!(ch, '"' \| '\\') {
64	+	escaped.push('\\');
65	+	}
66	+	escaped.push(ch);
67	+	}
68	+	escaped
69	+	}
70	+
71	+	/// Builds an MPD filter expression `(TAG == "VALUE")`.
72	+	pub fn filter_eq(tag: &str, value: &str) -> String {
73	+	format!("({tag} == \"{}\")", escape(value))
74	+	}
75	+
76	+	/// Combines filter expressions with `AND`.
77	+	pub fn filter_and<I, S>(filters: I) -> String
78	+	where
79	+	I: IntoIterator<Item = S>,
80	+	S: AsRef<str>,
81	+	{
82	+	let parts: Vec<String> = filters.into_iter().map(\|f\| f.as_ref().to_owned()).collect();
83	+	match parts.as_slice() {
84	+	[single] => single.clone(),
85	+	_ => format!("({})", parts.join(" AND ")),
86	+	}
87	+	}
88	+
89	+	/// One parsed response line.
90	+	#[derive(Debug, PartialEq, Eq)]
91	+	pub enum Line {
92	+	/// `OK`: the response is complete.
93	+	Ok,
94	+	/// `list_OK`: one command of a `command_list_ok_begin` list is complete.
95	+	ListOk,
96	+	/// A `key: value` pair.
97	+	Pair(Pair),
98	+	}
99	+
100	+	/// Parses one response line (without its trailing newline).
101	+	pub fn parse_line(line: &str) -> Result<Line, MpdError> {
102	+	match line {
103	+	"OK" => Ok(Line::Ok),
104	+	"list_OK" => Ok(Line::ListOk),
105	+	_ if line.starts_with("ACK ") => Err(MpdError::Ack(parse_ack(line)?)),
106	+	_ => line
107	+	.split_once(": ")
108	+	.map(\|(key, value)\| Line::Pair((key.to_owned(), value.to_owned())))
109	+	.ok_or_else(\|\| MpdError::Protocol(format!("unexpected response line `{line}`"))),
110	+	}
111	+	}
112	+
113	+	/// Parses `ACK [error@command_listNum] {current_command} message_text`.
114	+	fn parse_ack(line: &str) -> Result<Ack, MpdError> {
115	+	let malformed = \|\| MpdError::Protocol(format!("malformed ACK line `{line}`"));
116	+	let rest = line.strip_prefix("ACK [").ok_or_else(malformed)?;
117	+	let (codes, rest) = rest.split_once("] {").ok_or_else(malformed)?;
118	+	let (command, message) = rest.split_once('}').ok_or_else(malformed)?;
119	+	let (code, index) = codes.split_once('@').ok_or_else(malformed)?;
120	+	Ok(Ack {
121	+	code: code.parse().map_err(\|_\| malformed())?,
122	+	index: index.parse().map_err(\|_\| malformed())?,
123	+	command: command.to_owned(),
124	+	message: message.trim_start().to_owned(),
125	+	})
126	+	}
127	+
128	+	/// Parses the `OK MPD <version>` greeting.
129	+	pub fn parse_greeting(line: &str) -> Result<String, MpdError> {
130	+	line.strip_prefix("OK MPD ")
131	+	.map(str::to_owned)
132	+	.ok_or_else(\|\| MpdError::Protocol(format!("not an MPD server (greeting `{line}`)")))
133	+	}
134	+
135	+	/// Splits a flat list of pairs into groups, starting a new group whenever a
136	+	/// key from `starts` is encountered. Pairs before the first start key are
137	+	/// dropped.
138	+	pub fn split_groups<'a>(pairs: &'a [Pair], starts: &[&str]) -> Vec<&'a [Pair]> {
139	+	let mut bounds: Vec<usize> = pairs
140	+	.iter()
141	+	.enumerate()
142	+	.filter(\|(_, (key, _))\| starts.contains(&key.as_str()))
143	+	.map(\|(index, _)\| index)
144	+	.collect();
145	+	bounds.push(pairs.len());
146	+	bounds.windows(2).map(\|w\| &pairs[w[0]..w[1]]).collect()
147	+	}
148	+
149	+	#[cfg(test)]
150	+	mod tests {
151	+	use super::*;
152	+
153	+	#[test]
154	+	fn quotes_and_escapes_arguments() {
155	+	let cmd = Command::new("add").arg(r#"dir/a "quoted" \ name"#);
156	+	assert_eq!(cmd.as_str(), r#"add "dir/a \"quoted\" \\ name""#);
157	+	assert_eq!(cmd.name(), "add");
158	+	}
159	+
160	+	#[test]
161	+	fn newlines_cannot_start_a_new_command() {
162	+	// Newlines stay inside the quoted argument; MPD rejects the argument
163	+	// rather than executing a second command.
164	+	let cmd = Command::new("load").arg("x\"\nclear");
165	+	assert_eq!(cmd.as_str().matches('"').count(), 3);
166	+	assert!(cmd.as_str().contains("\\\""));
167	+	}
168	+
169	+	#[test]
170	+	fn builds_filters() {
171	+	assert_eq!(filter_eq("Artist", r#"A "B""#), r#"(Artist == "A \"B\"")"#);
172	+	assert_eq!(
173	+	filter_and([filter_eq("Artist", "x"), filter_eq("Album", "y")]),
174	+	r#"((Artist == "x") AND (Album == "y"))"#
175	+	);
176	+	assert_eq!(filter_and([filter_eq("Album", "y")]), r#"(Album == "y")"#);
177	+	// Filters are quoted once more when used as an argument.
178	+	let cmd = Command::new("find").arg(filter_eq("Album", r"a\b"));
179	+	assert_eq!(cmd.as_str(), r#"find "(Album == \"a\\\\b\")""#);
180	+	}
181	+
182	+	#[test]
183	+	fn parses_lines() {
184	+	assert_eq!(parse_line("OK").unwrap(), Line::Ok);
185	+	assert_eq!(parse_line("list_OK").unwrap(), Line::ListOk);
186	+	assert_eq!(
187	+	parse_line("Title: a: b").unwrap(),
188	+	Line::Pair(("Title".into(), "a: b".into()))
189	+	);
190	+	assert!(matches!(parse_line("garbage"), Err(MpdError::Protocol(_))));
191	+	}
192	+
193	+	#[test]
194	+	fn parses_ack() {
195	+	let Err(MpdError::Ack(ack)) = parse_line("ACK [50@1] {play} No such song") else {
196	+	panic!("expected ACK");
197	+	};
198	+	assert_eq!(ack.code, 50);
199	+	assert_eq!(ack.index, 1);
200	+	assert_eq!(ack.command, "play");
201	+	assert_eq!(ack.message, "No such song");
202	+	}
203	+
204	+	#[test]
205	+	fn parses_greeting() {
206	+	assert_eq!(parse_greeting("OK MPD 0.24.0").unwrap(), "0.24.0");
207	+	assert!(parse_greeting("HTTP/1.1 400").is_err());
208	+	}
209	+
210	+	#[test]
211	+	fn splits_groups() {
212	+	let pairs: Vec<Pair> = [
213	+	("x", "0"),
214	+	("file", "a"),
215	+	("Title", "A"),
216	+	("directory", "d"),
217	+	("file", "b"),
218	+	]
219	+	.iter()
220	+	.map(\|(k, v)\| ((k).into(), (v).into()))
221	+	.collect();
222	+	let groups = split_groups(&pairs, &["file", "directory"]);
223	+	assert_eq!(groups.len(), 3);
224	+	assert_eq!(groups[0].len(), 2);
225	+	assert_eq!(groups[1][0].1, "d");
226	+	}
227	+	}

	@@ -0,0 +1,36 @@
1	+	use super::{Command, commands};
2	+
3	+	/// A set of songs chosen in the UI, to be added to the queue or a playlist.
4	+	#[derive(Clone, Debug, PartialEq, Eq)]
5	+	pub enum Selection {
6	+	/// Songs or directories (added recursively).
7	+	Uris(Vec<String>),
8	+	/// Every song matching a filter expression.
9	+	Filter(String),
10	+	}
11	+
12	+	impl Selection {
13	+	pub fn is_empty(&self) -> bool {
14	+	match self {
15	+	Self::Uris(uris) => uris.is_empty(),
16	+	Self::Filter(_) => false,
17	+	}
18	+	}
19	+
20	+	pub fn add_to_queue(&self) -> Vec<Command> {
21	+	match self {
22	+	Self::Uris(uris) => uris.iter().map(\|uri\| commands::add(uri)).collect(),
23	+	Self::Filter(filter) => vec![commands::find_add(filter)],
24	+	}
25	+	}
26	+
27	+	pub fn add_to_playlist(&self, playlist: &str) -> Vec<Command> {
28	+	match self {
29	+	Self::Uris(uris) => uris
30	+	.iter()
31	+	.map(\|uri\| commands::playlist_add(playlist, uri))
32	+	.collect(),
33	+	Self::Filter(filter) => vec![commands::playlist_add_filter(playlist, filter)],
34	+	}
35	+	}
36	+	}

	@@ -0,0 +1,425 @@
1	+	//! Typed models built from MPD responses.
2	+
3	+	use std::{path::Path, str::FromStr, time::Duration};
4	+
5	+	use super::protocol::{Pair, split_groups};
6	+
7	+	/// A song as reported by MPD (library entry or queue item).
8	+	#[derive(Clone, Debug, Default, PartialEq)]
9	+	pub struct Song {
10	+	/// Library-relative path or URL.
11	+	pub file: String,
12	+	/// Queue id, present for queue items only.
13	+	pub id: Option<u32>,
14	+	/// Queue position, present for queue items only.
15	+	pub pos: Option<u32>,
16	+	pub duration: Option<Duration>,
17	+	/// Tag values in server order. A tag may occur multiple times.
18	+	pub tags: Vec<(String, String)>,
19	+	}
20	+
21	+	impl Song {
22	+	pub fn from_pairs(pairs: &[Pair]) -> Self {
23	+	let mut song = Self::default();
24	+	for (key, value) in pairs {
25	+	match key.as_str() {
26	+	"file" => song.file.clone_from(value),
27	+	"Id" => song.id = value.parse().ok(),
28	+	"Pos" => song.pos = value.parse().ok(),
29	+	"duration" => song.duration = parse_seconds(value),
30	+	// Older servers only report the integral `Time`.
31	+	"Time" if song.duration.is_none() => song.duration = parse_seconds(value),
32	+	"Last-Modified" \| "Added" \| "Format" \| "Time" \| "Range" \| "Prio" => {}
33	+	_ => song.tags.push((key.clone(), value.clone())),
34	+	}
35	+	}
36	+	song
37	+	}
38	+
39	+	/// The first value of `tag` (case-insensitive).
40	+	pub fn tag(&self, tag: &str) -> Option<&str> {
41	+	self.tags
42	+	.iter()
43	+	.find(\|(key, _)\| key.eq_ignore_ascii_case(tag))
44	+	.map(\|(_, value)\| value.as_str())
45	+	}
46	+
47	+	pub fn title(&self) -> Option<&str> {
48	+	self.tag("Title")
49	+	}
50	+
51	+	pub fn artist(&self) -> Option<&str> {
52	+	self.tag("Artist")
53	+	}
54	+
55	+	pub fn album(&self) -> Option<&str> {
56	+	self.tag("Album")
57	+	}
58	+
59	+	pub fn album_artist(&self) -> Option<&str> {
60	+	self.tag("AlbumArtist").or_else(\|\| self.artist())
61	+	}
62	+
63	+	/// The file name without its directory.
64	+	pub fn file_name(&self) -> &str {
65	+	self.file.rsplit('/').next().unwrap_or(&self.file)
66	+	}
67	+
68	+	/// The title, falling back to the file name without extension.
69	+	pub fn display_title(&self) -> &str {
70	+	self.title().unwrap_or_else(\|\| {
71	+	let name = self.file_name();
72	+	Path::new(name)
73	+	.file_stem()
74	+	.and_then(\|stem\| stem.to_str())
75	+	.unwrap_or(name)
76	+	})
77	+	}
78	+
79	+	/// Track number without a `/total` suffix.
80	+	pub fn track(&self) -> Option<&str> {
81	+	self.tag("Track").map(\|t\| t.split('/').next().unwrap_or(t))
82	+	}
83	+
84	+	/// Sort key for album order: disc, then track number.
85	+	pub fn disc_track(&self) -> (u32, u32) {
86	+	let number = \|tag: &str\| {
87	+	self.tag(tag)
88	+	.and_then(\|t\| t.split('/').next())
89	+	.and_then(\|t\| t.trim().parse().ok())
90	+	.unwrap_or(0)
91	+	};
92	+	(number("Disc"), number("Track"))
93	+	}
94	+	}
95	+
96	+	pub fn parse_songs(pairs: &[Pair]) -> Vec<Song> {
97	+	split_groups(pairs, &["file"])
98	+	.into_iter()
99	+	.map(Song::from_pairs)
100	+	.collect()
101	+	}
102	+
103	+	/// An entry of `lsinfo`.
104	+	#[derive(Clone, Debug, PartialEq)]
105	+	pub enum DirEntry {
106	+	Directory(String),
107	+	Song(Song),
108	+	Playlist(String),
109	+	}
110	+
111	+	impl DirEntry {
112	+	/// The library path of the entry.
113	+	pub fn path(&self) -> &str {
114	+	match self {
115	+	Self::Directory(path) \| Self::Playlist(path) => path,
116	+	Self::Song(song) => &song.file,
117	+	}
118	+	}
119	+
120	+	/// The last path component, as shown in the browser.
121	+	pub fn name(&self) -> &str {
122	+	let path = self.path();
123	+	path.rsplit('/').next().unwrap_or(path)
124	+	}
125	+	}
126	+
127	+	pub fn parse_entries(pairs: &[Pair]) -> Vec<DirEntry> {
128	+	split_groups(pairs, &["file", "directory", "playlist"])
129	+	.into_iter()
130	+	.filter_map(\|group\| {
131	+	let (key, value) = group.first()?;
132	+	Some(match key.as_str() {
133	+	"directory" => DirEntry::Directory(value.clone()),
134	+	"playlist" => DirEntry::Playlist(value.clone()),
135	+	_ => DirEntry::Song(Song::from_pairs(group)),
136	+	})
137	+	})
138	+	.collect()
139	+	}
140	+
141	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
142	+	pub enum PlayState {
143	+	#[default]
144	+	Stop,
145	+	Play,
146	+	Pause,
147	+	}
148	+
149	+	/// The tri-state used by `single` and `consume`.
150	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
151	+	pub enum OnOff {
152	+	#[default]
153	+	Off,
154	+	On,
155	+	Oneshot,
156	+	}
157	+
158	+	impl OnOff {
159	+	fn parse(value: &str) -> Self {
160	+	match value {
161	+	"1" => Self::On,
162	+	"oneshot" => Self::Oneshot,
163	+	_ => Self::Off,
164	+	}
165	+	}
166	+
167	+	pub fn is_on(self) -> bool {
168	+	self != Self::Off
169	+	}
170	+	}
171	+
172	+	#[derive(Clone, Debug, Default, PartialEq)]
173	+	pub struct Status {
174	+	/// `None` when the server has no mixer.
175	+	pub volume: Option<u8>,
176	+	pub repeat: bool,
177	+	pub random: bool,
178	+	pub single: OnOff,
179	+	pub consume: OnOff,
180	+	/// The queue version, bumped on every queue change.
181	+	pub playlist_version: u32,
182	+	pub playlist_length: u32,
183	+	pub state: PlayState,
184	+	/// Queue position of the current song.
185	+	pub song: Option<u32>,
186	+	pub song_id: Option<u32>,
187	+	pub elapsed: Duration,
188	+	pub duration: Option<Duration>,
189	+	/// Kilobits per second.
190	+	pub bitrate: Option<u32>,
191	+	/// `samplerate:bits:channels`.
192	+	pub audio: Option<String>,
193	+	pub updating_db: bool,
194	+	pub error: Option<String>,
195	+	}
196	+
197	+	impl Status {
198	+	pub fn from_pairs(pairs: &[Pair]) -> Self {
199	+	let mut status = Self::default();
200	+	for (key, value) in pairs {
201	+	match key.as_str() {
202	+	"volume" => status.volume = value.parse().ok(),
203	+	"repeat" => status.repeat = value == "1",
204	+	"random" => status.random = value == "1",
205	+	"single" => status.single = OnOff::parse(value),
206	+	"consume" => status.consume = OnOff::parse(value),
207	+	"playlist" => status.playlist_version = parse_or_default(value),
208	+	"playlistlength" => status.playlist_length = parse_or_default(value),
209	+	"state" => {
210	+	status.state = match value.as_str() {
211	+	"play" => PlayState::Play,
212	+	"pause" => PlayState::Pause,
213	+	_ => PlayState::Stop,
214	+	}
215	+	}
216	+	"song" => status.song = value.parse().ok(),
217	+	"songid" => status.song_id = value.parse().ok(),
218	+	"elapsed" => status.elapsed = parse_seconds(value).unwrap_or_default(),
219	+	"duration" => status.duration = parse_seconds(value),
220	+	"bitrate" => status.bitrate = value.parse().ok().filter(\|&b\| b > 0),
221	+	"audio" => status.audio = Some(value.clone()),
222	+	"updating_db" => status.updating_db = true,
223	+	"error" => status.error = Some(value.clone()),
224	+	_ => {}
225	+	}
226	+	}
227	+	status
228	+	}
229	+	}
230	+
231	+	/// A stored playlist.
232	+	#[derive(Clone, Debug, PartialEq, Eq)]
233	+	pub struct PlaylistInfo {
234	+	pub name: String,
235	+	}
236	+
237	+	pub fn parse_playlists(pairs: &[Pair]) -> Vec<PlaylistInfo> {
238	+	let mut playlists: Vec<PlaylistInfo> = pairs
239	+	.iter()
240	+	.filter(\|(key, _)\| key == "playlist")
241	+	.map(\|(_, name)\| PlaylistInfo { name: name.clone() })
242	+	.collect();
243	+	playlists.sort_by_key(\|p\| p.name.to_lowercase());
244	+	playlists
245	+	}
246	+
247	+	/// An album with its (optional) release date, from `list album group date`.
248	+	#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
249	+	pub struct Album {
250	+	pub date: String,
251	+	pub name: String,
252	+	}
253	+
254	+	pub fn parse_albums(pairs: &[Pair]) -> Vec<Album> {
255	+	let mut albums = Vec::new();
256	+	let mut date = String::new();
257	+	for (key, value) in pairs {
258	+	if key.eq_ignore_ascii_case("Date") {
259	+	date.clone_from(value);
260	+	} else if key.eq_ignore_ascii_case("Album") {
261	+	albums.push(Album {
262	+	date: date.clone(),
263	+	name: value.clone(),
264	+	});
265	+	}
266	+	}
267	+	albums.sort();
268	+	albums.dedup();
269	+	albums
270	+	}
271	+
272	+	/// Values of a single tag from `list <tag>`.
273	+	pub fn parse_tag_values(pairs: &[Pair], tag: &str) -> Vec<String> {
274	+	let mut values: Vec<String> = pairs
275	+	.iter()
276	+	.filter(\|(key, _)\| key.eq_ignore_ascii_case(tag))
277	+	.map(\|(_, value)\| value.clone())
278	+	.collect();
279	+	values.sort_by_cached_key(\|v\| v.to_lowercase());
280	+	values.dedup();
281	+	values
282	+	}
283	+
284	+	/// An MPD idle subsystem.
285	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
286	+	pub enum Subsystem {
287	+	Database,
288	+	Update,
289	+	StoredPlaylist,
290	+	Playlist,
291	+	Player,
292	+	Mixer,
293	+	Output,
294	+	Options,
295	+	Other,
296	+	}
297	+
298	+	impl FromStr for Subsystem {
299	+	type Err = std::convert::Infallible;
300	+
301	+	fn from_str(s: &str) -> Result<Self, Self::Err> {
302	+	Ok(match s {
303	+	"database" => Self::Database,
304	+	"update" => Self::Update,
305	+	"stored_playlist" => Self::StoredPlaylist,
306	+	"playlist" => Self::Playlist,
307	+	"player" => Self::Player,
308	+	"mixer" => Self::Mixer,
309	+	"output" => Self::Output,
310	+	"options" => Self::Options,
311	+	_ => Self::Other,
312	+	})
313	+	}
314	+	}
315	+
316	+	pub fn parse_subsystems(pairs: &[Pair]) -> Vec<Subsystem> {
317	+	pairs
318	+	.iter()
319	+	.filter(\|(key, _)\| key == "changed")
320	+	.filter_map(\|(_, value)\| value.parse().ok())
321	+	.collect()
322	+	}
323	+
324	+	fn parse_seconds(value: &str) -> Option<Duration> {
325	+	value
326	+	.parse::<f64>()
327	+	.ok()
328	+	.filter(\|s\| s.is_finite() && *s >= 0.0)
329	+	.map(Duration::from_secs_f64)
330	+	}
331	+
332	+	fn parse_or_default<T: FromStr + Default>(value: &str) -> T {
333	+	value.parse().unwrap_or_default()
334	+	}
335	+
336	+	#[cfg(test)]
337	+	mod tests {
338	+	use super::*;
339	+
340	+	fn pairs(items: &[(&str, &str)]) -> Vec<Pair> {
341	+	items
342	+	.iter()
343	+	.map(\|(k, v)\| ((k).to_owned(), (v).to_owned()))
344	+	.collect()
345	+	}
346	+
347	+	#[test]
348	+	fn parses_queue_songs() {
349	+	let songs = parse_songs(&pairs(&[
350	+	("file", "a/01 - One.flac"),
351	+	("Title", "One"),
352	+	("Artist", "X"),
353	+	("Track", "1/10"),
354	+	("duration", "61.5"),
355	+	("Pos", "0"),
356	+	("Id", "7"),
357	+	("file", "b/two.mp3"),
358	+	("Time", "30"),
359	+	]));
360	+	assert_eq!(songs.len(), 2);
361	+	assert_eq!(songs[0].id, Some(7));
362	+	assert_eq!(songs[0].track(), Some("1"));
363	+	assert_eq!(songs[0].duration, Some(Duration::from_millis(61_500)));
364	+	assert_eq!(songs[1].display_title(), "two");
365	+	assert_eq!(songs[1].duration, Some(Duration::from_secs(30)));
366	+	assert_eq!(songs[1].artist(), None);
367	+	}
368	+
369	+	#[test]
370	+	fn parses_lsinfo_entries() {
371	+	let entries = parse_entries(&pairs(&[
372	+	("directory", "music/rock"),
373	+	("Last-Modified", "2024"),
374	+	("file", "music/song.mp3"),
375	+	("Title", "S"),
376	+	("playlist", "mix"),
377	+	]));
378	+	assert_eq!(entries.len(), 3);
379	+	assert_eq!(entries[0], DirEntry::Directory("music/rock".into()));
380	+	assert_eq!(entries[0].name(), "rock");
381	+	assert!(matches!(&entries[1], DirEntry::Song(s) if s.title() == Some("S")));
382	+	assert_eq!(entries[2], DirEntry::Playlist("mix".into()));
383	+	}
384	+
385	+	#[test]
386	+	fn parses_status() {
387	+	let status = Status::from_pairs(&pairs(&[
388	+	("volume", "-1"),
389	+	("repeat", "1"),
390	+	("single", "oneshot"),
391	+	("playlist", "12"),
392	+	("playlistlength", "3"),
393	+	("state", "pause"),
394	+	("songid", "4"),
395	+	("elapsed", "1.250"),
396	+	("bitrate", "0"),
397	+	]));
398	+	assert_eq!(status.volume, None);
399	+	assert!(status.repeat && !status.random);
400	+	assert_eq!(status.single, OnOff::Oneshot);
401	+	assert_eq!(status.playlist_version, 12);
402	+	assert_eq!(status.state, PlayState::Pause);
403	+	assert_eq!(status.elapsed, Duration::from_millis(1250));
404	+	assert_eq!(status.bitrate, None);
405	+	}
406	+
407	+	#[test]
408	+	fn parses_grouped_albums() {
409	+	let albums = parse_albums(&pairs(&[
410	+	("Date", "2016"),
411	+	("Album", "B"),
412	+	("Date", "2001"),
413	+	("Album", "A"),
414	+	("Album", "C"),
415	+	]));
416	+	let names: Vec<_> = albums.iter().map(\|a\| a.name.as_str()).collect();
417	+	assert_eq!(names, ["A", "C", "B"]);
418	+	}
419	+
420	+	#[test]
421	+	fn parses_subsystems() {
422	+	let subs = parse_subsystems(&pairs(&[("changed", "player"), ("changed", "mixer")]));
423	+	assert_eq!(subs, [Subsystem::Player, Subsystem::Mixer]);
424	+	}
425	+	}

rmptui/1dcac38

Merge pull request #11 from krolyxon/v0.2

rmptui1dcac38

	@@ -0,0 +1,477 @@
1	+	//! Background tasks that own the MPD connections.
2	+	//!
3	+	//! * The idle task blocks on `idle` and reports changed subsystems.
4	+	//! * The command task executes [`Request`]s sent through an [`MpdHandle`]
5	+	//! and reports query results as [`Reply`]s.
6	+	//!
7	+	//! The UI never awaits the server: it sends requests and reacts to events.
8	+
9	+	use std::{path::PathBuf, time::Duration};
10	+
11	+	use tokio::{sync::mpsc, time::sleep};
12	+	use tracing::{debug, warn};
13	+
14	+	use super::{
15	+	commands,
16	+	connection::{Address, Connection},
17	+	error::{MpdError, MpdResult},
18	+	protocol::{Command, Pair},
19	+	types::{
20	+	Album, DirEntry, PlaylistInfo, Song, Status, Subsystem, parse_albums, parse_entries,
21	+	parse_playlists, parse_songs, parse_subsystems, parse_tag_values,
22	+	},
23	+	};
24	+
25	+	/// Data the UI asks for.
26	+	#[derive(Clone, Debug, PartialEq, Eq)]
27	+	pub enum Query {
28	+	/// Status and current song.
29	+	Status,
30	+	/// Queue changes since the given queue version (`0` for everything).
31	+	QueueChanges {
32	+	since: u32,
33	+	},
34	+	Playlists,
35	+	Directory(String),
36	+	PlaylistSongs(String),
37	+	/// All values of a tag, e.g. every `AlbumArtist`.
38	+	TagValues(String),
39	+	/// Albums whose `tag` equals `value`, grouped by date.
40	+	Albums {
41	+	tag: String,
42	+	value: String,
43	+	},
44	+	/// Songs matching a filter expression.
45	+	Find(String),
46	+	/// The server's music directory (only answered on local connections).
47	+	MusicDirectory,
48	+	}
49	+
50	+	/// The answer to a [`Query`].
51	+	#[derive(Clone, Debug)]
52	+	pub enum Reply {
53	+	Status {
54	+	status: Status,
55	+	current: Option<Song>,
56	+	},
57	+	QueueChanges {
58	+	status: Status,
59	+	since: u32,
60	+	changes: Vec<Song>,
61	+	},
62	+	Playlists(Vec<PlaylistInfo>),
63	+	Directory {
64	+	path: String,
65	+	entries: Vec<DirEntry>,
66	+	},
67	+	PlaylistSongs {
68	+	name: String,
69	+	songs: Vec<Song>,
70	+	},
71	+	TagValues {
72	+	tag: String,
73	+	values: Vec<String>,
74	+	},
75	+	Albums {
76	+	tag: String,
77	+	value: String,
78	+	albums: Vec<Album>,
79	+	},
80	+	Find {
81	+	filter: String,
82	+	songs: Vec<Song>,
83	+	},
84	+	MusicDirectory(Option<PathBuf>),
85	+	}
86	+
87	+	#[derive(Clone, Debug, PartialEq, Eq)]
88	+	pub enum Request {
89	+	/// Fire-and-forget commands, executed atomically as one command list.
90	+	Exec(Vec<Command>),
91	+	Query(Query),
92	+	/// Appends songs and starts playing the first one.
93	+	AddAndPlay(Vec<String>),
94	+	/// Appends every song matching a filter and plays the first one.
95	+	FindAddAndPlay(String),
96	+	/// Appends a stored playlist and plays its song at `offset`.
97	+	LoadAndPlay {
98	+	name: String,
99	+	offset: u32,
100	+	},
101	+	}
102	+
103	+	/// Notifications from the background tasks.
104	+	#[derive(Clone, Debug)]
105	+	pub enum MpdEvent {
106	+	Connected { version: String },
107	+	Disconnected(String),
108	+	Changed(Vec<Subsystem>),
109	+	Reply(Reply),
110	+	Error(String),
111	+	}
112	+
113	+	/// Cheap, cloneable sender for requests.
114	+	#[derive(Clone, Debug)]
115	+	pub struct MpdHandle {
116	+	tx: mpsc::UnboundedSender<Request>,
117	+	}
118	+
119	+	impl MpdHandle {
120	+	pub fn request(&self, request: Request) {
121	+	// The worker lives as long as the application, so a closed channel
122	+	// only happens during shutdown.
123	+	let _ = self.tx.send(request);
124	+	}
125	+
126	+	pub fn exec(&self, command: Command) {
127	+	self.request(Request::Exec(vec![command]));
128	+	}
129	+
130	+	pub fn exec_all(&self, commands: Vec<Command>) {
131	+	if !commands.is_empty() {
132	+	self.request(Request::Exec(commands));
133	+	}
134	+	}
135	+
136	+	pub fn query(&self, query: Query) {
137	+	self.request(Request::Query(query));
138	+	}
139	+
140	+	/// A handle whose requests go to `tx`, for tests.
141	+	pub fn from_sender(tx: mpsc::UnboundedSender<Request>) -> Self {
142	+	Self { tx }
143	+	}
144	+	}
145	+
146	+	/// Starts both workers and returns the request handle.
147	+	pub fn spawn<E>(
148	+	address: Address,
149	+	password: Option<String>,
150	+	events: mpsc::UnboundedSender<E>,
151	+	) -> MpdHandle
152	+	where
153	+	E: From<MpdEvent> + Send + 'static,
154	+	{
155	+	let (tx, rx) = mpsc::unbounded_channel();
156	+	let emit = Emitter(events);
157	+	tokio::spawn(idle_task(address.clone(), password.clone(), emit.clone()));
158	+	tokio::spawn(command_task(address, password, rx, emit));
159	+	MpdHandle { tx }
160	+	}
161	+
162	+	struct Emitter<E>(mpsc::UnboundedSender<E>);
163	+
164	+	impl<E> Clone for Emitter<E> {
165	+	fn clone(&self) -> Self {
166	+	Self(self.0.clone())
167	+	}
168	+	}
169	+
170	+	impl<E: From<MpdEvent>> Emitter<E> {
171	+	/// Returns `false` once the application stopped listening.
172	+	fn emit(&self, event: MpdEvent) -> bool {
173	+	self.0.send(event.into()).is_ok()
174	+	}
175	+	}
176	+
177	+	const MAX_BACKOFF: Duration = Duration::from_secs(10);
178	+
179	+	async fn idle_task<E: From<MpdEvent>>(
180	+	address: Address,
181	+	password: Option<String>,
182	+	emit: Emitter<E>,
183	+	) {
184	+	let mut backoff = Duration::from_millis(500);
185	+	let mut reported_down = false;
186	+	loop {
187	+	match Connection::connect(&address, password.as_deref()).await {
188	+	Ok(mut conn) => {
189	+	backoff = Duration::from_millis(500);
190	+	if !emit.emit(MpdEvent::Connected {
191	+	version: conn.version().to_owned(),
192	+	}) {
193	+	return;
194	+	}
195	+	let error = loop {
196	+	match conn.execute(&Command::new("idle")).await {
197	+	Ok(pairs) => {
198	+	if !emit.emit(MpdEvent::Changed(parse_subsystems(&pairs))) {
199	+	return;
200	+	}
201	+	}
202	+	Err(error) => break error,
203	+	}
204	+	};
205	+	warn!("idle connection lost: {error}");
206	+	if !emit.emit(MpdEvent::Disconnected(error.to_string())) {
207	+	return;
208	+	}
209	+	reported_down = true;
210	+	}
211	+	Err(error) => {
212	+	debug!("connecting to {address} failed: {error}");
213	+	if !reported_down {
214	+	reported_down = true;
215	+	if !emit.emit(MpdEvent::Disconnected(format!(
216	+	"cannot connect to {address}: {error}"
217	+	))) {
218	+	return;
219	+	}
220	+	}
221	+	}
222	+	}
223	+	sleep(backoff).await;
224	+	backoff = (backoff * 2).min(MAX_BACKOFF);
225	+	}
226	+	}
227	+
228	+	async fn command_task<E: From<MpdEvent>>(
229	+	address: Address,
230	+	password: Option<String>,
231	+	mut requests: mpsc::UnboundedReceiver<Request>,
232	+	emit: Emitter<E>,
233	+	) {
234	+	let mut conn: Option<Connection> = None;
235	+	while let Some(request) = requests.recv().await {
236	+	// MPD drops connections that stay silent for `connection_timeout`, so a
237	+	// failure on a reused connection is retried once on a fresh one.
238	+	let mut attempts = if conn.is_some() { 2 } else { 1 };
239	+	let result = loop {
240	+	let c = match conn.as_mut() {
241	+	Some(c) => c,
242	+	None => match Connection::connect(&address, password.as_deref()).await {
243	+	Ok(c) => conn.insert(c),
244	+	Err(error) => break Err(error),
245	+	},
246	+	};
247	+	attempts -= 1;
248	+	match execute(c, &request).await {
249	+	Err(error) if error.is_fatal() => {
250	+	conn = None;
251	+	if attempts == 0 {
252	+	break Err(error);
253	+	}
254	+	}
255	+	other => break other,
256	+	}
257	+	};
258	+	let event = match result {
259	+	Ok(Some(reply)) => MpdEvent::Reply(reply),
260	+	Ok(None) => continue,
261	+	Err(error) => {
262	+	warn!("request {request:?} failed: {error}");
263	+	MpdEvent::Error(error.to_string())
264	+	}
265	+	};
266	+	if !emit.emit(event) {
267	+	return;
268	+	}
269	+	}
270	+	}
271	+
272	+	async fn execute(conn: &mut Connection, request: &Request) -> MpdResult<Option<Reply>> {
273	+	match request {
274	+	Request::Exec(commands) => conn.execute_all(commands).await.map(\|()\| None),
275	+	Request::Query(query) => run_query(conn, query).await.map(Some),
276	+	Request::AddAndPlay(uris) => {
277	+	let Some((first, rest)) = uris.split_first() else {
278	+	return Ok(None);
279	+	};
280	+	let id = conn
281	+	.execute(&commands::add_id(first))
282	+	.await?
283	+	.into_iter()
284	+	.find(\|(key, _)\| key == "Id")
285	+	.and_then(\|(_, id)\| id.parse().ok())
286	+	.ok_or_else(\|\| MpdError::Protocol("addid returned no id".into()))?;
287	+	let mut batch: Vec<Command> = rest.iter().map(\|uri\| commands::add(uri)).collect();
288	+	batch.push(commands::play_id(id));
289	+	conn.execute_all(&batch).await.map(\|()\| None)
290	+	}
291	+	Request::FindAddAndPlay(filter) => {
292	+	let start = queue_length(conn).await?;
293	+	conn.execute_all(&[commands::find_add(filter), commands::play_pos(start)])
294	+	.await
295	+	.map(\|()\| None)
296	+	}
297	+	Request::LoadAndPlay { name, offset } => {
298	+	let start = queue_length(conn).await?;
299	+	let entries = conn
300	+	.execute(&Command::new("listplaylist").arg(name))
301	+	.await?;
302	+	conn.execute(&commands::load(name)).await?;
303	+	// `load` silently skips entries the server cannot resolve, so the
304	+	// playlist index is not necessarily the queue offset.
305	+	let added = conn
306	+	.execute(&Command::new("playlistinfo").arg(format!("{start}:")))
307	+	.await?;
308	+	let entries: Vec<&str> = files(&entries).collect();
309	+	let added: Vec<&str> = files(&added).collect();
310	+	let Some(pos) = queued_offset(&entries, &added, *offset as usize) else {
311	+	return Ok(None);
312	+	};
313	+	conn.execute(&commands::play_pos(start + pos as u32))
314	+	.await
315	+	.map(\|_\| None)
316	+	}
317	+	}
318	+	}
319	+
320	+	fn files(pairs: &[Pair]) -> impl Iterator<Item = &str> {
321	+	pairs
322	+	.iter()
323	+	.filter(\|(key, _)\| key == "file")
324	+	.map(\|(_, value)\| value.as_str())
325	+	}
326	+
327	+	/// Where playlist entry `index` ended up among the songs `load` appended,
328	+	/// matching entries in order and skipping the ones that were dropped.
329	+	fn queued_offset(entries: &[&str], added: &[&str], index: usize) -> Option<usize> {
330	+	if entries.len() == added.len() {
331	+	return (index < added.len()).then_some(index);
332	+	}
333	+	let mut pos = 0;
334	+	for (i, entry) in entries.iter().enumerate() {
335	+	let matched = added.get(pos).is_some_and(\|song\| same_song(entry, song));
336	+	if i == index {
337	+	// The entry was skipped: play whatever followed it instead.
338	+	return (pos < added.len()).then_some(pos);
339	+	}
340	+	if matched {
341	+	pos += 1;
342	+	}
343	+	}
344	+	None
345	+	}
346	+
347	+	/// Playlists may store absolute paths, which `load` turns into paths
348	+	/// relative to the music directory.
349	+	fn same_song(entry: &str, queued: &str) -> bool {
350	+	entry == queued
351	+	\|\| entry
352	+	.strip_suffix(queued)
353	+	.is_some_and(\|prefix\| prefix.ends_with('/'))
354	+	}
355	+
356	+	async fn queue_length(conn: &mut Connection) -> MpdResult<u32> {
357	+	let status = conn.execute(&Command::new("status")).await?;
358	+	Ok(Status::from_pairs(&status).playlist_length)
359	+	}
360	+
361	+	async fn run_query(conn: &mut Connection, query: &Query) -> MpdResult<Reply> {
362	+	Ok(match query {
363	+	Query::Status => {
364	+	let responses = conn
365	+	.execute_list(&[Command::new("status"), Command::new("currentsong")])
366	+	.await?;
367	+	let [status, current] = <[_; 2]>::try_from(responses)
368	+	.map_err(\|_\| MpdError::Protocol("short command list response".into()))?;
369	+	let current = (!current.is_empty()).then(\|\| Song::from_pairs(&current));
370	+	Reply::Status {
371	+	status: Status::from_pairs(&status),
372	+	current,
373	+	}
374	+	}
375	+	Query::QueueChanges { since } => {
376	+	let responses = conn
377	+	.execute_list(&[
378	+	Command::new("status"),
379	+	Command::new("plchanges").arg(since.to_string()),
380	+	])
381	+	.await?;
382	+	let [status, changes] = <[_; 2]>::try_from(responses)
383	+	.map_err(\|_\| MpdError::Protocol("short command list response".into()))?;
384	+	Reply::QueueChanges {
385	+	status: Status::from_pairs(&status),
386	+	since: *since,
387	+	changes: parse_songs(&changes),
388	+	}
389	+	}
390	+	Query::Playlists => Reply::Playlists(parse_playlists(
391	+	&conn.execute(&Command::new("listplaylists")).await?,
392	+	)),
393	+	Query::Directory(path) => {
394	+	let entries = parse_entries(&conn.execute(&Command::new("lsinfo").arg(path)).await?);
395	+	Reply::Directory {
396	+	path: path.clone(),
397	+	entries,
398	+	}
399	+	}
400	+	Query::PlaylistSongs(name) => {
401	+	let pairs = conn
402	+	.execute(&Command::new("listplaylistinfo").arg(name))
403	+	.await?;
404	+	Reply::PlaylistSongs {
405	+	name: name.clone(),
406	+	songs: parse_songs(&pairs),
407	+	}
408	+	}
409	+	Query::TagValues(tag) => {
410	+	let pairs = conn.execute(&Command::new("list").arg(tag)).await?;
411	+	Reply::TagValues {
412	+	tag: tag.clone(),
413	+	values: parse_tag_values(&pairs, tag),
414	+	}
415	+	}
416	+	Query::Albums { tag, value } => {
417	+	let pairs = conn
418	+	.execute(
419	+	&Command::new("list")
420	+	.arg("Album")
421	+	.arg(super::protocol::filter_eq(tag, value))
422	+	.arg("group")
423	+	.arg("Date"),
424	+	)
425	+	.await?;
426	+	Reply::Albums {
427	+	tag: tag.clone(),
428	+	value: value.clone(),
429	+	albums: parse_albums(&pairs),
430	+	}
431	+	}
432	+	Query::Find(filter) => {
433	+	let mut songs = parse_songs(&conn.execute(&Command::new("find").arg(filter)).await?);
434	+	songs.sort_by_key(Song::disc_track);
435	+	Reply::Find {
436	+	filter: filter.clone(),
437	+	songs,
438	+	}
439	+	}
440	+	Query::MusicDirectory => {
441	+	let dir = match conn.execute(&Command::new("config")).await {
442	+	Ok(pairs) => pairs
443	+	.into_iter()
444	+	.find(\|(key, _)\| key == "music_directory")
445	+	.map(\|(_, dir)\| PathBuf::from(dir)),
446	+	// `config` is only permitted on local (Unix socket) connections.
447	+	Err(MpdError::Ack(_)) => None,
448	+	Err(error) => return Err(error),
449	+	};
450	+	Reply::MusicDirectory(dir)
451	+	}
452	+	})
453	+	}
454	+
455	+	#[cfg(test)]
456	+	mod tests {
457	+	use super::queued_offset;
458	+
459	+	#[test]
460	+	fn queued_offset_skips_dropped_entries() {
461	+	let entries = ["gone.mp3", "a.mp3", "b.mp3", "missing.mp3", "c.mp3"];
462	+	let added = ["a.mp3", "b.mp3", "c.mp3"];
463	+	assert_eq!(queued_offset(&entries, &added, 1), Some(0));
464	+	assert_eq!(queued_offset(&entries, &added, 2), Some(1));
465	+	assert_eq!(queued_offset(&entries, &added, 4), Some(2));
466	+	// A dropped entry plays the song after it.
467	+	assert_eq!(queued_offset(&entries, &added, 0), Some(0));
468	+	assert_eq!(queued_offset(&entries, &added, 3), Some(2));
469	+	}
470	+
471	+	#[test]
472	+	fn queued_offset_matches_absolute_paths() {
473	+	let entries = ["/music/x.mp3", "gone.mp3", "/music/y.mp3"];
474	+	let added = ["x.mp3", "y.mp3"];
475	+	assert_eq!(queued_offset(&entries, &added, 2), Some(1));
476	+	}
477	+	}

	@@ -0,0 +1,133 @@
1	+	use ratatui::{
2	+	Frame,
3	+	layout::{Constraint, Rect},
4	+	text::Span,
5	+	widgets::Row,
6	+	};
7	+
8	+	use super::{Popup, PopupState, frame_popup};
9	+	use crate::{
10	+	action::{Action, Context},
11	+	config::KeyCombo,
12	+	screens::Ctx,
13	+	ui::list::ListView,
14	+	};
15	+
16	+	enum HelpRow {
17	+	Heading(String),
18	+	Binding {
19	+	keys: String,
20	+	description: &'static str,
21	+	},
22	+	}
23	+
24	+	/// Lists the key bindings, starting with the active screen's.
25	+	pub struct HelpPopup {
26	+	rows: Vec<HelpRow>,
27	+	list: ListView,
28	+	}
29	+
30	+	impl HelpPopup {
31	+	pub fn new(screen: Context, ctx: &Ctx) -> Self {
32	+	let mut order = vec![screen, Context::Navigation, Context::Global];
33	+	let rest: Vec<Context> = Context::ALL
34	+	.iter()
35	+	.copied()
36	+	.filter(\|c\| !order.contains(c) && !is_screen_context(*c))
37	+	.collect();
38	+	order.extend(rest);
39	+	let mut rows = Vec::new();
40	+	for context in order {
41	+	let Some(actions) = ctx.config.keymap.bindings().get(&context) else {
42	+	continue;
43	+	};
44	+	let bound: Vec<_> = actions
45	+	.iter()
46	+	.filter(\|(_, keys)\| !keys.is_empty())
47	+	.collect();
48	+	if bound.is_empty() {
49	+	continue;
50	+	}
51	+	if !rows.is_empty() {
52	+	rows.push(HelpRow::Heading(String::new()));
53	+	}
54	+	rows.push(HelpRow::Heading(heading(context)));
55	+	for (action, keys) in bound {
56	+	rows.push(HelpRow::Binding {
57	+	keys: keys
58	+	.iter()
59	+	.map(ToString::to_string)
60	+	.collect::<Vec<_>>()
61	+	.join(", "),
62	+	description: action.description(),
63	+	});
64	+	}
65	+	}
66	+	Self {
67	+	rows,
68	+	list: ListView::default(),
69	+	}
70	+	}
71	+	}
72	+
73	+	fn is_screen_context(context: Context) -> bool {
74	+	!matches!(
75	+	context,
76	+	Context::Global \| Context::Navigation \| Context::Popup \| Context::Input
77	+	)
78	+	}
79	+
80	+	fn heading(context: Context) -> String {
81	+	let name = context.name().replace('_', " ");
82	+	let mut chars = name.chars();
83	+	chars
84	+	.next()
85	+	.map(\|c\| c.to_uppercase().chain(chars).collect())
86	+	.unwrap_or_default()
87	+	}
88	+
89	+	impl Popup for HelpPopup {
90	+	fn draw(&mut self, frame: &mut Frame, area: Rect, ctx: &Ctx) {
91	+	let inner = frame_popup(
92	+	frame,
93	+	area,
94	+	70,
95	+	area.height.saturating_sub(4),
96	+	"Key bindings",
97	+	ctx,
98	+	);
99	+	let theme = ctx.theme();
100	+	let rows = &self.rows;
101	+	self.list.render(
102	+	frame,
103	+	inner,
104	+	None,
105	+	&[Constraint::Length(24), Constraint::Fill(1)],
106	+	rows.len(),
107	+	true,
108	+	theme,
109	+	\|i\| match &rows[i] {
110	+	HelpRow::Heading(title) => Row::new([Span::styled(title.clone(), theme.header())]),
111	+	HelpRow::Binding { keys, description } => Row::new([
112	+	Span::styled(format!(" {keys}"), theme.text()),
113	+	Span::styled(*description, theme.dim()),
114	+	]),
115	+	},
116	+	);
117	+	}
118	+
119	+	fn handle_key(&mut self, key: KeyCombo, ctx: &mut Ctx) -> PopupState {
120	+	let keymap = &ctx.config.keymap;
121	+	match keymap.resolve(&[Context::Popup, Context::Navigation], key) {
122	+	Some(Action::Close) => PopupState::Closed,
123	+	Some(action) => {
124	+	self.list.navigate(action, self.rows.len());
125	+	PopupState::Open
126	+	}
127	+	None if keymap.resolve(&[Context::Global], key) == Some(Action::Help) => {
128	+	PopupState::Closed
129	+	}
130	+	None => PopupState::Open,
131	+	}
132	+	}
133	+	}

	@@ -0,0 +1,99 @@
1	+	use ratatui::{Frame, layout::Rect};
2	+
3	+	use super::{Popup, PopupState, frame_popup};
4	+	use crate::{
5	+	action::{Context, ScreenId},
6	+	config::KeyCombo,
7	+	mpd::{Selection, commands},
8	+	screens::{Ctx, Effect, ScreenMessage},
9	+	tags::TagField,
10	+	ui::input::{InputEvent, LineInput},
11	+	};
12	+
13	+	/// What the entered text is for.
14	+	#[derive(Clone, Debug)]
15	+	pub enum InputPurpose {
16	+	NewPlaylist(Selection),
17	+	RenamePlaylist(String),
18	+	SaveQueue,
19	+	TagValue(TagField),
20	+	FileName,
21	+	}
22	+
23	+	pub struct InputPopup {
24	+	title: String,
25	+	input: LineInput,
26	+	purpose: InputPurpose,
27	+	}
28	+
29	+	impl InputPopup {
30	+	pub fn new(title: impl Into<String>, initial: &str, purpose: InputPurpose) -> Self {
31	+	Self {
32	+	title: title.into(),
33	+	input: LineInput::new(initial),
34	+	purpose,
35	+	}
36	+	}
37	+
38	+	fn submit(&self, ctx: &mut Ctx) -> PopupState {
39	+	let value = self.input.text().trim().to_owned();
40	+	if value.is_empty() && !matches!(self.purpose, InputPurpose::TagValue(_)) {
41	+	return PopupState::Open;
42	+	}
43	+	match &self.purpose {
44	+	InputPurpose::NewPlaylist(selection) => {
45	+	if ctx.mpd.playlists.iter().any(\|p\| p.name == value) {
46	+	ctx.notify(format!("Added to existing playlist “{value}”"));
47	+	} else {
48	+	ctx.notify(format!("Created playlist “{value}”"));
49	+	}
50	+	ctx.client.exec_all(selection.add_to_playlist(&value));
51	+	}
52	+	InputPurpose::RenamePlaylist(from) => {
53	+	if *from != value {
54	+	ctx.client.exec(commands::rename(from, &value));
55	+	}
56	+	}
57	+	InputPurpose::SaveQueue => {
58	+	ctx.client.exec(commands::save(&value));
59	+	ctx.notify(format!("Saved the queue as “{value}”"));
60	+	}
61	+	InputPurpose::FileName => ctx.effects.push(Effect::Message(
62	+	ScreenId::TagEditor,
63	+	ScreenMessage::FileName(value),
64	+	)),
65	+	InputPurpose::TagValue(field) => ctx.effects.push(Effect::Message(
66	+	ScreenId::TagEditor,
67	+	ScreenMessage::TagValue {
68	+	field: *field,
69	+	value,
70	+	},
71	+	)),
72	+	}
73	+	PopupState::Closed
74	+	}
75	+	}
76	+
77	+	impl Popup for InputPopup {
78	+	fn draw(&mut self, frame: &mut Frame, area: Rect, ctx: &Ctx) {
79	+	let width = (area.width * 3 / 5).max(40);
80	+	let inner = frame_popup(frame, area, width, 3, &self.title, ctx);
81	+	self.input.render(frame, inner, "", ctx.theme());
82	+	}
83	+
84	+	fn handle_key(&mut self, key: KeyCombo, ctx: &mut Ctx) -> PopupState {
85	+	match ctx.config.keymap.resolve(&[Context::Input], key) {
86	+	Some(action) => match self.input.apply(action) {
87	+	InputEvent::Submit => self.submit(ctx),
88	+	InputEvent::Cancel => PopupState::Closed,
89	+	_ => PopupState::Open,
90	+	},
91	+	None => {
92	+	if let Some(ch) = key.as_text() {
93	+	self.input.insert(ch);
94	+	}
95	+	PopupState::Open
96	+	}
97	+	}
98	+	}
99	+	}

	@@ -0,0 +1,60 @@
1	+	//! Modal popups drawn above the screens. The topmost popup receives all
2	+	//! keys until it closes.
3	+
4	+	mod add_to_playlist;
5	+	mod confirm;
6	+	mod help;
7	+	mod input;
8	+
9	+	use ratatui::{
10	+	Frame,
11	+	layout::{Constraint, Flex, Layout, Rect},
12	+	text::Line,
13	+	widgets::{Block, BorderType, Clear},
14	+	};
15	+
16	+	pub use add_to_playlist::AddToPlaylistPopup;
17	+	pub use confirm::ConfirmPopup;
18	+	pub use help::HelpPopup;
19	+	pub use input::{InputPopup, InputPurpose};
20	+
21	+	use crate::{config::KeyCombo, screens::Ctx};
22	+
23	+	#[derive(Clone, Copy, Debug, PartialEq, Eq)]
24	+	pub enum PopupState {
25	+	Open,
26	+	Closed,
27	+	}
28	+
29	+	pub trait Popup {
30	+	/// Draws the popup; `area` is the whole terminal.
31	+	fn draw(&mut self, frame: &mut Frame, area: Rect, ctx: &Ctx);
32	+
33	+	fn handle_key(&mut self, key: KeyCombo, ctx: &mut Ctx) -> PopupState;
34	+	}
35	+
36	+	/// Clears a centered rectangle and draws a titled frame around it,
37	+	/// returning the inner area.
38	+	fn frame_popup(
39	+	frame: &mut Frame,
40	+	area: Rect,
41	+	width: u16,
42	+	height: u16,
43	+	title: &str,
44	+	ctx: &Ctx,
45	+	) -> Rect {
46	+	let [area] = Layout::horizontal([Constraint::Length(width.min(area.width))])
47	+	.flex(Flex::Center)
48	+	.areas(area);
49	+	let [area] = Layout::vertical([Constraint::Length(height.min(area.height))])
50	+	.flex(Flex::Center)
51	+	.areas(area);
52	+	let block = Block::bordered()
53	+	.border_type(BorderType::Plain)
54	+	.border_style(ctx.theme().border())
55	+	.title(Line::from(format!(" {title} ")).style(ctx.theme().header()));
56	+	let inner = block.inner(area);
57	+	frame.render_widget(Clear, area);
58	+	frame.render_widget(block, area);
59	+	inner
60	+	}

	@@ -0,0 +1,138 @@
1	+	//! Screen 7: lyrics of the current song. Also drawn as a pane on the queue.
2	+
3	+	use crossterm::event::{MouseEvent, MouseEventKind};
4	+	use ratatui::{
5	+	Frame,
6	+	layout::{Alignment, Constraint, Layout, Rect},
7	+	text::{Line, Span},
8	+	widgets::Paragraph,
9	+	};
10	+
11	+	use super::{Ctx, Effect, Screen};
12	+	use crate::{
13	+	action::Action,
14	+	lyrics::{Lyrics, LyricsStatus},
15	+	ui,
16	+	};
17	+
18	+	#[derive(Debug, Default)]
19	+	pub struct LyricsScreen {
20	+	/// Scroll offset for plain (unsynced) lyrics.
21	+	scroll: usize,
22	+	height: usize,
23	+	file: Option<String>,
24	+	}
25	+
26	+	/// Draws the lyrics pane next to the queue (no manual scrolling).
27	+	pub fn draw_lyrics(frame: &mut Frame, area: Rect, ctx: &Ctx) {
28	+	let theme = ctx.theme();
29	+	let [header, line, body] = Layout::vertical([
30	+	Constraint::Length(1),
31	+	Constraint::Length(1),
32	+	Constraint::Fill(1),
33	+	])
34	+	.areas(area);
35	+	frame.render_widget(Line::styled("Lyrics", theme.header()), header);
36	+	ui::draw_hline(frame, line, theme);
37	+	render(frame, body, ctx, 0);
38	+	}
39	+
40	+	fn render(frame: &mut Frame, inner: Rect, ctx: &Ctx, scroll: usize) -> usize {
41	+	let theme = ctx.theme();
42	+	let height = usize::from(inner.height);
43	+
44	+	let lyrics = match (&ctx.mpd.current, &ctx.lyrics.status) {
45	+	(None, _) => {
46	+	ui::draw_placeholder(frame, inner, &["Nothing is playing"], theme);
47	+	return height;
48	+	}
49	+	(Some(_), LyricsStatus::Found(lyrics)) => lyrics,
50	+	(Some(_), LyricsStatus::Idle \| LyricsStatus::Loading) => {
51	+	ui::draw_placeholder(frame, inner, &["Looking for lyrics…"], theme);
52	+	return height;
53	+	}
54	+	(Some(_), LyricsStatus::NotFound) => {
55	+	ui::draw_placeholder(frame, inner, &["No lyrics found"], theme);
56	+	return height;
57	+	}
58	+	(Some(_), LyricsStatus::Failed(error)) => {
59	+	ui::draw_placeholder(frame, inner, &["Could not fetch lyrics", error], theme);
60	+	return height;
61	+	}
62	+	};
63	+
64	+	let current = lyrics.current_line(ctx.mpd.elapsed());
65	+	let top = match (lyrics, current) {
66	+	// Keep the current line in the middle.
67	+	(Lyrics::Synced(_), Some(line)) => line.saturating_sub(height / 2),
68	+	(Lyrics::Synced(_), None) => 0,
69	+	(Lyrics::Plain(_), _) => scroll.min(lyrics.len().saturating_sub(1)),
70	+	};
71	+	let lines: Vec<Line> = (top..lyrics.len().min(top + height))
72	+	.map(\|i\| {
73	+	let text = lyrics.line(i);
74	+	let style = match (lyrics, current) {
75	+	(Lyrics::Synced(_), Some(c)) if i == c => theme.header(),
76	+	(Lyrics::Synced(_), Some(c)) if i < c => theme.dim(),
77	+	(Lyrics::Synced(_), None) => theme.dim(),
78	+	_ => theme.text(),
79	+	};
80	+	Line::from(Span::styled(text.to_owned(), style))
81	+	})
82	+	.collect();
83	+	frame.render_widget(Paragraph::new(lines).alignment(Alignment::Center), inner);
84	+	height
85	+	}
86	+
87	+	impl Screen for LyricsScreen {
88	+	fn title(&self, ctx: &Ctx) -> Line<'static> {
89	+	match &ctx.mpd.current {
90	+	Some(song) => Line::from(format!("Lyrics: {}", ui::song_label(song))),
91	+	None => Line::from("Lyrics"),
92	+	}
93	+	}
94	+
95	+	fn draw(&mut self, frame: &mut Frame, area: Rect, ctx: &Ctx) {
96	+	// Plain lyrics start from the top for every song.
97	+	let file = ctx.mpd.current.as_ref().map(\|s\| s.file.clone());
98	+	if file != self.file {
99	+	self.file = file;
100	+	self.scroll = 0;
101	+	}
102	+	self.height = render(frame, area, ctx, self.scroll);
103	+	}
104	+
105	+	fn handle_action(&mut self, action: Action, ctx: &mut Ctx) -> bool {
106	+	let len = ctx.lyrics.lyrics().map_or(0, Lyrics::len);
107	+	let page = self.height.max(1);
108	+	let max = len.saturating_sub(1);
109	+	self.scroll = match action {
110	+	Action::Up => self.scroll.saturating_sub(1),
111	+	Action::Down => (self.scroll + 1).min(max),
112	+	Action::PageUp => self.scroll.saturating_sub(page),
113	+	Action::PageDown => (self.scroll + page).min(max),
114	+	Action::HalfPageUp => self.scroll.saturating_sub(page / 2),
115	+	Action::HalfPageDown => (self.scroll + page / 2).min(max),
116	+	Action::Top => 0,
117	+	Action::Bottom => max,
118	+	Action::ReloadLyrics => {
119	+	ctx.effects.push(Effect::ReloadLyrics);
120	+	ctx.notify("Fetching lyrics again…");
121	+	return true;
122	+	}
123	+	_ => return false,
124	+	};
125	+	true
126	+	}
127	+
128	+	fn on_mouse(&mut self, event: MouseEvent, ctx: &mut Ctx) {
129	+	let action = match event.kind {
130	+	MouseEventKind::ScrollDown => Action::Down,
131	+	MouseEventKind::ScrollUp => Action::Up,
132	+	_ => return,
133	+	};
134	+	for _ in 0..3 {
135	+	self.handle_action(action, ctx);
136	+	}
137	+	}
138	+	}

	@@ -1,62 +0,0 @@
1	−	use crate::ui;
2	−	use crossterm::event::{DisableMouseCapture, EnableMouseCapture};
3	−	use crossterm::terminal::{self, *};
4	−	use std::io;
5	−	use std::panic;
6	−
7	−	use crate::{app::App, AppResult};
8	−
9	−	pub type CrosstermTerminal = ratatui::Terminal<ratatui::backend::CrosstermBackend<std::io::Stderr>>;
10	−
11	−	#[derive(Debug)]
12	−	pub struct Tui {
13	−	terminal: CrosstermTerminal,
14	−	}
15	−
16	−	impl Tui {
17	−	pub fn new(terminal: CrosstermTerminal) -> Self {
18	−	Self { terminal }
19	−	}
20	−
21	−	pub fn init(&mut self) -> AppResult<()> {
22	−	terminal::enable_raw_mode()?;
23	−	crossterm::execute!(io::stderr(), EnterAlternateScreen, EnableMouseCapture)?;
24	−
25	−	let panic_hook = panic::take_hook();
26	−	panic::set_hook(Box::new(move \|panic\| {
27	−	if let Err(error) = Self::reset() {
28	−	eprintln!("failed to reset the terminal: {error}");
29	−	}
30	−	panic_hook(panic);
31	−	}));
32	−	Ok(())
33	−	}
34	−
35	−	/// [`Draw`] the terminal interface by [`rendering`] the widgets.
36	−	///
37	−	/// [`Draw`]: ratatui::Terminal::draw
38	−	/// [`rendering`]: crate::ui::render
39	−	pub fn draw(&mut self, app: &mut App) -> AppResult<()> {
40	−	self.terminal.draw(\|frame\| ui::render(app, frame))?;
41	−	Ok(())
42	−	}
43	−
44	−	/// Resets the terminal interface.
45	−	///
46	−	/// This function is also used for the panic hook to revert
47	−	/// the terminal properties if unexpected errors occur.
48	−	fn reset() -> AppResult<()> {
49	−	terminal::disable_raw_mode()?;
50	−	crossterm::execute!(io::stderr(), LeaveAlternateScreen, DisableMouseCapture)?;
51	−	Ok(())
52	−	}
53	−
54	−	/// Exits the terminal interface.
55	−	///
56	−	/// It disables the raw mode and reverts back the terminal properties.
57	−	pub fn exit(&mut self) -> AppResult<()> {
58	−	Self::reset()?;
59	−	self.terminal.show_cursor()?;
60	−	Ok(())
61	−	}
62	−	}

	@@ -1,27 +0,0 @@
1	−	use std::ffi::OsStr;
2	−	use std::path::Path;
3	−
4	−	/// Checks if a file has a given extension
5	−	// https://stackoverflow.com/questions/72392835/check-if-a-file-is-of-a-given-type
6	−	pub trait FileExtension {
7	−	fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool;
8	−	}
9	−
10	−	impl<P: AsRef<Path>> FileExtension for P {
11	−	fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool {
12	−	if let Some(extension) = self.as_ref().extension().and_then(OsStr::to_str) {
13	−	return extensions
14	−	.iter()
15	−	.any(\|x\| x.as_ref().eq_ignore_ascii_case(extension));
16	−	}
17	−
18	−	false
19	−	}
20	−	}
21	−
22	−	pub fn is_audio_file(path: &str) -> bool {
23	−	Path::new(path).has_extension(&[
24	−	"mp3", "ogg", "flac", "m4a", "wav", "aac", "opus", "ape", "wma", "mpc", "aiff", "dff",
25	−	"mp2", "mka",
26	−	])
27	−	}