Commit 3de1a21

rmptui3de1a21

Start v0.2 rewrite: async MPD client and new config system

Remove the v0.1 sources and lay the foundation for the rewrite:

- mpd: pure protocol encoding/parsing, TCP and Unix socket connections,
  typed models, and background idle/command workers so the UI never
  awaits the server.
- config: documented default.toml as the single source of truth, merged
  table-by-table with the user file; typed actions and per-context
  keymaps with conflict validation; theme colors; MPD_HOST/MPD_PORT.

Author: krolyxon
Date: 2026-10-17 16:40 +0530
Parent: c847cda
Commit: 3de1a21abf90c18696f85290a2ba278e0b9818ab

+4787 −3508

29 files changed

Browse files Patch

−Context 3+

M Cargo.lock +1679 −48
M Cargo.toml +25 −15
A src/action.rs +317 −0
D src/app.rs +0 −501
D src/browser.rs +0 −164
D src/config.rs +0 −669
A src/config/default.toml +199 −0
A src/config/keys.rs +305 −0
A src/config/mod.rs +515 −0
A src/config/theme.rs +91 −0
D src/connection.rs +0 −741
D src/event_handler/handler.rs +0 −473
D src/event_handler/mod.rs +0 −1
M src/lib.rs +3 −14
D src/list.rs +0 −30
D src/logging.rs +0 −86
M src/main.rs +1 −188
A src/mpd/commands.rs +162 −0
A src/mpd/connection.rs +156 −0
A src/mpd/error.rs +42 −0
A src/mpd/mod.rs +14 −0
A src/mpd/protocol.rs +227 −0
A src/mpd/types.rs +425 −0
A src/mpd/worker.rs +403 −0
D src/tui.rs +0 −62
D src/ui.rs +0 −489
A src/util.rs +59 −0
D src/utils.rs +0 −27
A tests/mpd_client.rs +164 −0

M Cargo.lock View

M Cargo.toml View

A src/action.rs View

D src/app.rs View

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/theme.rs View

D src/connection.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

D src/logging.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/types.rs View

A src/mpd/worker.rs View

D src/tui.rs View

D src/ui.rs View

A src/util.rs View

D src/utils.rs View

A tests/mpd_client.rs View

	@@ -0,0 +1,199 @@
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, wheel to scroll, click the progress
33	+	# bar to seek, click a tab to switch).
34	+	mouse = true
35	+	# Show the lyrics pane next to the queue on startup (toggle with `L`).
36	+	lyrics_pane = false
37	+	# Width of the lyrics pane in percent of the screen.
38	+	lyrics_pane_width = 40
39	+	# Seconds a status message stays visible.
40	+	message_timeout = 4
41	+	# Queue columns. `field` is one of artist, album_artist, title, album, track,
42	+	# disc, date, genre, duration or file; `width` is a relative weight.
43	+	queue_columns = [
44	+	{ field = "artist", width = 25 },
45	+	{ field = "track", width = 5 },
46	+	{ field = "title", width = 35 },
47	+	{ field = "album", width = 30 },
48	+	{ field = "duration", width = 7 },
49	+	]
50	+
51	+	[theme]
52	+	# Colors are names (black, red, green, yellow, blue, magenta, cyan, gray,
53	+	# darkgray, lightred, …, white, reset), 256-color indices ("208") or hex
54	+	# values ("#c694ff").
55	+	accent = "magenta"
56	+	text = "reset"
57	+	dim = "darkgray"
58	+	selection_fg = "black"
59	+	selection_bg = "magenta"
60	+	playing = "green"
61	+	marked = "yellow"
62	+	directory = "blue"
63	+	border = "darkgray"
64	+	error = "red"
65	+	# Visualizer bar gradient, from the bottom of the screen to the top.
66	+	visualizer = ["blue", "cyan", "green", "yellow", "red"]
67	+
68	+	[lyrics]
69	+	# Look up lyrics on https://lrclib.net when no local `.lrc` file exists.
70	+	online = true
71	+	# Keep fetched lyrics in $XDG_CACHE_HOME/rmptui/lyrics (~/.cache by default).
72	+	cache = true
73	+	lrclib_url = "https://lrclib.net"
74	+
75	+	[visualizer]
76	+	# Path of an MPD fifo output. Add this to mpd.conf:
77	+	#
78	+	# audio_output {
79	+	# type "fifo"
80	+	# name "Visualizer feed"
81	+	# path "/tmp/mpd.fifo"
82	+	# format "44100:16:2"
83	+	# }
84	+	fifo = "/tmp/mpd.fifo"
85	+	# Must match the `format` of the fifo output.
86	+	sample_rate = 44100
87	+	channels = 2
88	+	framerate = 60
89	+	bar_width = 2
90	+	bar_gap = 1
91	+	min_frequency = 40
92	+	max_frequency = 16000
93	+	# How fast bars fall, in screen heights per second.
94	+	falloff = 1.5
95	+
96	+	# Key bindings
97	+	#
98	+	# Each table is a context. Lookups start with the context of the focused
99	+	# popup or screen, then `navigation`, then `global`, so a key bound in a
100	+	# screen context shadows the same key in `global` on that screen.
101	+	#
102	+	# Each action takes a list of keys. A key is a character or one of Enter,
103	+	# Esc, Tab, Backspace, Delete, Insert, Space, Up, Down, Left, Right, Home,
104	+	# End, PageUp, PageDown and F1–F24, optionally prefixed by Ctrl+, Alt+ or
105	+	# Shift+ (e.g. "Ctrl+x", "Alt+Enter", "Shift+Tab"). Set an action to [] to
106	+	# unbind it; a key may only be used once per context.
107	+
108	+	[keys.global]
109	+	quit = ["q", "Ctrl+c"]
110	+	help = ["?", "F1"]
111	+	toggle_pause = ["p"]
112	+	pause = ["s"]
113	+	stop = ["x"]
114	+	next_track = [">"]
115	+	previous_track = ["<"]
116	+	seek_forward = ["f"]
117	+	seek_backward = ["b"]
118	+	volume_up = ["+", "="]
119	+	volume_down = ["-"]
120	+	toggle_mute = ["m"]
121	+	toggle_repeat = ["r"]
122	+	toggle_random = ["z"]
123	+	toggle_single = ["y"]
124	+	toggle_consume = ["R"]
125	+	update_database = ["U"]
126	+	next_screen = ["Tab"]
127	+	previous_screen = ["Shift+Tab"]
128	+	screen_queue = ["1"]
129	+	screen_browser = ["2"]
130	+	screen_playlists = ["3"]
131	+	screen_library = ["4"]
132	+	screen_tag_editor = ["5"]
133	+	screen_visualizer = ["6"]
134	+	screen_lyrics = ["7"]
135	+
136	+	[keys.navigation]
137	+	up = ["k", "Up"]
138	+	down = ["j", "Down"]
139	+	top = ["g", "Home"]
140	+	bottom = ["G", "End"]
141	+	page_up = ["PageUp"]
142	+	page_down = ["PageDown"]
143	+	half_page_up = ["Ctrl+u"]
144	+	half_page_down = ["Ctrl+d"]
145	+	left = ["h", "Left", "Backspace"]
146	+	right = ["l", "Right"]
147	+	activate = ["Enter"]
148	+	toggle_mark = ["v", "Insert"]
149	+	clear_marks = ["V"]
150	+	search = ["/"]
151	+	search_next = ["n"]
152	+	search_previous = ["N"]
153	+	add_to_queue = ["Space"]
154	+	add_to_playlist = ["a"]
155	+
156	+	[keys.queue]
157	+	delete = ["d", "Delete"]
158	+	move_item_up = ["K"]
159	+	move_item_down = ["J"]
160	+	clear_queue = ["c"]
161	+	shuffle_queue = ["Z"]
162	+	save_queue = ["S"]
163	+	jump_to_current = ["o"]
164	+	toggle_lyrics_pane = ["L"]
165	+
166	+	[keys.browser]
167	+
168	+	[keys.playlists]
169	+	delete = ["d", "Delete"]
170	+	move_item_up = ["K"]
171	+	move_item_down = ["J"]
172	+	delete_playlist = ["D"]
173	+	rename_playlist = ["R"]
174	+
175	+	[keys.library]
176	+	toggle_artist_tag = ["t"]
177	+
178	+	[keys.tag_editor]
179	+	save_tags = ["w"]
180	+	revert_tags = ["u"]
181	+
182	+	[keys.visualizer]
183	+
184	+	[keys.lyrics]
185	+	reload_lyrics = ["F5"]
186	+
187	+	[keys.popup]
188	+	close = ["q", "Esc"]
189	+
190	+	[keys.input]
191	+	submit = ["Enter"]
192	+	cancel = ["Esc"]
193	+	backspace = ["Backspace"]
194	+	delete_char = ["Delete"]
195	+	delete_word = ["Ctrl+w"]
196	+	cursor_left = ["Left"]
197	+	cursor_right = ["Right"]
198	+	cursor_home = ["Home", "Ctrl+a"]
199	+	cursor_end = ["End", "Ctrl+e"]

	@@ -0,0 +1,91 @@
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 accent: Color,
12	+	#[serde(deserialize_with = "color")]
13	+	pub text: Color,
14	+	#[serde(deserialize_with = "color")]
15	+	pub dim: 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 border: Color,
28	+	#[serde(deserialize_with = "color")]
29	+	pub error: Color,
30	+	#[serde(deserialize_with = "colors")]
31	+	pub visualizer: Vec<Color>,
32	+	}
33	+
34	+	impl Theme {
35	+	pub fn text(&self) -> Style {
36	+	Style::new().fg(self.text)
37	+	}
38	+
39	+	pub fn dim(&self) -> Style {
40	+	Style::new().fg(self.dim)
41	+	}
42	+
43	+	pub fn accent(&self) -> Style {
44	+	Style::new().fg(self.accent)
45	+	}
46	+
47	+	pub fn border(&self) -> Style {
48	+	Style::new().fg(self.border)
49	+	}
50	+
51	+	/// The highlighted row of a focused list.
52	+	pub fn selection(&self) -> Style {
53	+	Style::new().fg(self.selection_fg).bg(self.selection_bg)
54	+	}
55	+
56	+	/// The highlighted row of a list without focus.
57	+	pub fn selection_inactive(&self) -> Style {
58	+	Style::new().add_modifier(Modifier::REVERSED)
59	+	}
60	+
61	+	pub fn playing(&self) -> Style {
62	+	Style::new().fg(self.playing).add_modifier(Modifier::BOLD)
63	+	}
64	+
65	+	pub fn marked(&self) -> Style {
66	+	Style::new().fg(self.marked)
67	+	}
68	+
69	+	pub fn directory(&self) -> Style {
70	+	Style::new().fg(self.directory).add_modifier(Modifier::BOLD)
71	+	}
72	+
73	+	pub fn error(&self) -> Style {
74	+	Style::new().fg(self.error)
75	+	}
76	+	}
77	+
78	+	fn parse_color<E: de::Error>(value: &str) -> Result<Color, E> {
79	+	Color::from_str(value).map_err(\|_\| E::custom(format!("invalid color `{value}`")))
80	+	}
81	+
82	+	fn color<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Color, D::Error> {
83	+	parse_color(&String::deserialize(deserializer)?)
84	+	}
85	+
86	+	fn colors<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<Color>, D::Error> {
87	+	Vec::<String>::deserialize(deserializer)?
88	+	.iter()
89	+	.map(\|value\| parse_color(value))
90	+	.collect()
91	+	}

		@@ -1,188 +1 @@
1		−	use std::{env, io, net::Ipv6Addr, str::FromStr, time::Duration};
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,
12		−	};
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
30		−	}
31		−
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		−	}
128		−	}
129		−	Ok(())
130		−	}
131		−	.await;
132		−
133		−	watcher.abort();
134		−	let exit_result = tui.exit();
135		−	run_result?;
136		−	exit_result?;
137		−	Ok(())
138		−	}
139		−
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		−	}
154		−
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}")
173		−	}
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");
187		−	}
188		−	}
	1	+	fn main() {}

	@@ -0,0 +1,162 @@
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_id(id: u32) -> Command {
98	+	Command::new("deleteid").arg(id.to_string())
99	+	}
100	+
101	+	pub fn move_id(id: u32, to: u32) -> Command {
102	+	Command::new("moveid")
103	+	.arg(id.to_string())
104	+	.arg(to.to_string())
105	+	}
106	+
107	+	pub fn find_add(filter: &str) -> Command {
108	+	Command::new("findadd").arg(filter)
109	+	}
110	+
111	+	pub fn load(playlist: &str) -> Command {
112	+	Command::new("load").arg(playlist)
113	+	}
114	+
115	+	pub fn save(playlist: &str) -> Command {
116	+	Command::new("save").arg(playlist)
117	+	}
118	+
119	+	pub fn rename(from: &str, to: &str) -> Command {
120	+	Command::new("rename").arg(from).arg(to)
121	+	}
122	+
123	+	pub fn remove_playlist(playlist: &str) -> Command {
124	+	Command::new("rm").arg(playlist)
125	+	}
126	+
127	+	/// Adds a song or directory to a stored playlist, creating it if needed.
128	+	pub fn playlist_add(playlist: &str, uri: &str) -> Command {
129	+	Command::new("playlistadd").arg(playlist).arg(uri)
130	+	}
131	+
132	+	/// Adds every song matching `filter` to a stored playlist.
133	+	pub fn playlist_add_filter(playlist: &str, filter: &str) -> Command {
134	+	Command::new("searchaddpl").arg(playlist).arg(filter)
135	+	}
136	+
137	+	pub fn playlist_delete(playlist: &str, pos: u32) -> Command {
138	+	Command::new("playlistdelete")
139	+	.arg(playlist)
140	+	.arg(pos.to_string())
141	+	}
142	+
143	+	pub fn playlist_move(playlist: &str, from: u32, to: u32) -> Command {
144	+	Command::new("playlistmove")
145	+	.arg(playlist)
146	+	.arg(from.to_string())
147	+	.arg(to.to_string())
148	+	}
149	+
150	+	#[cfg(test)]
151	+	mod tests {
152	+	use super::*;
153	+
154	+	#[test]
155	+	fn formats_relative_arguments() {
156	+	assert_eq!(seek_relative(5).as_str(), r#"seekcur "+5""#);
157	+	assert_eq!(seek_relative(-5).as_str(), r#"seekcur "-5""#);
158	+	assert_eq!(change_volume(-2).as_str(), r#"volume "-2""#);
159	+	assert_eq!(update(None).as_str(), "update");
160	+	assert_eq!(set_volume(140).as_str(), r#"setvol "100""#);
161	+	}
162	+	}

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

		@@ -1,28 +1,38 @@
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.85"
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	+	lofty = "0.25.4"
	20	+	nucleo-matcher = "0.3.1"
	21	+	ratatui = { version = "0.30.2", default-features = false, features = ["crossterm_0_29"] }
	22	+	realfft = "3.5.0"
	23	+	reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] }
19	24		serde = { version = "1.0.229", features = ["derive"] }
	25	+	serde_json = "1.0.154"
	26	+	thiserror = "2.0.21"
	27	+	tokio = { version = "1.53.3", features = ["macros", "rt-multi-thread", "net", "io-util", "time", "sync", "fs"] }
20	28		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		−	] }
	29	+	tracing = "0.1.44"
	30	+	tracing-subscriber = { version = "0.3.23", default-features = false, features = ["fmt", "std", "env-filter"] }
	31	+	unicode-width = "0.2.2"
	32	+
	33	+	[dev-dependencies]
	34	+	tokio = { version = "1.53.3", features = ["test-util"] }
	35	+
	36	+	[profile.release]
	37	+	lto = "thin"
	38	+	codegen-units = 1

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

	@@ -1,501 +0,0 @@
1	−	use std::time::Duration;
2	−
3	−	use crate::{
4	−	browser::{BrowserEntry, FileBrowser},
5	−	config::Config,
6	−	connection::{Connection, MpdSnapshot, Song},
7	−	list::ContentList,
8	−	ui::InputMode,
9	−	utils::is_audio_file,
10	−	AppResult,
11	−	};
12	−	use ratatui::widgets::{ListState, TableState};
13	−
14	−	#[derive(Debug)]
15	−	pub struct App {
16	−	pub running: bool,
17	−	pub conn: Connection,
18	−	pub config: Config,
19	−	pub browser: FileBrowser,
20	−	pub queue_list: ContentList<Song>,
21	−	pub pl_list: ContentList<String>,
22	−	pub playlist_focus: PlaylistFocus,
23	−	pub playlist_song_index: usize,
24	−	pub selected_tab: SelectedTab,
25	−	pub inputmode: InputMode,
26	−	pub search_input: String,
27	−	pub search_cursor_pos: usize,
28	−	pub browser_search_results: Vec<usize>,
29	−	pub browser_search_index: usize,
30	−	pub pl_newname_input: String,
31	−	pub pl_cursor_pos: usize,
32	−	pub pl_new_pl_input: String,
33	−	pub pl_new_pl_cursor_pos: usize,
34	−	pub pl_new_pl_songs_buffer: Vec<Song>,
35	−	pub playlist_popup: bool,
36	−	pub append_list: ContentList<String>,
37	−	pub should_update_song_list: bool,
38	−	pub queue_state: TableState,
39	−	pub browser_state: TableState,
40	−	pub playlists_state: ListState,
41	−	pub playlist_songs_state: TableState,
42	−	pub playlist_contents: Vec<Song>,
43	−	}
44	−
45	−	#[derive(Debug, PartialEq, Clone, Copy)]
46	−	pub enum SelectedTab {
47	−	DirectoryBrowser,
48	−	Queue,
49	−	Playlists,
50	−	}
51	−
52	−	#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
53	−	pub enum PlaylistFocus {
54	−	#[default]
55	−	List,
56	−	Songs,
57	−	}
58	−
59	−	impl App {
60	−	pub async fn new(address: &str, password: Option<&str>, config: Config) -> AppResult<Self> {
61	−	let mut conn = Connection::connect(address, password).await?;
62	−	let mut queue_list = ContentList::new();
63	−	queue_list.list = conn.queue().await?;
64	−	let mut pl_list = ContentList::new();
65	−	pl_list.list = conn.playlists().await?;
66	−	pl_list.list.sort();
67	−	let append_list = Self::get_append_list(&mut conn).await?;
68	−	let mut browser = FileBrowser::new();
69	−	browser.update_directory(&mut conn).await?;
70	−
71	−	if let Some(position) = conn.current_song.place {
72	−	queue_list.index = position.pos as usize;
73	−	}
74	−
75	−	let mut app = Self {
76	−	running: true,
77	−	conn,
78	−	config,
79	−	browser,
80	−	queue_list,
81	−	pl_list,
82	−	playlist_focus: PlaylistFocus::List,
83	−	playlist_song_index: 0,
84	−	selected_tab: SelectedTab::Queue,
85	−	inputmode: InputMode::Normal,
86	−	search_input: String::new(),
87	−	search_cursor_pos: 0,
88	−	browser_search_results: Vec::new(),
89	−	browser_search_index: 0,
90	−	pl_newname_input: String::new(),
91	−	pl_cursor_pos: 0,
92	−	pl_new_pl_input: String::new(),
93	−	pl_new_pl_cursor_pos: 0,
94	−	pl_new_pl_songs_buffer: Vec::new(),
95	−	playlist_popup: false,
96	−	append_list,
97	−	should_update_song_list: false,
98	−	queue_state: TableState::default(),
99	−	browser_state: TableState::default(),
100	−	playlists_state: ListState::default(),
101	−	playlist_songs_state: TableState::default(),
102	−	playlist_contents: Vec::new(),
103	−	};
104	−	app.refresh_playlist_view().await?;
105	−	Ok(app)
106	−	}
107	−
108	−	pub async fn apply_snapshot(&mut self, snapshot: MpdSnapshot) -> AppResult<()> {
109	−	let MpdSnapshot {
110	−	status,
111	−	stats,
112	−	current_song,
113	−	queue,
114	−	} = snapshot;
115	−	self.conn.apply_snapshot(status, stats, current_song);
116	−	self.queue_list.list = queue;
117	−	if self.queue_list.list.is_empty() {
118	−	self.queue_list.index = 0;
119	−	} else {
120	−	self.queue_list.index = self.queue_list.index.min(self.queue_list.list.len() - 1);
121	−	}
122	−
123	−	if self.should_update_song_list && self.conn.status.updating_db.is_none() {
124	−	self.conn.refresh_song_list().await?;
125	−	self.browser.update_directory(&mut self.conn).await?;
126	−	self.should_update_song_list = false;
127	−	}
128	−	Ok(())
129	−	}
130	−
131	−	pub fn quit(&mut self) {
132	−	self.running = false;
133	−	}
134	−
135	−	pub async fn update_queue(&mut self) -> AppResult<()> {
136	−	self.queue_list.list = self.conn.queue().await?;
137	−	if self.queue_list.list.is_empty() {
138	−	self.queue_list.index = 0;
139	−	} else {
140	−	self.queue_list.index = self.queue_list.index.min(self.queue_list.list.len() - 1);
141	−	}
142	−	Ok(())
143	−	}
144	−
145	−	pub async fn refresh_playlists(&mut self) -> AppResult<()> {
146	−	self.pl_list.list = self.conn.playlists().await?;
147	−	self.pl_list.list.sort();
148	−	self.pl_list.index = self
149	−	.pl_list
150	−	.index
151	−	.min(self.pl_list.list.len().saturating_sub(1));
152	−	self.append_list = Self::get_append_list(&mut self.conn).await?;
153	−	self.refresh_playlist_view().await
154	−	}
155	−
156	−	pub async fn refresh_playlist_view(&mut self) -> AppResult<()> {
157	−	self.playlist_contents = match self.pl_list.list.get(self.pl_list.index) {
158	−	Some(name) => self.conn.playlist(name).await?,
159	−	None => Vec::new(),
160	−	};
161	−	self.playlist_song_index = self
162	−	.playlist_song_index
163	−	.min(self.playlist_contents.len().saturating_sub(1));
164	−	Ok(())
165	−	}
166	−
167	−	pub async fn delete_selected_playlist_song(&mut self) -> AppResult<()> {
168	−	let Some(playlist) = self.pl_list.list.get(self.pl_list.index) else {
169	−	return Ok(());
170	−	};
171	−	if self.playlist_song_index >= self.playlist_contents.len() {
172	−	return Ok(());
173	−	}
174	−	self.conn
175	−	.delete_playlist_song(playlist, self.playlist_song_index)
176	−	.await?;
177	−	self.refresh_playlist_view().await
178	−	}
179	−
180	−	pub async fn move_selected_playlist_song(&mut self, down: bool) -> AppResult<()> {
181	−	let Some(playlist) = self.pl_list.list.get(self.pl_list.index) else {
182	−	return Ok(());
183	−	};
184	−	let target = if down {
185	−	self.playlist_song_index.checked_add(1)
186	−	} else {
187	−	self.playlist_song_index.checked_sub(1)
188	−	};
189	−	let Some(target) = target.filter(\|target\| *target < self.playlist_contents.len()) else {
190	−	return Ok(());
191	−	};
192	−	self.conn
193	−	.move_playlist_song(playlist, self.playlist_song_index, target)
194	−	.await?;
195	−	self.playlist_song_index = target;
196	−	self.refresh_playlist_view().await
197	−	}
198	−
199	−	pub async fn delete_selected_playlist(&mut self) -> AppResult<()> {
200	−	let Some(playlist) = self.pl_list.list.get(self.pl_list.index) else {
201	−	return Ok(());
202	−	};
203	−	self.conn.delete_playlist(playlist).await?;
204	−	self.refresh_playlists().await?;
205	−	Ok(())
206	−	}
207	−
208	−	pub async fn play_selected_playlist_song(&mut self) -> AppResult<()> {
209	−	let Some(playlist) = self.pl_list.list.get(self.pl_list.index) else {
210	−	return Ok(());
211	−	};
212	−	if self.playlist_song_index >= self.playlist_contents.len() {
213	−	return Ok(());
214	−	}
215	−	let queue_position = self.conn.queue().await?.len();
216	−	self.conn.append_playlist(playlist).await?;
217	−	self.conn
218	−	.play(Some((queue_position + self.playlist_song_index) as u32))
219	−	.await?;
220	−	self.update_queue().await?;
221	−	self.conn.update_status().await
222	−	}
223	−
224	−	pub async fn get_append_list(conn: &mut Connection) -> AppResult<ContentList<String>> {
225	−	let mut list = ContentList::new();
226	−	list.list.push("Current Playlist".to_string());
227	−	list.list.push("New Playlist".to_string());
228	−	list.list.extend(conn.playlists().await?);
229	−	Ok(list)
230	−	}
231	−
232	−	pub async fn toggle_selected_item(&mut self) -> AppResult<()> {
233	−	match self.selected_tab {
234	−	SelectedTab::DirectoryBrowser => {
235	−	let Some(entry) = self.browser.entries.get(self.browser.selected).cloned() else {
236	−	return Ok(());
237	−	};
238	−	match entry {
239	−	BrowserEntry::Directory(name) => {
240	−	self.conn.add(&name).await?;
241	−	}
242	−	BrowserEntry::Song(song) => {
243	−	let positions: Vec<u32> = self
244	−	.queue_list
245	−	.list
246	−	.iter()
247	−	.enumerate()
248	−	.filter_map(\|(index, queued)\| {
249	−	(queued.file == song.file).then_some(index as u32)
250	−	})
251	−	.collect();
252	−	if positions.is_empty() {
253	−	self.conn.add(&song.file).await?;
254	−	} else {
255	−	for position in positions.into_iter().rev() {
256	−	self.conn.delete(position).await?;
257	−	}
258	−	}
259	−	}
260	−	}
261	−	if self.browser.selected < self.browser.entries.len().saturating_sub(1) {
262	−	self.browser.selected += 1;
263	−	}
264	−	}
265	−	SelectedTab::Queue => {
266	−	if !self.queue_list.list.is_empty() {
267	−	self.conn.delete(self.queue_list.index as u32).await?;
268	−	}
269	−	}
270	−	SelectedTab::Playlists => {}
271	−	}
272	−	self.update_queue().await?;
273	−	self.conn.update_status().await?;
274	−	Ok(())
275	−	}
276	−
277	−	pub fn cycle_tabs(&mut self) {
278	−	self.selected_tab = match self.selected_tab {
279	−	SelectedTab::Queue => SelectedTab::DirectoryBrowser,
280	−	SelectedTab::DirectoryBrowser => SelectedTab::Playlists,
281	−	SelectedTab::Playlists => SelectedTab::Queue,
282	−	};
283	−	}
284	−
285	−	pub async fn handle_enter(&mut self) -> AppResult<()> {
286	−	let Some(entry) = self.browser.entries.get(self.browser.selected).cloned() else {
287	−	return Ok(());
288	−	};
289	−	match entry {
290	−	BrowserEntry::Directory(name) => {
291	−	self.browser.prev_selected = self.browser.selected;
292	−	self.browser.path = name;
293	−	self.browser.selected = 0;
294	−	self.browser.update_directory(&mut self.conn).await?;
295	−	}
296	−	BrowserEntry::Song(song) => {
297	−	if let Some(index) = self
298	−	.queue_list
299	−	.list
300	−	.iter()
301	−	.position(\|queued\| queued.file == song.file)
302	−	{
303	−	self.conn.play(Some(index as u32)).await?;
304	−	} else {
305	−	self.conn.push(&song).await?;
306	−	self.update_queue().await?;
307	−	}
308	−	self.conn.update_status().await?;
309	−	}
310	−	}
311	−	Ok(())
312	−	}
313	−
314	−	pub async fn append_selected_to(&mut self) -> AppResult<()> {
315	−	let Some(playlist) = self.append_list.list.get(self.append_list.index).cloned() else {
316	−	return Ok(());
317	−	};
318	−	let songs = match self.selected_tab {
319	−	SelectedTab::Queue => self
320	−	.queue_list
321	−	.list
322	−	.get(self.queue_list.index)
323	−	.cloned()
324	−	.into_iter()
325	−	.collect(),
326	−	SelectedTab::DirectoryBrowser => {
327	−	let Some(entry) = self.browser.entries.get(self.browser.selected).cloned() else {
328	−	return Ok(());
329	−	};
330	−	match entry {
331	−	BrowserEntry::Song(song) => vec![song],
332	−	BrowserEntry::Directory(name) => self
333	−	.conn
334	−	.list_files(&name)
335	−	.await?
336	−	.into_iter()
337	−	.filter_map(\|(kind, file)\| {
338	−	(kind == "file" && is_audio_file(&file))
339	−	.then(\|\| Connection::song_from_file(&file))
340	−	})
341	−	.collect(),
342	−	}
343	−	}
344	−	SelectedTab::Playlists => {
345	−	let Some(name) = self.pl_list.list.get(self.pl_list.index) else {
346	−	return Ok(());
347	−	};
348	−	self.conn.playlist(name).await?
349	−	}
350	−	};
351	−
352	−	if playlist == "Current Playlist" {
353	−	if self.selected_tab == SelectedTab::Playlists {
354	−	if let Some(name) = self.pl_list.list.get(self.pl_list.index) {
355	−	self.conn.load_playlist(name).await?;
356	−	self.update_queue().await?;
357	−	}
358	−	} else {
359	−	let selected_directory = if self.selected_tab == SelectedTab::DirectoryBrowser {
360	−	self.browser
361	−	.entries
362	−	.get(self.browser.selected)
363	−	.and_then(\|entry\| {
364	−	if let BrowserEntry::Directory(path) = entry {
365	−	Some(path.as_str())
366	−	} else {
367	−	None
368	−	}
369	−	})
370	−	} else {
371	−	None
372	−	};
373	−	if let Some(path) = selected_directory {
374	−	self.conn.add(path).await?;
375	−	} else {
376	−	for song in songs {
377	−	self.conn.add(&song.file).await?;
378	−	}
379	−	}
380	−	self.update_queue().await?;
381	−	}
382	−	} else if playlist == "New Playlist" {
383	−	self.pl_new_pl_songs_buffer = songs;
384	−	self.inputmode = InputMode::NewPlaylist;
385	−	} else {
386	−	for song in songs {
387	−	self.conn.add_to_playlist(&playlist, &song).await?;
388	−	}
389	−	self.refresh_playlists().await?;
390	−	}
391	−	self.playlist_popup = false;
392	−	self.append_list.index = 0;
393	−	Ok(())
394	−	}
395	−
396	−	pub fn move_cursor_left(&mut self) {
397	−	let cursor = self.cursor_position().saturating_sub(1);
398	−	self.set_cursor_position(cursor);
399	−	}
400	−
401	−	pub fn move_cursor_right(&mut self) {
402	−	let cursor = self.cursor_position().saturating_add(1);
403	−	self.set_cursor_position(cursor);
404	−	}
405	−
406	−	fn cursor_position(&self) -> usize {
407	−	match self.inputmode {
408	−	InputMode::PlaylistRename => self.pl_cursor_pos,
409	−	InputMode::Editing => self.search_cursor_pos,
410	−	InputMode::NewPlaylist => self.pl_new_pl_cursor_pos,
411	−	InputMode::Normal => 0,
412	−	}
413	−	}
414	−
415	−	fn set_cursor_position(&mut self, position: usize) {
416	−	let length = match self.inputmode {
417	−	InputMode::PlaylistRename => self.pl_newname_input.chars().count(),
418	−	InputMode::Editing => self.search_input.chars().count(),
419	−	InputMode::NewPlaylist => self.pl_new_pl_input.chars().count(),
420	−	InputMode::Normal => 0,
421	−	};
422	−	let position = position.min(length);
423	−	match self.inputmode {
424	−	InputMode::PlaylistRename => self.pl_cursor_pos = position,
425	−	InputMode::Editing => self.search_cursor_pos = position,
426	−	InputMode::NewPlaylist => self.pl_new_pl_cursor_pos = position,
427	−	InputMode::Normal => {}
428	−	}
429	−	}
430	−
431	−	pub fn enter_char(&mut self, character: char) {
432	−	let (text, cursor) = match self.inputmode {
433	−	InputMode::PlaylistRename => (&mut self.pl_newname_input, self.pl_cursor_pos),
434	−	InputMode::Editing => (&mut self.search_input, self.search_cursor_pos),
435	−	InputMode::NewPlaylist => (&mut self.pl_new_pl_input, self.pl_new_pl_cursor_pos),
436	−	InputMode::Normal => return,
437	−	};
438	−	let byte_index = text
439	−	.char_indices()
440	−	.nth(cursor)
441	−	.map(\|(index, _)\| index)
442	−	.unwrap_or(text.len());
443	−	text.insert(byte_index, character);
444	−	self.move_cursor_right();
445	−	}
446	−
447	−	pub fn delete_char(&mut self) {
448	−	let cursor = self.cursor_position();
449	−	if cursor == 0 {
450	−	return;
451	−	}
452	−	let text = match self.inputmode {
453	−	InputMode::PlaylistRename => &mut self.pl_newname_input,
454	−	InputMode::Editing => &mut self.search_input,
455	−	InputMode::NewPlaylist => &mut self.pl_new_pl_input,
456	−	InputMode::Normal => return,
457	−	};
458	−	let start = text.char_indices().nth(cursor - 1).map(\|(i, _)\| i);
459	−	let end = text
460	−	.char_indices()
461	−	.nth(cursor)
462	−	.map(\|(i, _)\| i)
463	−	.unwrap_or(text.len());
464	−	if let Some(start) = start {
465	−	text.replace_range(start..end, "");
466	−	self.move_cursor_left();
467	−	}
468	−	}
469	−
470	−	pub fn reset_cursor(&mut self) {
471	−	self.set_cursor_position(0);
472	−	}
473	−
474	−	pub fn format_time(time: Duration) -> String {
475	−	let seconds = time.as_secs();
476	−	let hours = seconds / 3600;
477	−	let minutes = (seconds % 3600) / 60;
478	−	let seconds = seconds % 60;
479	−	if hours == 0 {
480	−	format!("{minutes:02}:{seconds:02}")
481	−	} else {
482	−	format!("{hours:02}:{minutes:02}:{seconds:02}")
483	−	}
484	−	}
485	−
486	−	pub fn handle_scroll_up(&mut self) {
487	−	match self.selected_tab {
488	−	SelectedTab::Queue => self.queue_list.prev(),
489	−	SelectedTab::DirectoryBrowser => self.browser.prev(),
490	−	SelectedTab::Playlists => self.pl_list.prev(),
491	−	}
492	−	}
493	−
494	−	pub fn handle_scroll_down(&mut self) {
495	−	match self.selected_tab {
496	−	SelectedTab::Queue => self.queue_list.next(),
497	−	SelectedTab::DirectoryBrowser => self.browser.next(),
498	−	SelectedTab::Playlists => self.pl_list.next(),
499	−	}
500	−	}
501	−	}

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

	@@ -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,15 +1,4 @@
1		−	//! An asynchronous terminal client for Music Player Daemon.
2		−
3		−	pub mod app;
4		−	pub mod browser;
	1	+	pub mod action;
5	2		pub mod config;
6		−	pub mod connection;
7		−	pub mod event_handler;
8		−	pub mod list;
9		−	pub mod logging;
10		−	pub mod tui;
11		−	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>>;
	3	+	pub mod mpd;
	4	+	pub mod util;

	@@ -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	−	}

	@@ -1,86 +0,0 @@
1	−	use std::{
2	−	fs::{self, OpenOptions},
3	−	io::{self, Write},
4	−	path::{Path, PathBuf},
5	−	sync::{Mutex, OnceLock},
6	−	time::{SystemTime, UNIX_EPOCH},
7	−	};
8	−
9	−	use crate::AppResult;
10	−
11	−	static LOG_FILE: OnceLock<Mutex<fs::File>> = OnceLock::new();
12	−
13	−	pub fn init(path: &Path) -> AppResult<PathBuf> {
14	−	if let Some(parent) = path.parent() {
15	−	fs::create_dir_all(parent)?;
16	−	}
17	−
18	−	let mut options = OpenOptions::new();
19	−	options.create(true).append(true);
20	−	#[cfg(unix)]
21	−	{
22	−	use std::os::unix::fs::OpenOptionsExt;
23	−	options.mode(0o600);
24	−	}
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);
49	−	}));
50	−
51	−	info(&format!("logging initialized: {}", path.display()));
52	−	Ok(path.to_path_buf())
53	−	}
54	−
55	−	pub fn info(message: &str) {
56	−	write("INFO", message);
57	−	}
58	−
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);
81	−	}
82	−	}
83	−
84	−	fn report_write_error(error: io::Error) {
85	−	eprintln!("failed to write rmptui log: {error}");
86	−	}

		@@ -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,14 @@
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 types;
8	+	mod worker;
9	+
10	+	pub use connection::{Address, Connection};
11	+	pub use error::{Ack, MpdError, MpdResult};
12	+	pub use protocol::Command;
13	+	pub use types::{Album, DirEntry, OnOff, PlayState, PlaylistInfo, Song, Status, Subsystem};
14	+	pub use worker::{MpdEvent, MpdHandle, Query, Reply, Request, spawn};

	@@ -0,0 +1,59 @@
1	+	//! Small helpers shared across modules.
2	+
3	+	use std::{env, path::PathBuf, time::Duration};
4	+
5	+	/// Replaces a leading `~` with the home directory.
6	+	pub fn expand_tilde(path: &str) -> PathBuf {
7	+	match path.strip_prefix('~') {
8	+	Some(rest) if rest.is_empty() \|\| rest.starts_with('/') => {
9	+	env::var_os("HOME").map(PathBuf::from).map_or_else(
10	+	\|\| PathBuf::from(path),
11	+	\|home\| home.join(rest.trim_start_matches('/')),
12	+	)
13	+	}
14	+	_ => PathBuf::from(path),
15	+	}
16	+	}
17	+
18	+	/// `$XDG_CACHE_HOME/rmptui`, falling back to `~/.cache/rmptui`.
19	+	pub fn cache_dir() -> PathBuf {
20	+	env::var_os("XDG_CACHE_HOME")
21	+	.filter(\|dir\| !dir.is_empty())
22	+	.map(PathBuf::from)
23	+	.unwrap_or_else(\|\| expand_tilde("~/.cache"))
24	+	.join("rmptui")
25	+	}
26	+
27	+	/// Formats a duration as `m:ss` or `h:mm:ss`.
28	+	pub fn format_duration(duration: Duration) -> String {
29	+	let secs = duration.as_secs();
30	+	let (h, m, s) = (secs / 3600, secs / 60 % 60, secs % 60);
31	+	if h > 0 {
32	+	format!("{h}:{m:02}:{s:02}")
33	+	} else {
34	+	format!("{m}:{s:02}")
35	+	}
36	+	}
37	+
38	+	#[cfg(test)]
39	+	mod tests {

	@@ -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,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	+	}

	@@ -0,0 +1,403 @@
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,
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	+	conn.execute_all(&[commands::load(name), commands::play_pos(start + offset)])
300	+	.await
301	+	.map(\|()\| None)
302	+	}
303	+	}
304	+	}
305	+
306	+	async fn queue_length(conn: &mut Connection) -> MpdResult<u32> {
307	+	let status = conn.execute(&Command::new("status")).await?;
308	+	Ok(Status::from_pairs(&status).playlist_length)
309	+	}
310	+
311	+	async fn run_query(conn: &mut Connection, query: &Query) -> MpdResult<Reply> {
312	+	Ok(match query {
313	+	Query::Status => {
314	+	let responses = conn
315	+	.execute_list(&[Command::new("status"), Command::new("currentsong")])
316	+	.await?;
317	+	let [status, current] = <[_; 2]>::try_from(responses)
318	+	.map_err(\|_\| MpdError::Protocol("short command list response".into()))?;
319	+	let current = (!current.is_empty()).then(\|\| Song::from_pairs(&current));
320	+	Reply::Status {
321	+	status: Status::from_pairs(&status),
322	+	current,
323	+	}
324	+	}
325	+	Query::QueueChanges { since } => {
326	+	let responses = conn
327	+	.execute_list(&[
328	+	Command::new("status"),
329	+	Command::new("plchanges").arg(since.to_string()),
330	+	])
331	+	.await?;
332	+	let [status, changes] = <[_; 2]>::try_from(responses)
333	+	.map_err(\|_\| MpdError::Protocol("short command list response".into()))?;
334	+	Reply::QueueChanges {
335	+	status: Status::from_pairs(&status),
336	+	since: *since,
337	+	changes: parse_songs(&changes),
338	+	}
339	+	}
340	+	Query::Playlists => Reply::Playlists(parse_playlists(
341	+	&conn.execute(&Command::new("listplaylists")).await?,
342	+	)),
343	+	Query::Directory(path) => {
344	+	let entries = parse_entries(&conn.execute(&Command::new("lsinfo").arg(path)).await?);
345	+	Reply::Directory {
346	+	path: path.clone(),
347	+	entries,
348	+	}
349	+	}
350	+	Query::PlaylistSongs(name) => {
351	+	let pairs = conn
352	+	.execute(&Command::new("listplaylistinfo").arg(name))
353	+	.await?;
354	+	Reply::PlaylistSongs {
355	+	name: name.clone(),
356	+	songs: parse_songs(&pairs),
357	+	}
358	+	}
359	+	Query::TagValues(tag) => {
360	+	let pairs = conn.execute(&Command::new("list").arg(tag)).await?;
361	+	Reply::TagValues {
362	+	tag: tag.clone(),
363	+	values: parse_tag_values(&pairs, tag),
364	+	}
365	+	}
366	+	Query::Albums { tag, value } => {
367	+	let pairs = conn
368	+	.execute(
369	+	&Command::new("list")
370	+	.arg("Album")
371	+	.arg(super::protocol::filter_eq(tag, value))
372	+	.arg("group")
373	+	.arg("Date"),
374	+	)
375	+	.await?;
376	+	Reply::Albums {
377	+	tag: tag.clone(),
378	+	value: value.clone(),
379	+	albums: parse_albums(&pairs),
380	+	}
381	+	}
382	+	Query::Find(filter) => {
383	+	let mut songs = parse_songs(&conn.execute(&Command::new("find").arg(filter)).await?);
384	+	songs.sort_by_key(Song::disc_track);
385	+	Reply::Find {
386	+	filter: filter.clone(),
387	+	songs,
388	+	}
389	+	}
390	+	Query::MusicDirectory => {
391	+	let dir = match conn.execute(&Command::new("config")).await {
392	+	Ok(pairs) => pairs
393	+	.into_iter()
394	+	.find(\|(key, _)\| key == "music_directory")
395	+	.map(\|(_, dir)\| PathBuf::from(dir)),
396	+	// `config` is only permitted on local (Unix socket) connections.
397	+	Err(MpdError::Ack(_)) => None,
398	+	Err(error) => return Err(error),
399	+	};
400	+	Reply::MusicDirectory(dir)
401	+	}
402	+	})
403	+	}

	@@ -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,489 +0,0 @@
1	−	use std::time::Duration;
2	−
3	−	use crate::{
4	−	app::{App, PlaylistFocus, SelectedTab},
5	−	browser::BrowserEntry,
6	−	connection::{PlaybackState, Song, VolumeStatus},
7	−	};
8	−	use ratatui::{prelude::, widgets::};
9	−
10	−	#[derive(Debug, PartialEq, Clone, Copy)]
11	−	pub enum InputMode {
12	−	Editing,
13	−	Normal,
14	−	PlaylistRename,
15	−	NewPlaylist,
16	−	}
17	−
18	−	fn song_row(song: &Song, playing: bool, queued: bool) -> Row<'static> {
19	−	let mut artist = song.artist.clone().unwrap_or_default();
20	−	let track = tag_value(song, "Track");
21	−	let title = song.title.clone().unwrap_or_else(\|\| song.file.clone());
22	−	let album = tag_value(song, "Album");
23	−	let time = App::format_time(song.duration.unwrap_or(Duration::ZERO));
24	−
25	−	if playing {
26	−	artist.insert_str(0, "> ");
27	−	}
28	−	let row = Row::new(vec![
29	−	Cell::from(artist.cyan()),
30	−	Cell::from(if playing {
31	−	format!(" {track}").green()
32	−	} else {
33	−	track.green()
34	−	}),
35	−	Cell::from(if playing { format!(" {title}") } else { title }),
36	−	Cell::from(album.cyan()),
37	−	Cell::from(time.magenta()),
38	−	]);
39	−	if queued {
40	−	row.bold()
41	−	} else {
42	−	row
43	−	}
44	−	}
45	−
46	−	fn tag_value(song: &Song, name: &str) -> String {
47	−	song.tags
48	−	.iter()
49	−	.find(\|(tag, _)\| tag.eq_ignore_ascii_case(name))
50	−	.map(\|(_, value)\| value.clone())
51	−	.unwrap_or_default()
52	−	}
53	−
54	−	/// Renders the user interface widgets
55	−	pub fn render(app: &mut App, frame: &mut Frame) {
56	−	// Layout
57	−	let layout = Layout::default()
58	−	.direction(Direction::Vertical)
59	−	.constraints(vec![Constraint::Percentage(93), Constraint::Min(3)])
60	−	.split(frame.area());
61	−
62	−	match app.selected_tab {
63	−	SelectedTab::Queue => draw_queue(frame, app, layout[0]),
64	−	SelectedTab::Playlists => draw_playlist_viewer(frame, app, layout[0]),
65	−	SelectedTab::DirectoryBrowser => draw_directory_browser(frame, app, layout[0]),
66	−	}
67	−
68	−	match app.inputmode {
69	−	InputMode::Normal => {
70	−	draw_progress_bar(frame, app, layout[1]);
71	−	}
72	−	InputMode::Editing => {
73	−	draw_search_bar(frame, app, layout[1]);
74	−	}
75	−	InputMode::PlaylistRename => {
76	−	draw_rename_playlist(frame, app, layout[1]);
77	−	}
78	−	InputMode::NewPlaylist => {
79	−	draw_new_playlist(frame, app, layout[1]);
80	−	}
81	−	}
82	−
83	−	if app.playlist_popup {
84	−	draw_add_to_playlist(frame, app, layout[0]);
85	−	}
86	−	}
87	−
88	−	/// Draws the directory
89	−	fn draw_directory_browser(frame: &mut Frame, app: &mut App, size: Rect) {
90	−	let total_songs = app.conn.stats.songs.to_string();
91	−
92	−	let rows = app.browser.entries.iter().map(\|entry\| match entry {
93	−	BrowserEntry::Song(song) => {
94	−	let queued =
95	−	app.queue_list.list.iter().any(\|queued\| {
96	−	queued.file.rsplit('/').next().unwrap_or_default() == entry.name()
97	−	});
98	−	song_row(song, false, queued)
99	−	}
100	−	BrowserEntry::Directory(name) => directory_row(name),
101	−	});
102	−
103	−	let header = ["Artist", "Track", "Title", "Album", "Time"]
104	−	.into_iter()
105	−	.map(Cell::from)
106	−	.collect::<Row>()
107	−	.bold()
108	−	.height(1);
109	−	let table = Table::new(
110	−	rows,
111	−	[
112	−	Constraint::Percentage(34),
113	−	Constraint::Percentage(3),
114	−	Constraint::Min(30),
115	−	Constraint::Percentage(30),
116	−	Constraint::Percentage(3),
117	−	],
118	−	)
119	−	.block(
120	−	Block::default()
121	−	.title(format!("Song Browser: {}", app.browser.path).bold())
122	−	.title(
123	−	Line::from(format!("Total Songs: {}", total_songs).green())
124	−	.alignment(Alignment::Center),
125	−	)
126	−	.title(match app.conn.volume_status {
127	−	VolumeStatus::Unmuted => {
128	−	Line::from(format!("Volume: {}%", app.conn.status.volume).green())
129	−	.alignment(Alignment::Right)
130	−	}
131	−	VolumeStatus::Muted(_v) => Line::from("Muted".red()).alignment(Alignment::Right),
132	−	})
133	−	.borders(Borders::ALL),
134	−	)
135	−	.row_highlight_style(
136	−	Style::default()
137	−	.add_modifier(Modifier::REVERSED)
138	−	.fg(Color::Cyan)
139	−	.bg(Color::Black),
140	−	)
141	−	.header(header)
142	−	.flex(layout::Flex::Legacy);
143	−
144	−	app.browser_state.select(Some(app.browser.selected));
145	−	frame.render_stateful_widget(table, size, &mut app.browser_state);
146	−	}
147	−
148	−	/// draws playing queue
149	−	fn draw_queue(frame: &mut Frame, app: &mut App, size: Rect) {
150	−	let rows = app.queue_list.list.iter().enumerate().map(\|(i, song)\| {
151	−	let playing = app
152	−	.conn
153	−	.current_song
154	−	.place
155	−	.is_some_and(\|position\| i == position.pos as usize);
156	−	song_row(song, playing, false)
157	−	});
158	−
159	−	let header = ["Artist", "Track", "Title", "Album", "Time"]
160	−	.into_iter()
161	−	.map(Cell::from)
162	−	.collect::<Row>()
163	−	.bold()
164	−	.height(1);
165	−	let table = Table::new(
166	−	rows,
167	−	[
168	−	Constraint::Percentage(34),
169	−	Constraint::Percentage(3),
170	−	Constraint::Min(30),
171	−	Constraint::Percentage(30),
172	−	Constraint::Percentage(3),
173	−	],
174	−	)
175	−	.block(
176	−	Block::default()
177	−	.title("Play Queue".green().bold())
178	−	.title(format!("({} items)", app.queue_list.list.len()).bold())
179	−	.title(match app.conn.volume_status {
180	−	VolumeStatus::Unmuted => {
181	−	Line::from(format!("Volume: {}%", app.conn.status.volume).green())
182	−	.alignment(Alignment::Right)
183	−	}
184	−	VolumeStatus::Muted(_v) => Line::from("Muted".red()).alignment(Alignment::Right),
185	−	})
186	−	.borders(Borders::ALL),
187	−	)
188	−	.row_highlight_style(
189	−	Style::default()
190	−	.add_modifier(Modifier::REVERSED)
191	−	.fg(Color::Cyan)
192	−	.bg(Color::Black),
193	−	)
194	−	.header(header)
195	−	.flex(layout::Flex::Legacy);
196	−
197	−	app.queue_state.select(Some(app.queue_list.index));
198	−	frame.render_stateful_widget(table, size, &mut app.queue_state);
199	−	}
200	−
201	−	// Draw search bar
202	−	fn draw_search_bar(frame: &mut Frame, app: &mut App, size: Rect) {
203	−	// Make the cursor visible and ask ratatui to put it at the specified coordinates after
204	−	// rendering
205	−	#[allow(clippy::cast_possible_truncation)]
206	−	frame.set_cursor_position((
207	−	// Draw the cursor at the current position in the input field.
208	−	// This position is can be controlled via the left and right arrow key
209	−	size.x + app.search_cursor_pos as u16 + 2,
210	−	// Move one line down, from the border to the input line
211	−	size.y + 1,
212	−	));
213	−
214	−	let input = Paragraph::new("/".to_string() + &app.search_input)
215	−	.style(Style::default())
216	−	.block(
217	−	Block::default()
218	−	.borders(Borders::ALL)
219	−	.title("Search: Enter to keep, n/N next/previous ".bold().green()),
220	−	);
221	−	frame.render_widget(input, size);
222	−	}
223	−
224	−	/// Draws Progress Bar
225	−	fn draw_progress_bar(frame: &mut Frame, app: &mut App, size: Rect) {
226	−	let song = app.conn.now_playing();
227	−
228	−	// Get the current playing state
229	−	let mut state = String::new();
230	−	if !app.queue_list.list.is_empty() {
231	−	state.push_str(match app.conn.status.state {
232	−	PlaybackState::Playing => "Playing",
233	−	PlaybackState::Paused => "Paused",
234	−	PlaybackState::Stopped => "Stopped",
235	−	});
236	−	state.push(':');
237	−	}
238	−
239	−	// Get the current modes
240	−	let mut modes_bottom: String = String::new();
241	−	// we do this to check if at least one mode is enabled so we can push "[]"
242	−	if app.conn.status.repeat \| app.conn.status.random {
243	−	modes_bottom.push('r');
244	−	}
245	−
246	−	if !modes_bottom.is_empty() {
247	−	modes_bottom.clear();
248	−	modes_bottom.push('[');
249	−	if app.conn.status.repeat {
250	−	modes_bottom.push('r');
251	−	}
252	−	if app.conn.status.random {
253	−	modes_bottom.push('z');
254	−	}
255	−	modes_bottom.push(']');
256	−	};
257	−
258	−	// get the duration
259	−	let duration = if !app.conn.status.total.is_zero() {
260	−	format!(
261	−	"[{}/{}]",
262	−	App::format_time(app.conn.current_elapsed()),
263	−	App::format_time(app.conn.status.total)
264	−	)
265	−	} else {
266	−	"".to_string()
267	−	};
268	−
269	−	// Define the title
270	−	let title = Block::default()
271	−	.title(state.red().bold())
272	−	.title(song.green())
273	−	.title(Line::from(duration.cyan().bold()).alignment(Alignment::Right))
274	−	.title_bottom(modes_bottom)
275	−	.borders(Borders::ALL);
276	−
277	−	let progress_bar = LineGauge::default()
278	−	.block(title.borders(Borders::ALL))
279	−	.filled_style(
280	−	Style::default()
281	−	.fg(Color::Blue)
282	−	.add_modifier(Modifier::BOLD),
283	−	)
284	−	.unfilled_style(
285	−	Style::default()
286	−	.fg(Color::Black)
287	−	.add_modifier(Modifier::BOLD),
288	−	)
289	−	.filled_symbol(symbols::line::THICK_HORIZONTAL)
290	−	.unfilled_symbol(symbols::line::THICK_HORIZONTAL)
291	−	.ratio(app.conn.get_progress_ratio());
292	−
293	−	frame.render_widget(progress_bar, size);
294	−	}
295	−
296	−	fn draw_playlist_viewer(frame: &mut Frame, app: &mut App, area: Rect) {
297	−	let layouts = Layout::default()
298	−	.direction(Direction::Horizontal)
299	−	.constraints(vec![Constraint::Percentage(40), Constraint::Percentage(60)])
300	−	.split(area);
301	−
302	−	// Draw list of playlists
303	−	let list_focused = app.playlist_focus == PlaylistFocus::List;
304	−	let title = Block::default()
305	−	.title("Playlists".green().bold())
306	−	.borders(Borders::ALL)
307	−	.border_style(if list_focused {
308	−	Style::default().fg(Color::Cyan)
309	−	} else {
310	−	Style::default()
311	−	});
312	−	let list = List::new(app.pl_list.list.iter().map(String::as_str))
313	−	.block(title)
314	−	.highlight_style(Style::new().fg(Color::Cyan).bg(Color::Black).add_modifier(
315	−	if list_focused {
316	−	Modifier::BOLD \| Modifier::REVERSED
317	−	} else {
318	−	Modifier::BOLD
319	−	},
320	−	))
321	−	.repeat_highlight_symbol(true);
322	−	app.playlists_state.select(Some(app.pl_list.index));
323	−	frame.render_stateful_widget(list, layouts[0], &mut app.playlists_state);
324	−
325	−	// Playlist viewer
326	−
327	−	// Handle if there are no playlists in the mpd database
328	−	if app.pl_list.list.is_empty() {
329	−	let title = Block::default()
330	−	.title("No Playlists Found".red().bold())
331	−	.title_alignment(Alignment::Center)
332	−	.borders(Borders::ALL);
333	−	frame.render_widget(Clear, area); //this clears out the background
334	−	frame.render_widget(title, area);
335	−	return;
336	−	}
337	−
338	−	let songs = &app.playlist_contents;
339	−	let rows = songs.iter().map(\|song\| {
340	−	let title = song.title.as_deref().unwrap_or_default().cyan();
341	−	let artist = song.artist.as_deref().unwrap_or(&song.file);
342	−	let time = App::format_time(song.duration.unwrap_or(Duration::ZERO));
343	−
344	−	let row = Row::new(vec![
345	−	Cell::from(artist),
346	−	Cell::from(title),
347	−	Cell::from(time.to_string().green()),
348	−	]);
349	−	row
350	−	});
351	−
352	−	let title = Block::default()
353	−	.title(format!("Content: ({} items)", songs.len()).bold())
354	−	.borders(Borders::ALL)
355	−	.border_style(if app.playlist_focus == PlaylistFocus::Songs {
356	−	Style::default().fg(Color::Cyan)
357	−	} else {
358	−	Style::default()
359	−	});
360	−	let table = Table::new(
361	−	rows,
362	−	vec![
363	−	Constraint::Percentage(40),
364	−	Constraint::Percentage(50),
365	−	Constraint::Percentage(10),
366	−	],
367	−	)
368	−	.block(title)
369	−	.row_highlight_style(
370	−	Style::default()
371	−	.add_modifier(Modifier::REVERSED)
372	−	.fg(Color::Cyan)
373	−	.bg(Color::Black),
374	−	)
375	−	.flex(layout::Flex::SpaceBetween);
376	−	app.playlist_songs_state
377	−	.select(Some(app.playlist_song_index));
378	−	frame.render_stateful_widget(table, layouts[1], &mut app.playlist_songs_state);
379	−	}
380	−
381	−	fn draw_add_to_playlist(frame: &mut Frame, app: &mut App, area: Rect) {
382	−	let area = centered_rect(40, 50, area);
383	−	let mut state = ListState::default();
384	−	let title = Block::default()
385	−	.title("Add Selected Item to: ")
386	−	.title(Line::from("<Esc> to Cancel".green().bold()).alignment(Alignment::Right));
387	−	let list = List::new(app.append_list.list.iter().map(String::as_str))
388	−	.block(title.borders(Borders::ALL))
389	−	.highlight_style(
390	−	Style::new()
391	−	.fg(Color::Cyan)
392	−	.bg(Color::Black)
393	−	.add_modifier(Modifier::BOLD)
394	−	.add_modifier(Modifier::REVERSED),
395	−	)
396	−	.repeat_highlight_symbol(true);
397	−
398	−	state.select(Some(app.append_list.index));
399	−	frame.render_widget(Clear, area); //this clears out the background
400	−	frame.render_stateful_widget(list, area, &mut state);
401	−	}
402	−
403	−	fn draw_rename_playlist(frame: &mut Frame, app: &mut App, area: Rect) {
404	−	#[allow(clippy::cast_possible_truncation)]
405	−	frame.set_cursor_position((
406	−	// Draw the cursor at the current position in the input field.
407	−	// This position is can be controlled via the left and right arrow key
408	−	area.x + app.pl_cursor_pos as u16 + 2,
409	−	// Move one line down, from the border to the input line
410	−	area.y + 1,
411	−	));
412	−
413	−	let input = Paragraph::new("/".to_string() + &app.pl_newname_input)
414	−	.style(Style::default())
415	−	.block(
416	−	Block::default()
417	−	.borders(Borders::ALL)
418	−	.title("Enter New Name: ".bold().green()),
419	−	);
420	−	frame.render_widget(input, area);
421	−	}
422	−
423	−	fn draw_new_playlist(frame: &mut Frame, app: &mut App, area: Rect) {
424	−	#[allow(clippy::cast_possible_truncation)]
425	−	frame.set_cursor_position((
426	−	// Draw the cursor at the current position in the input field.
427	−	// This position is can be controlled via the left and right arrow key
428	−	area.x + app.pl_new_pl_cursor_pos as u16 + 2,
429	−	// Move one line down, from the border to the input line
430	−	area.y + 1,
431	−	));
432	−
433	−	let input = Paragraph::new("/".to_string() + &app.pl_new_pl_input)
434	−	.style(Style::default())
435	−	.block(
436	−	Block::default()
437	−	.borders(Borders::ALL)
438	−	.title("Enter New Playlist's Name: ".bold().green()),
439	−	);
440	−	frame.render_widget(input, area);
441	−	}
442	−
443	−	fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
444	−	let popup_layout = Layout::vertical([
445	−	Constraint::Percentage((100 - percent_y) / 2),
446	−	Constraint::Percentage(percent_y),
447	−	Constraint::Percentage((100 - percent_y) / 2),
448	−	])
449	−	.split(r);
450	−
451	−	Layout::horizontal([
452	−	Constraint::Percentage((100 - percent_x) / 2),
453	−	Constraint::Percentage(percent_x),
454	−	Constraint::Percentage((100 - percent_x) / 2),
455	−	])
456	−	.split(popup_layout[1])[1]
457	−	}
458	−
459	−	fn directory_row(name: &str) -> Row<'static> {
460	−	Row::new(vec![Cell::from(format!("[{name}]")).column_span(5)])
461	−	}
462	−
463	−	#[cfg(test)]
464	−	mod tests {
465	−	use super::*;
466	−
467	−	#[test]
468	−	fn directory_names_use_the_full_browser_row_width() {
469	−	let name = "mr-robot-vol1-long-name";
470	−	let area = Rect::new(0, 0, 80, 1);
471	−	let mut buffer = Buffer::empty(area);
472	−	let table = Table::new(
473	−	[directory_row(name)],
474	−	[
475	−	Constraint::Length(6),
476	−	Constraint::Length(2),
477	−	Constraint::Length(10),
478	−	Constraint::Length(10),
479	−	Constraint::Length(6),
480	−	],
481	−	);
482	−	Widget::render(table, area, &mut buffer);
483	−
484	−	let rendered = (0..area.width)
485	−	.map(\|x\| buffer[(x, 0)].symbol())
486	−	.collect::<String>();
487	−	assert!(rendered.contains(&format!("[{name}]")));
488	−	}
489	−	}

	@@ -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	−	}

	@@ -0,0 +1,164 @@
1	+	//! Talks to a scripted fake MPD server over real TCP sockets.
2	+
3	+	use std::time::Duration;
4	+
5	+	use rmptui::mpd::{
6	+	self, Address, Command, Connection, MpdError, MpdEvent, Query, Reply, Request, Subsystem,
7	+	};
8	+	use tokio::{
9	+	io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
10	+	net::TcpListener,
11	+	sync::mpsc,
12	+	time::timeout,
13	+	};
14	+
15	+	/// Serves one connection: greets, then answers each request line with the
16	+	/// response produced by `respond`. Received lines are forwarded to `seen`.
17	+	async fn fake_server<F>(respond: F) -> (Address, mpsc::UnboundedReceiver<String>)
18	+	where
19	+	F: Fn(&str) -> String + Send + Sync + Clone + 'static,
20	+	{
21	+	let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
22	+	let address = Address::Tcp(listener.local_addr().unwrap().to_string());
23	+	let (seen_tx, seen_rx) = mpsc::unbounded_channel();
24	+	tokio::spawn(async move {
25	+	loop {
26	+	let Ok((socket, _)) = listener.accept().await else {
27	+	return;
28	+	};
29	+	let respond = respond.clone();
30	+	let seen = seen_tx.clone();
31	+	tokio::spawn(async move {
32	+	let (read, mut write) = socket.into_split();
33	+	write.write_all(b"OK MPD 0.24.0\n").await.unwrap();
34	+	let mut lines = BufReader::new(read).lines();
35	+	let mut list: Option<Vec<String>> = None;
36	+	while let Ok(Some(line)) = lines.next_line().await {
37	+	let _ = seen.send(line.clone());
38	+	let response = match (line.as_str(), list.as_mut()) {
39	+	("command_list_ok_begin", _) => {
40	+	list = Some(Vec::new());
41	+	continue;
42	+	}
43	+	("command_list_end", Some(commands)) => {
44	+	let mut out = String::new();
45	+	for command in commands.iter() {
46	+	let body = respond(command);
47	+	out.push_str(body.strip_suffix("OK\n").unwrap_or(&body));
48	+	out.push_str("list_OK\n");
49	+	}
50	+	list = None;
51	+	out + "OK\n"
52	+	}
53	+	(_, Some(commands)) => {
54	+	commands.push(line);
55	+	continue;
56	+	}
57	+	// Block forever on idle, like a quiet server.
58	+	("idle", None) => std::future::pending().await,
59	+	(_, None) => respond(&line),
60	+	};
61	+	if write.write_all(response.as_bytes()).await.is_err() {
62	+	return;
63	+	}
64	+	}
65	+	});
66	+	}
67	+	});
68	+	(address, seen_rx)
69	+	}
70	+
71	+	fn responder(line: &str) -> String {
72	+	match line {
73	+	"status" => {
74	+	"volume: 50\nstate: play\nplaylist: 3\nplaylistlength: 2\nsongid: 1\nOK\n".into()
75	+	}
76	+	"currentsong" => "file: a.flac\nTitle: A\nId: 1\nPos: 0\nOK\n".into(),
77	+	r#"password "secret""# => "OK\n".into(),
78	+	r#"addid "x.mp3""# => "Id: 42\nOK\n".into(),
79	+	r#"play "nope""# => "ACK [2@0] {play} Bad song index\n".into(),
80	+	_ => "OK\n".into(),
81	+	}
82	+	}
83	+
84	+	#[tokio::test]
85	+	async fn executes_commands_and_lists() {
86	+	let (address, mut seen) = fake_server(responder).await;
87	+	let mut conn = Connection::connect(&address, Some("secret")).await.unwrap();
88	+	assert_eq!(conn.version(), "0.24.0");
89	+	assert_eq!(seen.recv().await.unwrap(), r#"password "secret""#);
90	+
91	+	let pairs = conn.execute(&Command::new("status")).await.unwrap();
92	+	assert!(pairs.contains(&("state".into(), "play".into())));
93	+
94	+	let responses = conn
95	+	.execute_list(&[Command::new("status"), Command::new("currentsong")])
96	+	.await
97	+	.unwrap();
98	+	assert_eq!(responses.len(), 2);
99	+	assert_eq!(responses[1][0], ("file".into(), "a.flac".into()));
100	+
101	+	let error = conn
102	+	.execute(&Command::new("play").arg("nope"))
103	+	.await
104	+	.unwrap_err();
105	+	assert!(matches!(error, MpdError::Ack(ack) if ack.code == 2 && ack.command == "play"));
106	+	// The connection stays usable after an ACK.
107	+	conn.execute(&Command::new("ping")).await.unwrap();
108	+	}
109	+
110	+	#[tokio::test]
111	+	async fn worker_answers_queries_and_runs_compound_requests() {
112	+	let (address, mut seen) = fake_server(responder).await;
113	+	let (tx, mut events) = mpsc::unbounded_channel::<MpdEvent>();
114	+	let handle = mpd::spawn(address, None, tx);
115	+
116	+	assert!(matches!(
117	+	next(&mut events).await,
118	+	MpdEvent::Connected { .. }
119	+	));
120	+
121	+	handle.query(Query::Status);
122	+	match next(&mut events).await {
123	+	MpdEvent::Reply(Reply::Status { status, current }) => {
124	+	assert_eq!(status.volume, Some(50));
125	+	assert_eq!(current.unwrap().title(), Some("A"));
126	+	}
127	+	other => panic!("unexpected event {other:?}"),
128	+	}
129	+
130	+	handle.request(Request::AddAndPlay(vec!["x.mp3".into(), "y.mp3".into()]));
131	+	// Drain the requests seen by the server until the playid arrives.
132	+	let mut lines = Vec::new();
133	+	while !lines.iter().any(\|l: &String\| l.starts_with("playid")) {
134	+	lines.push(
135	+	timeout(Duration::from_secs(5), seen.recv())
136	+	.await
137	+	.unwrap()
138	+	.unwrap(),
139	+	);
140	+	}
141	+	assert!(lines.contains(&r#"addid "x.mp3""#.to_owned()));
142	+	assert!(lines.contains(&r#"add "y.mp3""#.to_owned()));
143	+	assert!(lines.contains(&r#"playid "42""#.to_owned()));
144	+
145	+	handle.exec(Command::new("play").arg("nope"));
146	+	assert!(
147	+	matches!(next(&mut events).await, MpdEvent::Error(msg) if msg.contains("Bad song index"))
148	+	);
149	+	}
150	+
151	+	async fn next(events: &mut mpsc::UnboundedReceiver<MpdEvent>) -> MpdEvent {
152	+	timeout(Duration::from_secs(5), events.recv())
153	+	.await
154	+	.unwrap()
155	+	.unwrap()
156	+	}
157	+
158	+	#[test]
159	+	fn subsystem_names() {
160	+	assert_eq!(
161	+	"stored_playlist".parse::<Subsystem>().unwrap(),
162	+	Subsystem::StoredPlaylist
163	+	);
164	+	}

rmptui/3de1a21

Start v0.2 rewrite: async MPD client and new config system

rmptui3de1a21