feat: begin initial rewrite structure

Cargo.lock

@@ -110,12 +110,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "arc-swap"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
-
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -429,19 +423,6 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
-[[package]]
-name = "color-eyre"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5920befb47832a6d61ee3a3a846565cfa39b331331e68a3b1d1116630f2f26d"
-dependencies = [
- "backtrace",
- "eyre",
- "indenter",
- "once_cell",
- "owo-colors",
-]
-
 [[package]]
 name = "colorchoice"
 version = "1.0.3"
@@ -1510,11 +1491,9 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 name = "lowfi"
 version = "1.7.2"
 dependencies = [
- "arc-swap",
  "atomic_float",
  "bytes",
  "clap",
- "color-eyre",
  "convert_case 0.8.0",
  "crossterm",
  "dirs",
@@ -1523,7 +1502,6 @@ dependencies = [
  "futures",
  "html-escape",
  "indicatif",
- "lazy_static",
  "libc",
  "mpris-server",
  "regex",
@@ -1917,12 +1895,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "owo-colors"
-version = "4.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e"
-
 [[package]]
 name = "parking"
 version = "2.2.1"

Cargo.toml

@@ -27,12 +27,10 @@ clap = { version = "4.5.21", features = ["derive", "cargo"] }
 eyre = "0.6.12"
 fastrand = "2.3.0"
 thiserror = "2.0.12"
-color-eyre = { version = "0.6.5", default-features = false }
 
 # Async
 tokio = { version = "1.41.1", features = ["macros", "rt-multi-thread", "fs"], default-features = false }
 futures = "0.3.31"
-arc-swap = "1.7.1"
 
 # Data
 reqwest = { version = "0.12.9", features = ["stream"] }
@@ -46,7 +44,6 @@ dirs = "6.0.0"
 
 # Misc
 convert_case = "0.8.0"
-lazy_static = "1.5.0"
 url = "2.5.4"
 unicode-segmentation = "1.12.0"
 

README.md

@@ -5,6 +5,24 @@ It'll do this as simply as it can: no albums, no ads, just lofi.
 
 ![example image](media/example1.png)
 
+## The Rewrite
+
+This branch serves as a rewrite for lowfi. The main focus is to make the code more
+maintainable. This includes such things as:
+
+* Replacing `Mutex` & `Arc` with channels, massively improving performance.
+* More clearly handling tracks in different phases of loading, instead of having
+a mess of different structs.
+* Making the UI code cleaner and easier to follow.
+* Rethinking input & control of the player, especially with MPRIS in mind.
+* Making track loading simpler and more consistent.
+
+This is an *internal rewrite*, and the goal is to retain every single feature.
+If there is a feature present in the original version of lowfi that is not present
+in the rewrite, then it is a bug and must be implemented.
+
+Currently, it is in an extremely early and non-functional state.
+
 ## Disclaimer
 
 As of the 1.7.0 version of lowfi, **all** of the audio files embedded

src/audio.rs

@@ -1,7 +1,7 @@
 /// This gets the output stream while also shutting up alsa with [libc].
 /// Uses raw libc calls, and therefore is functional only on Linux.
 #[cfg(target_os = "linux")]
-pub fn silent_get_output_stream() -> eyre::Result<rodio::OutputStream, crate::player::Error> {
+pub fn silent_get_output_stream() -> eyre::Result<rodio::OutputStream, crate::Error> {
     use libc::freopen;
     use rodio::OutputStreamBuilder;
     use std::ffi::CString;
@@ -37,4 +37,4 @@ pub fn silent_get_output_stream() -> eyre::Result<rodio::OutputStream, crate::pl
     }
 
     Ok(stream)
-}
+}

src/download.rs

@@ -0,0 +1,27 @@
+use tokio::sync::mpsc::{self, Receiver, Sender};
+
+pub struct Downloader {
+    /// TODO: Actually have a track type here.
+    queue: Receiver<()>,
+    handle: crate::Handle,
+}
+
+impl Downloader {
+    async fn downloader(tx: Sender<()>) -> crate::Result<()> {
+        
+        // todo
+        Ok(())
+    }
+
+    pub async fn init(buffer_size: usize) -> Self {
+        let (tx, rx) = mpsc::channel(buffer_size);
+        Self {
+            queue: rx,
+            handle: tokio::spawn(Self::downloader(tx)),
+        }
+    }
+}
+
+pub async fn downloader() {
+
+}

src/error.rs

@@ -0,0 +1,88 @@
+use tokio::sync::mpsc;
+
+pub type Result<T> = std::result::Result<T, Error>;
+#[derive(Debug, thiserror::Error)]
+pub enum Kind {
+    #[error("unable to fetch data: {0}")]
+    Request(#[from] reqwest::Error),
+
+    #[error("C string null error: {0}")]
+    FfiNull(#[from] std::ffi::NulError),
+
+    #[error("audio playing error: {0}")]
+    Rodio(#[from] rodio::StreamError),
+
+    #[error("couldn't send internal message: {0}")]
+    Send(#[from] mpsc::error::SendError<crate::Message>),
+}
+
+#[derive(Debug, Default)]
+pub struct Context {
+    track: Option<String>,
+}
+
+impl std::fmt::Display for Context {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(track) = &self.track {
+            write!(f, " ")?;
+            write!(f, "(track: {track})")?;
+        }
+        
+        Ok(())
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("{kind}{context}")]
+pub struct Error {
+    pub context: Context,
+
+    #[source]
+    pub kind: Kind,
+}
+
+impl<T, E> From<(T, E)> for Error
+where
+    T: Into<String>,
+    Kind: From<E>,
+{
+    fn from((track, err): (T, E)) -> Self {
+        Self {
+            context: Context { track: Some(track.into()) },
+            kind: Kind::from(err),
+        }
+    }
+}
+
+impl<E> From<E> for Error
+where
+    Kind: From<E>,
+{
+    fn from(err: E) -> Self {
+        Self {
+            context: Context::default(),
+            kind: Kind::from(err),
+        }
+    }
+}
+
+pub trait WithContextExt<T> {
+    fn context(self, name: impl Into<String>) -> std::result::Result<T, Error>;
+}
+
+impl<T, E> WithContextExt<T> for std::result::Result<T, E>
+where
+    (String, E): Into<Error>,
+    E: Into<Kind>,
+{
+    fn context(self, name: impl Into<String>) -> std::result::Result<T, Error> {
+        self.map_err(|e| {
+            let error = match e.into() {
+                Kind::Request(error) => Kind::Request(error.without_url()),
+                kind => kind,
+            };
+
+            (name.into(), error).into()
+        })
+    }
+}

src/main.rs

@@ -1,111 +1,52 @@
-//! An extremely simple lofi player.
+pub mod error;
+use crate::{download::Downloader, ui::UI};
+pub use error::{Error, Result};
+pub mod message;
+pub mod ui;
+pub use message::Message;
+use tokio::sync::mpsc::{self, Receiver};
+pub mod audio;
+pub mod download;
 
-#![warn(clippy::all, clippy::pedantic, clippy::nursery)]
+pub type Handle = tokio::task::JoinHandle<crate::Result<()>>;
 
-use clap::{Parser, Subcommand};
+pub struct Player {
-use std::path::PathBuf;
+    ui: UI,
-
+    downloader: Downloader,
-mod messages;
+    sink: rodio::Sink,
-mod play;
+    stream: rodio::OutputStream,
-mod player;
+    rx: Receiver<crate::Message>,
-mod tracks;
-
-#[allow(clippy::all, clippy::pedantic, clippy::nursery, clippy::restriction)]
-#[cfg(feature = "scrape")]
-mod scrapers;
-
-#[cfg(feature = "scrape")]
-use crate::scrapers::Source;
-
-/// An extremely simple lofi player.
-#[derive(Parser, Clone)]
-#[command(about, version)]
-#[allow(clippy::struct_excessive_bools)]
-struct Args {
-    /// Use an alternate terminal screen.
-    #[clap(long, short)]
-    alternate: bool,
-
-    /// Hide the bottom control bar.
-    #[clap(long, short)]
-    minimalist: bool,
-
-    /// Exclude borders in UI.
-    #[clap(long, short)]
-    borderless: bool,
-
-    /// Start lowfi paused.
-    #[clap(long, short)]
-    paused: bool,
-
-    /// FPS of the UI.
-    #[clap(long, short, default_value_t = 12)]
-    fps: u8,
-
-    /// Timeout in seconds for music downloads.
-    #[clap(long, default_value_t = 3)]
-    timeout: u64,
-
-    /// Include ALSA & other logs.
-    #[clap(long, short)]
-    debug: bool,
-
-    /// Width of the player, from 0 to 32.
-    #[clap(long, short, default_value_t = 3)]
-    width: usize,
-
-    /// Use a custom track list
-    #[clap(long, short, alias = "list", alias = "tracks", short_alias = 'l')]
-    track_list: Option<String>,
-
-    /// Internal song buffer size.
-    #[clap(long, short = 's', alias = "buffer", default_value_t = 5)]
-    buffer_size: usize,
-
-    /// The command that was ran.
-    /// This is [None] if no command was specified.
-    #[command(subcommand)]
-    command: Option<Commands>,
 }
 
-/// Defines all of the extra commands lowfi can run.
+impl Player {
-#[derive(Subcommand, Clone)]
+    pub async fn init() -> crate::Result<Self> {
-enum Commands {
+        #[cfg(target_os = "linux")]
-    /// Scrapes a music source for files.
+        let mut stream = audio::silent_get_output_stream()?;
-    #[cfg(feature = "scrape")]
+        #[cfg(not(target_os = "linux"))]
-    Scrape {
+        let mut stream = rodio::OutputStreamBuilder::open_default_stream()?;
-        // The source to scrape from.
-        source: scrapers::Source,
-    },
-}
 
-/// Gets lowfi's data directory.
+        stream.log_on_drop(false);
-pub fn data_dir() -> eyre::Result<PathBuf, player::Error> {
+        let sink = rodio::Sink::connect_new(stream.mixer());
-    let dir = dirs::data_dir()
+        let (tx, rx) = mpsc::channel(8);
-        .ok_or(player::Error::DataDir)?
-        .join("lowfi");
 
-    Ok(dir)
+        Ok(Self {
+            downloader: Downloader::init(5).await,
+            ui: UI::init(tx).await,
+            rx,
+            sink,
+            stream,
+        })
+    }
 }
 
 #[tokio::main]
-async fn main() -> eyre::Result<()> {
+pub async fn main() -> crate::Result<()> {
-    color_eyre::install()?;
+    let mut player: Player = Player::init().await?;
-
+    player.ui.render(ui::Render { track: "test".to_owned() }).await?;
-    let cli = Args::parse();
+    
-
+    while let Some(message) = player.rx.recv().await {
-    if let Some(command) = cli.command {
+        if message == Message::Quit { break };
-        match command {
+    }
-            #[cfg(feature = "scrape")]
-            Commands::Scrape { source } => match source {
-                Source::Archive => scrapers::archive::scrape().await?,
-                Source::Lofigirl => scrapers::lofigirl::scrape().await?,
-                Source::Chillhop => scrapers::chillhop::scrape().await?,
-            },
-        }
-    } else {
-        play::play(cli).await?;
-    };
 
     Ok(())
 }

src/message.rs

@@ -1,18 +1,14 @@
-/// Handles communication between the frontend & audio player.
+use crate::ui;
-#[derive(PartialEq, Debug, Clone, Copy)]
+
+/// Handles communication between different parts of the program.
+#[derive(PartialEq, Debug, Clone)]
 pub enum Message {
+    /// Sent to update the UI with new information.
+    Render(ui::Render),
+
     /// Notifies the audio server that it should update the track.
     Next,
 
-    /// Special in that this isn't sent in a "client to server" sort of way,
-    /// but rather is sent by a child of the server when a song has not only
-    /// been requested but also downloaded aswell.
-    NewSong,
-
-    /// This signal is only sent if a track timed out. In that case,
-    /// lowfi will try again and again to retrieve the track.
-    TryAgain,
-
     /// Similar to Next, but specific to the first track.
     Init,
 
@@ -34,4 +30,4 @@ pub enum Message {
 
     /// Quits gracefully.
     Quit,
-}
+}

src/play.rs

@@ -1,78 +0,0 @@
-//! Responsible for the basic initialization & shutdown of the audio server & frontend.
-
-use crossterm::cursor::Show;
-use crossterm::event::PopKeyboardEnhancementFlags;
-use crossterm::terminal::{self, Clear, ClearType};
-use std::io::{stdout, IsTerminal};
-use std::process::exit;
-use std::sync::Arc;
-use std::{env, panic};
-use tokio::{sync::mpsc, task};
-
-use crate::messages::Message;
-use crate::player::persistent_volume::PersistentVolume;
-use crate::player::Player;
-use crate::player::{self, ui};
-use crate::Args;
-
-/// Initializes the audio server, and then safely stops
-/// it when the frontend quits.
-pub async fn play(args: Args) -> eyre::Result<(), player::Error> {
-    // TODO: This isn't a great way of doing things,
-    // but it's better than vanilla behaviour at least.
-    let eyre_hook = panic::take_hook();
-
-    panic::set_hook(Box::new(move |x| {
-        let mut lock = stdout().lock();
-        crossterm::execute!(
-            lock,
-            Clear(ClearType::FromCursorDown),
-            Show,
-            PopKeyboardEnhancementFlags
-        )
-        .unwrap();
-        terminal::disable_raw_mode().unwrap();
-
-        eyre_hook(x);
-        exit(1)
-    }));
-
-    // Actually initializes the player.
-    // Stream kept here in the master thread to keep it alive.
-    let (player, stream) = Player::new(&args).await?;
-    let player = Arc::new(player);
-
-    // Initialize the UI, as well as the internal communication channel.
-    let (tx, rx) = mpsc::channel(8);
-    let ui = if stdout().is_terminal() && !(env::var("LOWFI_DISABLE_UI") == Ok("1".to_owned())) {
-        Some(task::spawn(ui::start(
-            Arc::clone(&player),
-            tx.clone(),
-            args.clone(),
-        )))
-    } else {
-        None
-    };
-
-    // Sends the player an "init" signal telling it to start playing a song straight away.
-    tx.send(Message::Init).await?;
-
-    // Actually starts the player.
-    Player::play(Arc::clone(&player), tx.clone(), rx, args.debug).await?;
-
-    // Save the volume.txt file for the next session.
-    PersistentVolume::save(player.sink.volume())
-        .await
-        .map_err(player::Error::PersistentVolumeSave)?;
-
-    // Save the bookmarks for the next session.
-    player.bookmarks.save().await?;
-
-    drop(stream);
-    player.sink.stop();
-    if let Some(x) = ui {
-        x.abort();
-    }
-
-    Ok(())
-}

src/player.rs

@@ -1,314 +0,0 @@
-//! Responsible for playing & queueing audio.
-//! This also has the code for the underlying
-//! audio server which adds new tracks.
-
-use std::{collections::VecDeque, sync::Arc, time::Duration};
-
-use arc_swap::ArcSwapOption;
-use atomic_float::AtomicF32;
-use downloader::Downloader;
-use reqwest::Client;
-use rodio::{OutputStream, OutputStreamBuilder, Sink};
-use tokio::{
-    select,
-    sync::{
-        mpsc::{Receiver, Sender},
-        RwLock,
-    },
-    task,
-};
-
-#[cfg(feature = "mpris")]
-use mpris_server::{PlaybackStatus, PlayerInterface, Property};
-
-use crate::{
-    messages::Message,
-    player::{self, bookmark::Bookmarks, persistent_volume::PersistentVolume},
-    tracks::{self, list::List},
-    Args,
-};
-
-pub mod audio;
-pub mod bookmark;
-pub mod downloader;
-pub mod error;
-pub mod persistent_volume;
-pub mod queue;
-pub mod ui;
-
-pub use error::Error;
-
-#[cfg(feature = "mpris")]
-pub mod mpris;
-
-/// Main struct responsible for queuing up & playing tracks.
-// TODO: Consider refactoring [Player] from being stored in an [Arc], into containing many smaller [Arc]s.
-// TODO: In other words, this would change the type from `Arc<Player>` to just `Player`.
-// TODO:
-// TODO: This is conflicting, since then it'd clone ~10 smaller [Arc]s
-// TODO: every single time, which could be even worse than having an
-// TODO: [Arc] of an [Arc] in some cases (Like with [Sink] & [Client]).
-pub struct Player {
-    /// [rodio]'s [`Sink`] which can control playback.
-    pub sink: Sink,
-
-    /// The internal buffer size.
-    pub buffer_size: usize,
-
-    /// The [`TrackInfo`] of the current track.
-    /// This is [`None`] when lowfi is buffering/loading.
-    current: ArcSwapOption<tracks::Info>,
-
-    /// The current progress for downloading tracks, if
-    /// `current` is None.
-    progress: AtomicF32,
-
-    /// The tracks, which is a [`VecDeque`] that holds
-    /// *undecoded* [Track]s.
-    ///
-    /// This is populated specifically by the [Downloader].
-    tracks: RwLock<VecDeque<tracks::QueuedTrack>>,
-
-    /// The bookmarks, which are saved on quit.
-    pub bookmarks: Bookmarks,
-
-    /// The timeout for track downloads, as a [Duration].
-    timeout: Duration,
-
-    /// The actual list of tracks to be played.
-    list: List,
-
-    /// The initial volume level.
-    volume: PersistentVolume,
-
-    /// The web client, which can contain a `UserAgent` & some
-    /// settings that help lowfi work more effectively.
-    client: Client,
-}
-
-impl Player {
-    /// Just a shorthand for setting `current`.
-    fn set_current(&self, info: tracks::Info) {
-        self.current.store(Some(Arc::new(info)));
-    }
-
-    /// A shorthand for checking if `self.current` is [Some].
-    pub fn current_exists(&self) -> bool {
-        self.current.load().is_some()
-    }
-
-    /// Sets the volume of the sink, and also clamps the value to avoid negative/over 100% values.
-    pub fn set_volume(&self, volume: f32) {
-        self.sink.set_volume(volume.clamp(0.0, 1.0));
-    }
-
-    /// Initializes the entire player, including audio devices & sink.
-    ///
-    /// This also will load the track list & persistent volume.
-    pub async fn new(args: &Args) -> eyre::Result<(Self, OutputStream), player::Error> {
-        // Load the bookmarks.
-        let bookmarks = Bookmarks::load().await?;
-
-        // Load the volume file.
-        let volume = PersistentVolume::load()
-            .await
-            .map_err(player::Error::PersistentVolumeLoad)?;
-
-        // Load the track list.
-        let list = List::load(args.track_list.as_ref())
-            .await
-            .map_err(player::Error::TrackListLoad)?;
-
-        // We should only shut up alsa forcefully on Linux if we really have to.
-        #[cfg(target_os = "linux")]
-        let mut stream = if !args.alternate && !args.debug {
-            audio::silent_get_output_stream()?
-        } else {
-            OutputStreamBuilder::open_default_stream()?
-        };
-
-        #[cfg(not(target_os = "linux"))]
-        let mut stream = OutputStreamBuilder::open_default_stream()?;
-
-        stream.log_on_drop(false); // Frankly, this is a stupid feature. Stop shoving your crap into my beloved stderr!!!
-        let sink = Sink::connect_new(stream.mixer());
-
-        if args.paused {
-            sink.pause();
-        }
-
-        let client = Client::builder()
-            .user_agent(concat!(
-                env!("CARGO_PKG_NAME"),
-                "/",
-                env!("CARGO_PKG_VERSION")
-            ))
-            .timeout(Duration::from_secs(args.timeout * 5))
-            .build()?;
-
-        let player = Self {
-            tracks: RwLock::new(VecDeque::with_capacity(args.buffer_size)),
-            buffer_size: args.buffer_size,
-            current: ArcSwapOption::new(None),
-            progress: AtomicF32::new(0.0),
-            timeout: Duration::from_secs(args.timeout),
-            bookmarks,
-            client,
-            sink,
-            volume,
-            list,
-        };
-
-        Ok((player, stream))
-    }
-
-    /// This is the main "audio server".
-    ///
-    /// `rx` & `tx` are used to communicate with it, for example when to
-    /// skip tracks or pause.
-    ///
-    /// This will also initialize a [Downloader] as well as an MPRIS server if enabled.
-    /// The [Downloader]s internal buffer size is determined by `buf_size`.
-    pub async fn play(
-        player: Arc<Self>,
-        tx: Sender<Message>,
-        mut rx: Receiver<Message>,
-        debug: bool,
-    ) -> eyre::Result<(), player::Error> {
-        // Initialize the mpris player.
-        //
-        // We're initializing here, despite MPRIS being a "user interface",
-        // since we need to be able to *actively* write new information to MPRIS
-        // specifically when it occurs, unlike the UI which passively reads the
-        // information each frame. Blame MPRIS, not me.
-        #[cfg(feature = "mpris")]
-        let mpris = mpris::Server::new(Arc::clone(&player), tx.clone())
-            .await
-            .inspect_err(|x| {
-                dbg!(x);
-            })?;
-
-        // `itx` is used to notify the `Downloader` when it needs to download new tracks.
-        let downloader = Downloader::new(Arc::clone(&player));
-        let (itx, downloader) = downloader.start(debug);
-
-        // Start buffering tracks immediately.
-        Downloader::notify(&itx).await?;
-
-        // Set the initial sink volume to the one specified.
-        player.set_volume(player.volume.float());
-
-        // Whether the last signal was a `NewSong`. This is helpful, since we
-        // only want to autoplay if there hasn't been any manual intervention.
-        //
-        // In other words, this will be `true` after a new track has been fully
-        // loaded and it'll be `false` if a track is still currently loading.
-        let mut new = false;
-
-        loop {
-            let clone = Arc::clone(&player);
-
-            let msg = select! {
-                biased;
-
-                Some(x) = rx.recv() => x,
-                // This future will finish only at the end of the current track.
-                // The condition is a kind-of hack which gets around the quirks
-                // of `sleep_until_end`.
-                //
-                // That's because `sleep_until_end` will return instantly if the sink
-                // is uninitialized. That's why we put a check to make sure that the last
-                // signal we got was `NewSong`, since we shouldn't start waiting for the
-                // song to be over until it has actually started.
-                //
-                // It's also important to note that the condition is only checked at the
-                // beginning of the loop, not throughout.
-                Ok(()) = task::spawn_blocking(move || clone.sink.sleep_until_end()),
-                        if new => Message::Next,
-            };
-
-            match msg {
-                Message::Next | Message::Init | Message::TryAgain => {
-                    // We manually skipped, so we shouldn't actually wait for the song
-                    // to be over until we recieve the `NewSong` signal.
-                    new = false;
-
-                    // This basically just prevents `Next` while a song is still currently loading.
-                    if msg == Message::Next && !player.current_exists() {
-                        continue;
-                    }
-
-                    // Handle the rest of the signal in the background,
-                    // as to not block the main audio server thread.
-                    task::spawn(Self::next(
-                        Arc::clone(&player),
-                        itx.clone(),
-                        tx.clone(),
-                        debug,
-                    ));
-                }
-                Message::Play => {
-                    player.sink.play();
-
-                    #[cfg(feature = "mpris")]
-                    mpris.playback(PlaybackStatus::Playing).await?;
-                }
-                Message::Pause => {
-                    player.sink.pause();
-
-                    #[cfg(feature = "mpris")]
-                    mpris.playback(PlaybackStatus::Paused).await?;
-                }
-                Message::PlayPause => {
-                    if player.sink.is_paused() {
-                        player.sink.play();
-                    } else {
-                        player.sink.pause();
-                    }
-
-                    #[cfg(feature = "mpris")]
-                    mpris
-                        .playback(mpris.player().playback_status().await?)
-                        .await?;
-                }
-                Message::ChangeVolume(change) => {
-                    player.set_volume(player.sink.volume() + change);
-
-                    #[cfg(feature = "mpris")]
-                    mpris
-                        .changed(vec![Property::Volume(player.sink.volume().into())])
-                        .await?;
-                }
-                // This basically just continues, but more importantly, it'll re-evaluate
-                // the select macro at the beginning of the loop.
-                // See the top section to find out why this matters.
-                Message::NewSong => {
-                    // We've recieved `NewSong`, so on the next loop iteration we'll
-                    // begin waiting for the song to be over in order to autoplay.
-                    new = true;
-
-                    #[cfg(feature = "mpris")]
-                    mpris
-                        .changed(vec![
-                            Property::Metadata(mpris.player().metadata().await?),
-                            Property::PlaybackStatus(mpris.player().playback_status().await?),
-                        ])
-                        .await?;
-
-                    continue;
-                }
-                Message::Bookmark => {
-                    let current = player.current.load();
-                    let current = current.as_ref().unwrap();
-
-                    player.bookmarks.bookmark(current).await?;
-                }
-                Message::Quit => break,
-            }
-        }
-
-        downloader.abort();
-
-        Ok(())
-    }
-}

src/player/bookmark.rs

@@ -1,107 +0,0 @@
-//! Module for handling saving, loading, and adding
-//! bookmarks.
-
-use std::path::PathBuf;
-use std::sync::atomic::AtomicBool;
-
-use tokio::sync::RwLock;
-use tokio::{fs, io};
-
-use crate::{data_dir, tracks};
-
-/// Errors that might occur while managing bookmarks.
-#[derive(Debug, thiserror::Error)]
-pub enum BookmarkError {
-    #[error("data directory not found")]
-    DataDir,
-
-    #[error("io failure")]
-    Io(#[from] io::Error),
-}
-
-/// Manages the bookmarks in the current player.
-pub struct Bookmarks {
-    /// The different entries in the bookmarks file.
-    entries: RwLock<Vec<String>>,
-
-    /// The internal bookmarked register, which keeps track
-    /// of whether a track is bookmarked or not.
-    ///
-    /// This is much more efficient than checking every single frame.
-    bookmarked: AtomicBool,
-}
-
-impl Bookmarks {
-    /// Gets the path of the bookmarks file.
-    pub async fn path() -> eyre::Result<PathBuf, BookmarkError> {
-        let data_dir = data_dir().map_err(|_| BookmarkError::DataDir)?;
-        fs::create_dir_all(data_dir.clone()).await?;
-
-        Ok(data_dir.join("bookmarks.txt"))
-    }
-
-    /// Loads bookmarks from the `bookmarks.txt` file.
-    pub async fn load() -> eyre::Result<Self, BookmarkError> {
-        let text = fs::read_to_string(Self::path().await?)
-            .await
-            .unwrap_or_default();
-
-        let lines: Vec<String> = text
-            .trim_start_matches("noheader")
-            .trim()
-            .lines()
-            .filter_map(|x| {
-                if x.is_empty() {
-                    None
-                } else {
-                    Some(x.to_string())
-                }
-            })
-            .collect();
-
-        Ok(Self {
-            entries: RwLock::new(lines),
-            bookmarked: AtomicBool::new(false),
-        })
-    }
-
-    // Saves the bookmarks to the `bookmarks.txt` file.
-    pub async fn save(&self) -> eyre::Result<(), BookmarkError> {
-        let text = format!("noheader\n{}", self.entries.read().await.join("\n"));
-        fs::write(Self::path().await?, text).await?;
-        Ok(())
-    }
-
-    /// Bookmarks a given track with a full path and optional custom name.
-    ///
-    /// Returns whether the track is now bookmarked, or not.
-    pub async fn bookmark(&self, track: &tracks::Info) -> eyre::Result<(), BookmarkError> {
-        let entry = track.to_entry();
-        let idx = self.entries.read().await.iter().position(|x| **x == entry);
-
-        if let Some(idx) = idx {
-            self.entries.write().await.remove(idx);
-        } else {
-            self.entries.write().await.push(entry);
-        };
-
-        self.bookmarked
-            .swap(idx.is_none(), std::sync::atomic::Ordering::Relaxed);
-
-        Ok(())
-    }
-
-    /// Returns whether a track is bookmarked or not by using the internal
-    /// bookmarked register.
-    pub fn bookmarked(&self) -> bool {
-        self.bookmarked.load(std::sync::atomic::Ordering::Relaxed)
-    }
-
-    /// Sets the internal bookmarked register by checking against
-    /// the current track's info.
-    pub async fn set_bookmarked(&self, track: &tracks::Info) {
-        let val = self.entries.read().await.contains(&track.to_entry());
-        self.bookmarked
-            .swap(val, std::sync::atomic::Ordering::Relaxed);
-    }
-}

src/player/downloader.rs

@@ -1,78 +0,0 @@
-//! Contains the [`Downloader`] struct.
-
-use std::{error::Error, sync::Arc};
-
-use tokio::{
-    sync::mpsc::{self, Receiver, Sender},
-    task::{self, JoinHandle},
-    time::sleep,
-};
-
-use super::Player;
-
-/// This struct is responsible for downloading tracks in the background.
-///
-/// This is not used for the first track or a track when the buffer is currently empty.
-pub struct Downloader {
-    /// The player for the downloader to download to & with.
-    player: Arc<Player>,
-
-    /// The internal reciever, which is used by the downloader to know
-    /// when to begin downloading more tracks.
-    rx: Receiver<()>,
-
-    /// A copy of the internal sender, which can be useful for keeping
-    /// track of it.
-    tx: Sender<()>,
-}
-
-impl Downloader {
-    /// Uses a sender recieved from [Sender] to notify the
-    /// download thread that it should resume downloading.
-    pub async fn notify(sender: &Sender<()>) -> Result<(), mpsc::error::SendError<()>> {
-        sender.send(()).await
-    }
-
-    /// Initializes the [Downloader].
-    ///
-    /// This also sends a [`Sender`] which can be used to notify
-    /// when the downloader needs to begin downloading more tracks.
-    pub fn new(player: Arc<Player>) -> Self {
-        let (tx, rx) = mpsc::channel(8);
-        Self { player, rx, tx }
-    }
-
-    /// Push a new, random track onto the internal buffer.
-    pub async fn push_buffer(&self, debug: bool) {
-        let data = self.player.list.random(&self.player.client, None).await;
-        match data {
-            Ok(track) => self.player.tracks.write().await.push_back(track),
-            Err(error) => {
-                if debug {
-                    panic!("{error} - {:?}", error.source())
-                }
-
-                if !error.is_timeout() {
-                    sleep(self.player.timeout).await;
-                }
-            }
-        }
-    }
-
-    /// Actually starts & consumes the [Downloader].
-    pub fn start(mut self, debug: bool) -> (Sender<()>, JoinHandle<()>) {
-        let tx = self.tx.clone();
-
-        let handle = task::spawn(async move {
-            // Loop through each update notification.
-            while self.rx.recv().await == Some(()) {
-                //  For each update notification, we'll push tracks until the buffer is completely full.
-                while self.player.tracks.read().await.len() < self.player.buffer_size {
-                    self.push_buffer(debug).await;
-                }
-            }
-        });
-
-        (tx, handle)
-    }
-}

src/player/error.rs

@@ -1,51 +0,0 @@
-use std::ffi::NulError;
-
-use crate::{messages::Message, player::bookmark::BookmarkError};
-use tokio::sync::mpsc::error::SendError;
-
-#[cfg(feature = "mpris")]
-use mpris_server::zbus::{self, fdo};
-
-/// Any errors which might occur when running or initializing the lowfi player.
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error("unable to load the persistent volume")]
-    PersistentVolumeLoad(eyre::Error),
-
-    #[error("unable to save the persistent volume")]
-    PersistentVolumeSave(eyre::Error),
-
-    #[error("sending internal message failed")]
-    Communication(#[from] SendError<Message>),
-
-    #[error("unable to load track list")]
-    TrackListLoad(eyre::Error),
-
-    #[error("interfacing with audio failed")]
-    Stream(#[from] rodio::StreamError),
-
-    #[error("NUL error, if you see this, something has gone VERY wrong")]
-    Nul(#[from] NulError),
-
-    #[error("unable to send or prepare network request")]
-    Reqwest(#[from] reqwest::Error),
-
-    #[cfg(feature = "mpris")]
-    #[error("mpris bus error")]
-    ZBus(#[from] zbus::Error),
-
-    // TODO: This has a terrible error message, mainly because I barely understand
-    // what this error even represents. What does fdo mean?!?!? Why, MPRIS!?!?
-    #[cfg(feature = "mpris")]
-    #[error("mpris fdo (zbus interface) error")]
-    Fdo(#[from] fdo::Error),
-
-    #[error("unable to notify downloader")]
-    DownloaderNotify(#[from] SendError<()>),
-
-    #[error("unable to find data directory")]
-    DataDir,
-
-    #[error("bookmarking load/unload failed")]
-    Bookmark(#[from] BookmarkError),
-}

src/player/mpris.rs

@@ -1,281 +0,0 @@
-//! Contains the code for the MPRIS server & other helper functions.
-
-use std::{env, process, sync::Arc};
-
-use mpris_server::{
-    zbus::{self, fdo, Result},
-    LoopStatus, Metadata, PlaybackRate, PlaybackStatus, PlayerInterface, Property, RootInterface,
-    Time, TrackId, Volume,
-};
-use tokio::sync::mpsc::Sender;
-
-use super::ui;
-use super::Message;
-
-const ERROR: fdo::Error = fdo::Error::Failed(String::new());
-
-/// The actual MPRIS player.
-pub struct Player {
-    /// A reference to the [`super::Player`] itself.
-    pub player: Arc<super::Player>,
-
-    /// The audio server sender, which is used to communicate with
-    /// the audio sender for skips and a few other inputs.
-    pub sender: Sender<Message>,
-}
-
-impl RootInterface for Player {
-    async fn raise(&self) -> fdo::Result<()> {
-        Err(ERROR)
-    }
-
-    async fn quit(&self) -> fdo::Result<()> {
-        self.sender
-            .send(Message::Quit)
-            .await
-            .map_err(|_error| ERROR)
-    }
-
-    async fn can_quit(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-
-    async fn fullscreen(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn set_fullscreen(&self, _: bool) -> Result<()> {
-        Ok(())
-    }
-
-    async fn can_set_fullscreen(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn can_raise(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn has_track_list(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn identity(&self) -> fdo::Result<String> {
-        Ok("lowfi".to_owned())
-    }
-
-    async fn desktop_entry(&self) -> fdo::Result<String> {
-        Ok("dev.talwat.lowfi".to_owned())
-    }
-
-    async fn supported_uri_schemes(&self) -> fdo::Result<Vec<String>> {
-        Ok(vec!["https".to_owned()])
-    }
-
-    async fn supported_mime_types(&self) -> fdo::Result<Vec<String>> {
-        Ok(vec!["audio/mpeg".to_owned()])
-    }
-}
-
-impl PlayerInterface for Player {
-    async fn next(&self) -> fdo::Result<()> {
-        self.sender
-            .send(Message::Next)
-            .await
-            .map_err(|_error| ERROR)
-    }
-
-    async fn previous(&self) -> fdo::Result<()> {
-        Err(ERROR)
-    }
-
-    async fn pause(&self) -> fdo::Result<()> {
-        self.sender
-            .send(Message::Pause)
-            .await
-            .map_err(|_error| ERROR)
-    }
-
-    async fn play_pause(&self) -> fdo::Result<()> {
-        self.sender
-            .send(Message::PlayPause)
-            .await
-            .map_err(|_error| ERROR)
-    }
-
-    async fn stop(&self) -> fdo::Result<()> {
-        self.pause().await
-    }
-
-    async fn play(&self) -> fdo::Result<()> {
-        self.sender
-            .send(Message::Play)
-            .await
-            .map_err(|_error| ERROR)
-    }
-
-    async fn seek(&self, _offset: Time) -> fdo::Result<()> {
-        Err(ERROR)
-    }
-
-    async fn set_position(&self, _track_id: TrackId, _position: Time) -> fdo::Result<()> {
-        Err(ERROR)
-    }
-
-    async fn open_uri(&self, _uri: String) -> fdo::Result<()> {
-        Err(ERROR)
-    }
-
-    async fn playback_status(&self) -> fdo::Result<PlaybackStatus> {
-        Ok(if !self.player.current_exists() {
-            PlaybackStatus::Stopped
-        } else if self.player.sink.is_paused() {
-            PlaybackStatus::Paused
-        } else {
-            PlaybackStatus::Playing
-        })
-    }
-
-    async fn loop_status(&self) -> fdo::Result<LoopStatus> {
-        Err(ERROR)
-    }
-
-    async fn set_loop_status(&self, _loop_status: LoopStatus) -> Result<()> {
-        Ok(())
-    }
-
-    async fn rate(&self) -> fdo::Result<PlaybackRate> {
-        Ok(self.player.sink.speed().into())
-    }
-
-    async fn set_rate(&self, rate: PlaybackRate) -> Result<()> {
-        self.player.sink.set_speed(rate as f32);
-        Ok(())
-    }
-
-    async fn shuffle(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-
-    async fn set_shuffle(&self, _shuffle: bool) -> Result<()> {
-        Ok(())
-    }
-
-    async fn metadata(&self) -> fdo::Result<Metadata> {
-        let metadata = self
-            .player
-            .current
-            .load()
-            .as_ref()
-            .map_or_else(Metadata::new, |track| {
-                let mut metadata = Metadata::builder()
-                    .title(track.display_name.clone())
-                    .album(self.player.list.name.clone())
-                    .build();
-
-                metadata.set_length(
-                    track
-                        .duration
-                        .map(|x| Time::from_micros(x.as_micros() as i64)),
-                );
-
-                metadata
-            });
-
-        Ok(metadata)
-    }
-
-    async fn volume(&self) -> fdo::Result<Volume> {
-        Ok(self.player.sink.volume().into())
-    }
-
-    async fn set_volume(&self, volume: Volume) -> Result<()> {
-        self.player.set_volume(volume as f32);
-        ui::flash_audio();
-
-        Ok(())
-    }
-
-    async fn position(&self) -> fdo::Result<Time> {
-        Ok(Time::from_micros(
-            self.player.sink.get_pos().as_micros() as i64
-        ))
-    }
-
-    async fn minimum_rate(&self) -> fdo::Result<PlaybackRate> {
-        Ok(0.2f64)
-    }
-
-    async fn maximum_rate(&self) -> fdo::Result<PlaybackRate> {
-        Ok(3.0f64)
-    }
-
-    async fn can_go_next(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-
-    async fn can_go_previous(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn can_play(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-
-    async fn can_pause(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-
-    async fn can_seek(&self) -> fdo::Result<bool> {
-        Ok(false)
-    }
-
-    async fn can_control(&self) -> fdo::Result<bool> {
-        Ok(true)
-    }
-}
-
-/// A struct which contains the MPRIS [Server], and has some helper functions
-/// to make it easier to work with.
-pub struct Server {
-    /// The inner MPRIS server.
-    inner: mpris_server::Server<Player>,
-}
-
-impl Server {
-    /// Shorthand to emit a `PropertiesChanged` signal, like when pausing/unpausing.
-    pub async fn changed(
-        &self,
-        properties: impl IntoIterator<Item = mpris_server::Property> + Send + Sync,
-    ) -> zbus::Result<()> {
-        self.inner.properties_changed(properties).await
-    }
-
-    /// Shorthand to emit a `PropertiesChanged` signal, specifically about playback.
-    pub async fn playback(&self, new: PlaybackStatus) -> zbus::Result<()> {
-        self.inner
-            .properties_changed(vec![Property::PlaybackStatus(new)])
-            .await
-    }
-
-    /// Shorthand to get the inner mpris player object.
-    pub fn player(&self) -> &Player {
-        self.inner.imp()
-    }
-
-    /// Creates a new MPRIS server.
-    pub async fn new(
-        player: Arc<super::Player>,
-        sender: Sender<Message>,
-    ) -> eyre::Result<Self, zbus::Error> {
-        let suffix = if env::var("LOWFI_FIXED_MPRIS_NAME").is_ok_and(|x| x == "1") {
-            String::from("lowfi")
-        } else {
-            format!("lowfi.{}.instance{}", player.list.name, process::id())
-        };
-
-        let server = mpris_server::Server::new(&suffix, Player { player, sender }).await?;
-
-        Ok(Self { inner: server })
-    }
-}

src/player/persistent_volume.rs

@@ -1,70 +0,0 @@
-use eyre::eyre;
-use std::path::PathBuf;
-use tokio::fs;
-
-/// This is the representation of the persistent volume,
-/// which is loaded at startup and saved on shutdown.
-#[derive(Clone, Copy)]
-pub struct PersistentVolume {
-    /// The volume, as a percentage.
-    inner: u16,
-}
-
-impl PersistentVolume {
-    /// Retrieves the config directory.
-    async fn config() -> eyre::Result<PathBuf> {
-        let config = dirs::config_dir()
-            .ok_or_else(|| eyre!("Couldn't find config directory"))?
-            .join(PathBuf::from("lowfi"));
-
-        if !config.exists() {
-            fs::create_dir_all(&config).await?;
-        }
-
-        Ok(config)
-    }
-
-    /// Returns the volume as a float from 0 to 1.
-    pub fn float(self) -> f32 {
-        f32::from(self.inner) / 100.0
-    }
-
-    /// Loads the [`PersistentVolume`] from [`dirs::config_dir()`].
-    pub async fn load() -> eyre::Result<Self> {
-        let config = Self::config().await?;
-        let volume = config.join(PathBuf::from("volume.txt"));
-
-        // Basically just read from the volume file if it exists, otherwise return 100.
-        let volume = if volume.exists() {
-            let contents = fs::read_to_string(volume).await?;
-            let trimmed = contents.trim();
-            let stripped = trimmed.strip_suffix("%").unwrap_or(trimmed);
-            stripped
-                .parse()
-                .map_err(|_error| eyre!("volume.txt file is invalid"))?
-        } else {
-            fs::write(&volume, "100").await?;
-            100u16
-        };
-
-        Ok(Self { inner: volume })
-    }
-
-    /// Saves `volume` to `volume.txt`.
-    pub async fn save(volume: f32) -> eyre::Result<()> {
-        let config = Self::config().await?;
-        let path = config.join(PathBuf::from("volume.txt"));
-
-        // Already rounded & absolute, therefore this should be safe.
-        #[expect(
-            clippy::as_conversions,
-            clippy::cast_sign_loss,
-            clippy::cast_possible_truncation
-        )]
-        let percentage = (volume * 100.0).abs().round() as u16;
-
-        fs::write(path, percentage.to_string()).await?;
-
-        Ok(())
-    }
-}

src/player/queue.rs

@@ -1,88 +0,0 @@
-use std::{
-    error::Error,
-    sync::{atomic::Ordering, Arc},
-};
-use tokio::{sync::mpsc::Sender, time::sleep};
-
-use crate::{
-    messages::Message,
-    player::{downloader::Downloader, Player},
-    tracks,
-};
-
-impl Player {
-    /// Fetches the next track from the queue, or a random track if the queue is empty.
-    /// This will also set the current track to the fetched track's info.
-    async fn fetch(&self) -> Result<tracks::DecodedTrack, tracks::Error> {
-        // TODO: Consider replacing this with `unwrap_or_else` when async closures are stablized.
-        let track = self.tracks.write().await.pop_front();
-        let track = if let Some(track) = track {
-            track
-        } else {
-            // If the queue is completely empty, then fallback to simply getting a new track.
-            // This is relevant particularly at the first song.
-
-            // Serves as an indicator that the queue is "loading".
-            // We're doing it here so that we don't get the "loading" display
-            // for only a frame in the other case that the buffer is not empty.
-            self.current.store(None);
-            self.progress.store(0.0, Ordering::Relaxed);
-            self.list.random(&self.client, Some(&self.progress)).await?
-        };
-
-        let decoded = track.decode()?;
-
-        // Set the current track.
-        self.set_current(decoded.info.clone());
-
-        Ok(decoded)
-    }
-
-    /// Gets, decodes, and plays the next track in the queue while also handling the downloader.
-    ///
-    /// This functions purpose is to be called in the background, so that when the audio server recieves a
-    /// `Next` signal it will still be able to respond to other signals while it's loading.
-    ///
-    /// This also sends the either a `NewSong` or `TryAgain` signal to `tx`.
-    pub async fn next(
-        player: Arc<Self>,
-        itx: Sender<()>,
-        tx: Sender<Message>,
-        debug: bool,
-    ) -> eyre::Result<()> {
-        // Stop the sink.
-        player.sink.stop();
-
-        let track = player.fetch().await;
-
-        match track {
-            Ok(track) => {
-                // Start playing the new track.
-                player.sink.append(track.data);
-
-                // Set whether it's bookmarked.
-                player.bookmarks.set_bookmarked(&track.info).await;
-
-                // Notify the background downloader that there's an empty spot
-                // in the buffer.
-                Downloader::notify(&itx).await?;
-
-                // Notify the audio server that the next song has actually been downloaded.
-                tx.send(Message::NewSong).await?;
-            }
-            Err(error) => {
-                if debug {
-                    panic!("{error} - {:?}", error.source())
-                }
-
-                if !error.is_timeout() {
-                    sleep(player.timeout).await;
-                }
-
-                tx.send(Message::TryAgain).await?;
-            }
-        };
-
-        Ok(())
-    }
-}

src/player/ui.rs

@@ -1,332 +0,0 @@
-//! The module which manages all user interface, including inputs.
-
-#![allow(
-    clippy::as_conversions,
-    clippy::cast_sign_loss,
-    clippy::cast_precision_loss,
-    clippy::cast_possible_truncation,
-    reason = "the ui is full of these because of various layout & positioning aspects, and for a simple music player making all casts safe is not worth the effort"
-)]
-
-use std::{
-    fmt::Write as _,
-    io::{stdout, Stdout},
-    process::{Command, Output},
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
-    time::Duration,
-};
-
-use crate::Args;
-
-use crossterm::{
-    cursor::{Hide, MoveTo, MoveToColumn, MoveUp, Show},
-    event::{KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags},
-    style::{Print, Stylize as _},
-    terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
-};
-
-use eyre::Context;
-use lazy_static::lazy_static;
-use thiserror::Error;
-use tokio::{
-    sync::mpsc::Sender,
-    task,
-    time::sleep,
-};
-use unicode_segmentation::UnicodeSegmentation;
-
-use super::Player;
-use crate::messages::Message;
-
-mod components;
-mod input;
-
-/// The error type for the UI, which is used to handle errors that occur
-/// while drawing the UI or handling input.
-#[derive(Debug, Error)]
-pub enum UIError {
-    #[error("unable to convert number")]
-    Conversion(#[from] std::num::TryFromIntError),
-
-    #[error("unable to write output")]
-    Write(#[from] std::io::Error),
-
-    #[error("sending message to backend from ui failed")]
-    Communication(#[from] tokio::sync::mpsc::error::SendError<Message>),
-}
-
-/// How long the audio bar will be visible for when audio is adjusted.
-/// This is in frames.
-const AUDIO_BAR_DURATION: usize = 10;
-
-lazy_static! {
-    /// The volume timer, which controls how long the volume display should
-    /// show up and when it should disappear.
-    ///
-    /// When this is 0, it means that the audio bar shouldn't be displayed.
-    /// To make it start counting, you need to set it to 1.
-    static ref VOLUME_TIMER: AtomicUsize = AtomicUsize::new(0);
-}
-
-/// Sets the volume timer to one, effectively flashing the audio display in lowfi's UI.
-///
-/// The amount of frames the audio display is visible for is determined by [`AUDIO_BAR_DURATION`].
-pub fn flash_audio() {
-    VOLUME_TIMER.store(1, Ordering::Relaxed);
-}
-
-/// Represents an abstraction for drawing the actual lowfi window itself.
-///
-/// The main purpose of this struct is just to add the fancy border,
-/// as well as clear the screen before drawing.
-pub struct Window {
-    /// Whether or not to include borders in the output.
-    borderless: bool,
-
-    /// The top & bottom borders, which are here since they can be
-    /// prerendered, as they don't change from window to window.
-    ///
-    /// If the option to not include borders is set, these will just be empty [String]s.
-    borders: [String; 2],
-
-    /// The width of the window.
-    width: usize,
-
-    /// The output, currently just an [`Stdout`].
-    out: Stdout,
-}
-
-impl Window {
-    pub fn top(width: usize) -> String {
-        let output = Command::new("date")
-            .arg("+%H:%M:%S")
-            .output()
-            .wrap_err("couldn't run the command")
-            .and_then(|x: Output| String::from_utf8(x.stdout).wrap_err("invalid command output"))
-            .unwrap_or_default();
-
-        let output = output.trim();
-        let len = output.len().min(width);
-        let output = &output[..len];
-
-        let pad = "─".repeat((width-1).saturating_sub(output.len()));
-        let top = format!("┌─ {} {}┐", output, pad);
-
-        return top;
-    }
-
-    /// Initializes a new [Window].
-    ///
-    /// * `width` - Width of the windows.
-    /// * `borderless` - Whether to include borders in the window, or not.
-    pub fn new(width: usize, borderless: bool) -> Self {
-        let borders = if borderless {
-            [String::new(), String::new()]
-        } else {
-            let middle = "─".repeat(width + 2);
-
-            [Self::top(width), format!("└{middle}┘")]
-        };
-
-        Self {
-            borders,
-            borderless,
-            width,
-            out: stdout(),
-        }
-    }
-
-    /// Actually draws the window, with each element in `content` being on a new line.
-    pub fn draw(&mut self, content: Vec<String>, space: bool) -> eyre::Result<(), UIError> {
-        self.borders[0] = Self::top(self.width);
-        let len: u16 = content.len().try_into()?;
-
-        // Note that this will have a trailing newline, which we use later.
-        let menu: String = content.into_iter().fold(String::new(), |mut output, x| {
-            // Horizontal Padding & Border
-            let padding = if self.borderless { " " } else { "│" };
-            let space = if space {
-                " ".repeat(self.width.saturating_sub(x.graphemes(true).count()))
-            } else {
-                String::new()
-            };
-            write!(output, "{padding} {}{space} {padding}\r\n", x.reset()).unwrap();
-
-            output
-        });
-
-        // We're doing this because Windows is stupid and can't stand
-        // writing to the last line repeatedly.
-        #[cfg(windows)]
-        let (height, suffix) = (len + 2, "\r\n");
-        #[cfg(not(windows))]
-        let (height, suffix) = (len + 1, "");
-
-        // There's no need for another newline after the main menu content, because it already has one.
-        let rendered = format!("{}\r\n{menu}{}{suffix}", self.borders[0], self.borders[1]);
-
-        crossterm::execute!(
-            self.out,
-            Clear(ClearType::FromCursorDown),
-            MoveToColumn(0),
-            Print(rendered),
-            MoveToColumn(0),
-            MoveUp(height),
-        )?;
-
-        Ok(())
-    }
-}
-
-/// The code for the terminal interface itself.
-///
-/// * `minimalist` - All this does is hide the bottom control bar.
-async fn interface(
-    player: Arc<Player>,
-    minimalist: bool,
-    borderless: bool,
-    debug: bool,
-    fps: u8,
-    width: usize,
-) -> eyre::Result<(), UIError> {
-    let mut window = Window::new(width, borderless || debug);
-
-    loop {
-        // Load `current` once so that it doesn't have to be loaded over and over
-        // again by different UI components.
-        let current = player.current.load();
-        let current = current.as_ref();
-
-        let action = components::action(&player, current, width);
-
-        let volume = player.sink.volume();
-        let percentage = format!("{}%", (volume * 100.0).round().abs());
-
-        let timer = VOLUME_TIMER.load(Ordering::Relaxed);
-        let middle = match timer {
-            0 => components::progress_bar(&player, current, width - 16),
-            _ => components::audio_bar(volume, &percentage, width - 17),
-        };
-
-        if timer > 0 && timer <= AUDIO_BAR_DURATION {
-            // We'll keep increasing the timer until it eventually hits `AUDIO_BAR_DURATION`.
-            VOLUME_TIMER.fetch_add(1, Ordering::Relaxed);
-        } else {
-            // If enough time has passed, we'll reset it back to 0.
-            VOLUME_TIMER.store(0, Ordering::Relaxed);
-        }
-
-        let controls = components::controls(width);
-
-        let menu = match (minimalist, debug, player.current.load().as_ref()) {
-            (true, _, _) => vec![action, middle],
-            (false, true, Some(x)) => vec![x.full_path.clone(), action, middle, controls],
-            _ => vec![action, middle, controls],
-        };
-
-        window.draw(menu, false)?;
-
-        let delta = 1.0 / f32::from(fps);
-        sleep(Duration::from_secs_f32(delta)).await;
-    }
-}
-
-/// Represents the terminal environment, and is used to properly
-/// initialize and clean up the terminal.
-pub struct Environment {
-    /// Whether keyboard enhancements are enabled.
-    enhancement: bool,
-
-    /// Whether the terminal is in an alternate screen or not.
-    alternate: bool,
-}
-
-impl Environment {
-    /// This prepares the terminal, returning an [Environment] helpful
-    /// for cleaning up afterwards.
-    pub fn ready(alternate: bool) -> eyre::Result<Self, UIError> {
-        let mut lock = stdout().lock();
-
-        crossterm::execute!(lock, Hide)?;
-
-        if alternate {
-            crossterm::execute!(lock, EnterAlternateScreen, MoveTo(0, 0))?;
-        }
-
-        terminal::enable_raw_mode()?;
-        let enhancement = terminal::supports_keyboard_enhancement()?;
-
-        if enhancement {
-            crossterm::execute!(
-                lock,
-                PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES)
-            )?;
-        }
-
-        Ok(Self {
-            enhancement,
-            alternate,
-        })
-    }
-
-    /// Uses the information collected from initialization to safely close down
-    /// the terminal & restore it to it's previous state.
-    pub fn cleanup(&self) -> eyre::Result<(), UIError> {
-        let mut lock = stdout().lock();
-
-        if self.alternate {
-            crossterm::execute!(lock, LeaveAlternateScreen)?;
-        }
-
-        crossterm::execute!(lock, Clear(ClearType::FromCursorDown), Show)?;
-
-        if self.enhancement {
-            crossterm::execute!(lock, PopKeyboardEnhancementFlags)?;
-        }
-
-        terminal::disable_raw_mode()?;
-
-        eprintln!("bye! :)");
-
-        Ok(())
-    }
-}
-
-impl Drop for Environment {
-    /// Just a wrapper for [`Environment::cleanup`] which ignores any errors thrown.
-    fn drop(&mut self) {
-        // Well, we're dropping it, so it doesn't really matter if there's an error.
-        let _ = self.cleanup();
-    }
-}
-
-/// Initializes the UI, this will also start taking input from the user.
-///
-/// `alternate` controls whether to use [`EnterAlternateScreen`] in order to hide
-/// previous terminal history.
-pub async fn start(
-    player: Arc<Player>,
-    sender: Sender<Message>,
-    args: Args,
-) -> eyre::Result<(), UIError> {
-    let environment = Environment::ready(args.alternate)?;
-
-    let interface = task::spawn(interface(
-        Arc::clone(&player),
-        args.minimalist,
-        args.borderless,
-        args.debug,
-        args.fps,
-        21 + args.width.min(32) * 2,
-    ));
-
-    input::listen(sender.clone()).await?;
-    interface.abort();
-
-    environment.cleanup()?;
-
-    Ok(())
-}

src/player/ui/components.rs

@@ -1,152 +0,0 @@
-//! Various different individual components that
-//! appear in lowfi's UI, like the progress bar.
-
-use std::{ops::Deref as _, sync::Arc, time::Duration};
-
-use crossterm::style::Stylize as _;
-use unicode_segmentation::UnicodeSegmentation as _;
-
-use crate::{player::Player, tracks::Info};
-
-/// Small helper function to format durations.
-pub fn format_duration(duration: &Duration) -> String {
-    let seconds = duration.as_secs() % 60;
-    let minutes = duration.as_secs() / 60;
-
-    format!("{minutes:02}:{seconds:02}")
-}
-
-/// Creates the progress bar, as well as all the padding needed.
-pub fn progress_bar(player: &Player, current: Option<&Arc<Info>>, width: usize) -> String {
-    let mut duration = Duration::new(0, 0);
-    let elapsed = if current.is_some() {
-        player.sink.get_pos()
-    } else {
-        Duration::new(0, 0)
-    };
-
-    let mut filled = 0;
-    if let Some(current) = current {
-        if let Some(x) = current.duration {
-            duration = x;
-
-            let elapsed = elapsed.as_secs() as f32 / duration.as_secs() as f32;
-            filled = (elapsed * width as f32).round() as usize;
-        }
-    };
-
-    format!(
-        " [{}{}] {}/{} ",
-        "/".repeat(filled),
-        " ".repeat(width.saturating_sub(filled)),
-        format_duration(&elapsed),
-        format_duration(&duration),
-    )
-}
-
-/// Creates the audio bar, as well as all the padding needed.
-pub fn audio_bar(volume: f32, percentage: &str, width: usize) -> String {
-    let audio = (volume * width as f32).round() as usize;
-
-    format!(
-        " volume: [{}{}] {}{} ",
-        "/".repeat(audio),
-        " ".repeat(width.saturating_sub(audio)),
-        " ".repeat(4usize.saturating_sub(percentage.len())),
-        percentage,
-    )
-}
-
-/// This represents the main "action" bars state.
-enum ActionBar {
-    /// When the app is paused.
-    Paused(Info),
-
-    /// When the app is playing.
-    Playing(Info),
-
-    /// When the app is loading.
-    Loading(f32),
-
-    /// When the app is muted.
-    Muted,
-}
-
-impl ActionBar {
-    /// Formats the action bar to be displayed.
-    /// The second value is the character length of the result.
-    fn format(&self, star: bool) -> (String, usize) {
-        let (word, subject) = match self {
-            Self::Playing(x) => ("playing", Some((x.display_name.clone(), x.width))),
-            Self::Paused(x) => ("paused", Some((x.display_name.clone(), x.width))),
-            Self::Loading(progress) => {
-                let progress = format!("{: <2.0}%", (progress * 100.0).min(99.0));
-
-                ("loading", Some((progress, 3)))
-            }
-            Self::Muted => {
-                let msg = "+ to increase volume";
-
-                ("muted,", Some((String::from(msg), msg.len())))
-            }
-        };
-
-        subject.map_or_else(
-            || (word.to_owned(), word.len()),
-            |(subject, len)| {
-                (
-                    format!("{} {}{}", word, if star { "*" } else { "" }, subject.bold()),
-                    word.len() + 1 + len + usize::from(star),
-                )
-            },
-        )
-    }
-}
-
-/// Creates the top/action bar, which has the name of the track and it's status.
-/// This also creates all the needed padding.
-pub fn action(player: &Player, current: Option<&Arc<Info>>, width: usize) -> String {
-    let (main, len) = current
-        .map_or_else(
-            || ActionBar::Loading(player.progress.load(std::sync::atomic::Ordering::Acquire)),
-            |info| {
-                let info = info.deref().clone();
-
-                if player.sink.volume() < 0.01 {
-                    return ActionBar::Muted;
-                }
-
-                if player.sink.is_paused() {
-                    ActionBar::Paused(info)
-                } else {
-                    ActionBar::Playing(info)
-                }
-            },
-        )
-        .format(player.bookmarks.bookmarked());
-
-    if len > width {
-        let chopped: String = main.graphemes(true).take(width + 1).collect();
-
-        format!("{chopped}...")
-    } else {
-        format!("{}{}", main, " ".repeat(width - len))
-    }
-}
-
-/// Creates the bottom controls bar, and also spaces it properly.
-pub fn controls(width: usize) -> String {
-    let controls = [["[s]", "kip"], ["[p]", "ause"], ["[q]", "uit"]];
-
-    let len: usize = controls.concat().iter().map(|x| x.len()).sum();
-    let controls = controls.map(|x| format!("{}{}", x[0].bold(), x[1]));
-
-    let mut controls = controls.join(&" ".repeat((width - len) / (controls.len() - 1)));
-    // This is needed because changing the above line
-    // only works for when the width is even
-    controls.push_str(match width % 2 {
-        0 => " ",
-        _ => "",
-    });
-    controls
-}

src/scrapers.rs

@@ -1,88 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use clap::ValueEnum;
-use eyre::bail;
-use reqwest::Client;
-use tokio::{
-    fs::{self, File},
-    io::AsyncWriteExt,
-};
-
-pub mod archive;
-pub mod chillhop;
-pub mod lofigirl;
-
-/// Represents the different sources which can be scraped.
-#[derive(Clone, Copy, PartialEq, Eq, Debug, ValueEnum)]
-pub enum Source {
-    Lofigirl,
-    Archive,
-    Chillhop,
-}
-
-impl Source {
-    /// Gets the cache directory name, for example, `chillhop`.
-    pub fn cache_dir(&self) -> &'static str {
-        match self {
-            Source::Lofigirl => "lofigirl",
-            Source::Archive => "archive",
-            Source::Chillhop => "chillhop",
-        }
-    }
-
-    /// Gets the full root URL of the source.
-    pub fn url(&self) -> &'static str {
-        match self {
-            Source::Chillhop => "https://chillhop.com",
-            Source::Archive => "https://ia601004.us.archive.org/31/items/lofigirl",
-            Source::Lofigirl => "https://lofigirl.com/wp-content/uploads",
-        }
-    }
-}
-
-/// Sends a get request, with caching.
-async fn get(client: &Client, path: &str, source: Source) -> eyre::Result<String> {
-    let trimmed = path.trim_matches('/');
-    let cache = PathBuf::from(format!("./cache/{}/{trimmed}.html", source.cache_dir()));
-
-    if let Ok(x) = fs::read_to_string(&cache).await {
-        Ok(x)
-    } else {
-        let resp = client
-            .get(format!("{}/{trimmed}", source.url()))
-            .send()
-            .await?;
-
-        let status = resp.status();
-
-        if status == 429 {
-            bail!("rate limit reached: {path}");
-        }
-
-        if status != 404 && !status.is_success() && !status.is_redirection() {
-            bail!("non success code {}: {path}", resp.status().as_u16());
-        }
-
-        let text = resp.text().await?;
-
-        let parent = cache.parent();
-        if let Some(x) = parent {
-            if x != Path::new("") {
-                fs::create_dir_all(x).await?;
-            }
-        }
-
-        let mut file = File::create(&cache).await?;
-        file.write_all(text.as_bytes()).await?;
-
-        if status.is_redirection() {
-            bail!("redirect: {path}")
-        }
-
-        if status == 404 {
-            bail!("not found: {path}")
-        }
-
-        Ok(text)
-    }
-}

src/scrapers/archive.rs

@@ -1,74 +0,0 @@
-//! Has all of the functions for the `scrape` command.
-//!
-//! This command is completely optional, and as such isn't subject to the same
-//! quality standards as the rest of the codebase.
-
-use futures::{stream::FuturesOrdered, StreamExt};
-use lazy_static::lazy_static;
-use reqwest::Client;
-use scraper::{Html, Selector};
-
-use crate::scrapers::{get, Source};
-
-lazy_static! {
-    static ref SELECTOR: Selector = Selector::parse("html > body > pre > a").unwrap();
-}
-
-async fn parse(client: &Client, path: &str) -> eyre::Result<Vec<String>> {
-    let document = get(client, path, super::Source::Lofigirl).await?;
-    let html = Html::parse_document(&document);
-
-    Ok(html
-        .select(&SELECTOR)
-        .skip(1)
-        .map(|x| String::from(x.attr("href").unwrap()))
-        .collect())
-}
-
-/// This function basically just scans the entire file server, and returns a list of paths to mp3 files.
-///
-/// It's a bit hacky, and basically works by checking all of the years, then months, and then all of the files.
-/// This is done as a way to avoid recursion, since async rust really hates recursive functions.
-async fn scan() -> eyre::Result<Vec<String>> {
-    let client = Client::new();
-
-    let mut releases = parse(&client, "/").await?;
-    releases.truncate(releases.len() - 4);
-
-    // A little bit of async to run all of the months concurrently.
-    let mut futures = FuturesOrdered::new();
-
-    for release in releases {
-        let client = client.clone();
-        futures.push_back(async move {
-            let items = parse(&client, &release).await.unwrap();
-            items
-                .into_iter()
-                .filter_map(|x| {
-                    if x.ends_with(".mp3") {
-                        Some(format!("{release}{x}"))
-                    } else {
-                        None
-                    }
-                })
-                .collect::<Vec<String>>()
-        });
-    }
-
-    let mut files = Vec::new();
-    while let Some(mut result) = futures.next().await {
-        files.append(&mut result);
-    }
-
-    eyre::Result::Ok(files)
-}
-
-pub async fn scrape() -> eyre::Result<()> {
-    println!("{}/", Source::Lofigirl.url());
-    let files = scan().await?;
-    for file in files {
-        println!("{file}");
-    }
-
-    Ok(())
-}

src/scrapers/chillhop.rs

@@ -1,223 +0,0 @@
-use eyre::eyre;
-use futures::stream::FuturesUnordered;
-use futures::StreamExt;
-use indicatif::ProgressBar;
-use lazy_static::lazy_static;
-use std::fmt;
-use std::str::FromStr;
-
-use reqwest::Client;
-use scraper::{Html, Selector};
-use serde::{
-    de::{self, Visitor},
-    Deserialize, Deserializer,
-};
-use tokio::fs;
-
-use crate::scrapers::{get, Source};
-
-lazy_static! {
-    static ref RELEASES: Selector = Selector::parse(".table-body > a").unwrap();
-    static ref RELEASE_LABEL: Selector = Selector::parse("label").unwrap();
-    // static ref RELEASE_DATE: Selector = Selector::parse(".release-feat-props > .text-xs").unwrap();
-    // static ref RELEASE_NAME: Selector = Selector::parse(".release-feat-props > h2").unwrap();
-    static ref RELEASE_AUTHOR: Selector = Selector::parse(".release-feat-props .artist-link").unwrap();
-    static ref RELEASE_TEXTAREA: Selector = Selector::parse("textarea").unwrap();
-}
-
-#[derive(Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Track {
-    title: String,
-    #[serde(deserialize_with = "deserialize_u32_from_string")]
-    file_id: u32,
-    artists: String,
-}
-
-impl Track {
-    pub fn clean(&mut self) {
-        self.artists = html_escape::decode_html_entities(&self.artists).to_string();
-
-        self.title = html_escape::decode_html_entities(&self.title).to_string();
-    }
-}
-
-#[derive(Deserialize, Debug)]
-struct Release {
-    #[serde(skip)]
-    pub path: String,
-
-    #[serde(skip)]
-    pub index: usize,
-
-    pub tracks: Vec<Track>,
-}
-
-#[derive(thiserror::Error, Debug)]
-enum ReleaseError {
-    #[error("invalid release: {0}")]
-    Invalid(#[from] eyre::Error),
-}
-
-impl Release {
-    pub async fn scan(
-        path: String,
-        index: usize,
-        client: Client,
-        bar: ProgressBar,
-    ) -> Result<Self, ReleaseError> {
-        let content = get(&client, &path, Source::Chillhop).await?;
-        let html = Html::parse_document(&content);
-
-        let textarea = html
-            .select(&RELEASE_TEXTAREA)
-            .next()
-            .ok_or(eyre!("unable to find textarea: {path}"))?;
-
-        let mut release: Self = serde_json::from_str(&textarea.inner_html()).unwrap();
-        release.path = path;
-        release.index = index;
-        release.tracks.reverse();
-
-        bar.inc(release.tracks.len() as u64);
-
-        Ok(release)
-    }
-}
-
-async fn scan_page(
-    number: usize,
-    client: &Client,
-    bar: ProgressBar,
-) -> eyre::Result<Vec<impl futures::Future<Output = Result<Release, ReleaseError>>>> {
-    let path = format!("releases/?page={number}");
-    let content = get(client, &path, Source::Chillhop).await?;
-    let html = Html::parse_document(&content);
-
-    let elements = html.select(&RELEASES);
-    Ok(elements
-        .enumerate()
-        .filter_map(|(i, x)| {
-            let label = x.select(&RELEASE_LABEL).next()?.inner_html();
-            if label == "Compilation" {
-                return None;
-            }
-
-            Some(Release::scan(
-                x.attr("href")?.to_string(),
-                (number * 12) + i,
-                client.clone(),
-                bar.clone(),
-            ))
-        })
-        .collect())
-}
-
-pub async fn scrape() -> eyre::Result<()> {
-    const PAGE_COUNT: usize = 40;
-    const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
-    const TRACK_COUNT: u64 = 1625;
-
-    const IGNORED_TRACKS: [u32; 20] = [
-        // 404
-        74707, // Lyrics
-        21655, 21773, 8172, 55397, 75135, 24827, 8141, 8157, 64052, 31612, 41956, 8001, 9217,
-        55372, // Abnormal
-        8469, 7832, 10448, 9446, 9396,
-    ];
-
-    const IGNORED_ARTISTS: [&str; 1] = [
-        "Kenji", // Lyrics
-    ];
-
-    fs::create_dir_all("./cache/chillhop").await.unwrap();
-    let client = Client::builder().user_agent(USER_AGENT).build().unwrap();
-
-    let futures = FuturesUnordered::new();
-    let bar = ProgressBar::new(TRACK_COUNT + (12 * (PAGE_COUNT as u64)));
-
-    let mut errors = Vec::new();
-
-    // This is slightly less memory efficient than I'd hope, but it is what it is.
-    for page in 0..=PAGE_COUNT {
-        bar.inc(12);
-        for x in scan_page(page, &client, bar.clone()).await? {
-            futures.push(x);
-        }
-    }
-
-    let mut results: Vec<Result<Release, ReleaseError>> = futures.collect().await;
-    bar.finish_and_clear();
-
-    // I mean, is it... optimal? Absolutely not. Does it work? Yes.
-    eprintln!("sorting...");
-    results.sort_by_key(|x| if let Ok(x) = x { x.index } else { 0 });
-    results.reverse();
-
-    eprintln!("printing...");
-    let mut printed = Vec::with_capacity(TRACK_COUNT as usize); // Lazy way to get rid of dupes.
-    for result in results {
-        let release = match result {
-            Ok(release) => release,
-            Err(error) => {
-                errors.push(error);
-                continue;
-            }
-        };
-
-        for mut track in release.tracks {
-            if IGNORED_TRACKS.contains(&track.file_id) {
-                continue;
-            }
-
-            if IGNORED_ARTISTS.contains(&track.artists.as_ref()) {
-                continue;
-            }
-
-            if printed.contains(&track.file_id) {
-                continue;
-            }
-
-            printed.push(track.file_id);
-
-            track.clean();
-            println!("{}!{}", track.file_id, track.title);
-        }
-    }
-
-    eprintln!("-- ERROR REPORT --");
-    for error in errors {
-        eprintln!("{error}");
-    }
-
-    Ok(())
-}
-
-pub fn deserialize_u32_from_string<'de, D>(deserializer: D) -> Result<u32, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    struct U32FromStringVisitor;
-
-    impl<'de> Visitor<'de> for U32FromStringVisitor {
-        type Value = u32;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a string containing an unsigned 32-bit integer")
-        }
-
-        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-        where
-            E: de::Error,
-        {
-            u32::from_str(value).map_err(|_| {
-                de::Error::invalid_value(
-                    de::Unexpected::Str(value),
-                    &"a valid unsigned 32-bit integer",
-                )
-            })
-        }
-    }
-
-    deserializer.deserialize_str(U32FromStringVisitor)
-}

src/scrapers/lofigirl.rs

@@ -1,87 +0,0 @@
-//! Has all of the functions for the `scrape` command.
-//!
-//! This command is completely optional, and as such isn't subject to the same
-//! quality standards as the rest of the codebase.
-
-use futures::{stream::FuturesOrdered, StreamExt};
-use lazy_static::lazy_static;
-use reqwest::Client;
-use scraper::{Html, Selector};
-
-use crate::scrapers::get;
-
-lazy_static! {
-    static ref SELECTOR: Selector = Selector::parse("html > body > pre > a").unwrap();
-}
-
-async fn parse(client: &Client, path: &str) -> eyre::Result<Vec<String>> {
-    let document = get(client, path, super::Source::Lofigirl).await?;
-    let html = Html::parse_document(&document);
-
-    Ok(html
-        .select(&SELECTOR)
-        .skip(5)
-        .map(|x| String::from(x.attr("href").unwrap()))
-        .collect())
-}
-
-/// This function basically just scans the entire file server, and returns a list of paths to mp3 files.
-///
-/// It's a bit hacky, and basically works by checking all of the years, then months, and then all of the files.
-/// This is done as a way to avoid recursion, since async rust really hates recursive functions.
-async fn scan() -> eyre::Result<Vec<String>> {
-    let client = Client::new();
-    let items = parse(&client, "/").await?;
-
-    let mut years: Vec<u32> = items
-        .iter()
-        .filter_map(|x| {
-            let year = x.strip_suffix("/")?;
-            year.parse().ok()
-        })
-        .collect();
-
-    years.sort();
-
-    // A little bit of async to run all of the months concurrently.
-    let mut futures = FuturesOrdered::new();
-
-    for year in years {
-        let months = parse(&client, &year.to_string()).await?;
-
-        for month in months {
-            let client = client.clone();
-            futures.push_back(async move {
-                let path = format!("{}/{}", year, month);
-
-                let items = parse(&client, &path).await.unwrap();
-                items
-                    .into_iter()
-                    .filter_map(|x| {
-                        if x.ends_with(".mp3") {
-                            Some(format!("{path}{x}"))
-                        } else {
-                            None
-                        }
-                    })
-                    .collect::<Vec<String>>()
-            });
-        }
-    }
-
-    let mut files = Vec::new();
-    while let Some(mut result) = futures.next().await {
-        files.append(&mut result);
-    }
-
-    eyre::Result::Ok(files)
-}
-
-pub async fn scrape() -> eyre::Result<()> {
-    let files = scan().await?;
-    for file in files {
-        println!("{file}");
-    }
-
-    Ok(())
-}

src/tracks.rs

@@ -1,243 +0,0 @@
-//! Has all of the structs for managing the state
-//! of tracks, as well as downloading them & finding new ones.
-//!
-//! There are several structs which represent the different stages
-//! that go on in downloading and playing tracks. The proccess for fetching tracks,
-//! and what structs are relevant in each step, are as follows.
-//!
-//! First Stage, when a track is initially fetched.
-//! 1. Raw entry selected from track list.
-//! 2. Raw entry split into path & display name.
-//! 3. Track data fetched, and [`QueuedTrack`] is created which includes a [`TrackName`] that may be raw.
-//!
-//! Second Stage, when a track is played.
-//! 1. Track data is decoded.
-//! 2. [`Info`] created from decoded data.
-//! 3. [`Decoded`] made from [`Info`] and the original decoded data.
-
-use std::{io::Cursor, path::Path, time::Duration};
-
-use bytes::Bytes;
-use convert_case::{Case, Casing};
-use regex::Regex;
-use rodio::{Decoder, Source as _};
-use unicode_segmentation::UnicodeSegmentation;
-use url::form_urlencoded;
-
-pub mod error;
-pub mod list;
-
-pub use error::Error;
-
-use crate::tracks::error::Context;
-use lazy_static::lazy_static;
-
-/// Just a shorthand for a decoded [Bytes].
-pub type DecodedData = Decoder<Cursor<Bytes>>;
-
-/// Specifies a track's name, and specifically,
-/// whether it has already been formatted or if it
-/// is still in it's raw path form.
-#[derive(Debug, Clone)]
-pub enum TrackName {
-    /// Pulled straight from the list,
-    /// with no splitting done at all.
-    Raw(String),
-
-    /// If a track has a custom specified name
-    /// in the list, then it should be defined with this variant.
-    Formatted(String),
-}
-
-/// Tracks which are still waiting in the queue, and can't be played yet.
-///
-/// This means that only the data & track name are included.
-pub struct QueuedTrack {
-    /// Name of the track, which may be raw.
-    pub name: TrackName,
-
-    /// Full downloadable path/url of the track.
-    pub full_path: String,
-
-    /// The raw data of the track, which is not decoded and
-    /// therefore much more memory efficient.
-    pub data: Bytes,
-}
-
-impl QueuedTrack {
-    /// This will actually decode and format the track,
-    /// returning a [`DecodedTrack`] which can be played
-    /// and also has a duration & formatted name.
-    pub fn decode(self) -> eyre::Result<DecodedTrack, Error> {
-        DecodedTrack::new(self)
-    }
-}
-
-/// The [`Info`] struct, which has the name and duration of a track.
-///
-/// This is not included in [Track] as the duration has to be acquired
-/// from the decoded data and not from the raw data.
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct Info {
-    /// The full downloadable path/url of the track.
-    pub full_path: String,
-
-    /// Whether the track entry included a custom name, or not.
-    pub custom_name: bool,
-
-    /// This is a formatted name, so it doesn't include the full path.
-    pub display_name: String,
-
-    /// This is the *actual* terminal width of the track name, used to make
-    /// the UI consistent.
-    pub width: usize,
-
-    /// The duration of the track, this is an [Option] because there are
-    /// cases where the duration of a track is unknown.
-    pub duration: Option<Duration>,
-}
-
-lazy_static! {
-    static ref MASTER_PATTERNS: [Regex; 5] = [
-        // (master), (master v2)
-        Regex::new(r"\s*\(.*?master(?:\s*v?\d+)?\)$").unwrap(),
-        // mstr or - mstr or (mstr) — now also matches "mstr v3", "mstr2", etc.
-        Regex::new(r"\s*[-(]?\s*mstr(?:\s*v?\d+)?\s*\)?$").unwrap(),
-        // - master, master at end without parentheses
-        Regex::new(r"\s*[-]?\s*master(?:\s*v?\d+)?$").unwrap(),
-        // kupla master1, kupla master v2 (without parentheses or separator)
-        Regex::new(r"\s+kupla\s+master(?:\s*v?\d+|\d+)?$").unwrap(),
-        // (kupla master) followed by trailing parenthetical numbers, e.g. "... (kupla master) (1)"
-        Regex::new(r"\s*\(.*?master(?:\s*v?\d+)?\)(?:\s*\(\d+\))+$").unwrap(),
-    ];
-    static ref ID_PATTERN: Regex = Regex::new(r"^[a-z]\d[ .]").unwrap();
-}
-
-impl Info {
-    /// Converts the info back into a full track list entry.
-    pub fn to_entry(&self) -> String {
-        let mut entry = self.full_path.clone();
-
-        if self.custom_name {
-            entry.push('!');
-            entry.push_str(&self.display_name);
-        }
-
-        entry
-    }
-
-    /// Decodes a URL string into normal UTF-8.
-    fn decode_url(text: &str) -> String {
-        // The tuple contains smart pointers, so it's not really practical to use `into()`.
-        #[allow(clippy::tuple_array_conversions)]
-        form_urlencoded::parse(text.as_bytes())
-            .map(|(key, val)| [key, val].concat())
-            .collect()
-    }
-
-    /// Formats a name with [`convert_case`].
-    ///
-    /// This will also strip the first few numbers that are
-    /// usually present on most lofi tracks and do some other
-    /// formatting operations.
-    fn format_name(name: &str) -> eyre::Result<String, Error> {
-        let path = Path::new(name);
-
-        let name = path
-            .file_stem()
-            .and_then(|x| x.to_str())
-            .ok_or((name, error::Kind::InvalidName))?;
-
-        let name = Self::decode_url(name).to_lowercase();
-        let mut name = name
-            .replace("masster", "master")
-            .replace("(online-audio-converter.com)", "") // Some of these names, man...
-            .replace('_', " ");
-
-        // Get rid of "master" suffix with a few regex patterns.
-        for regex in MASTER_PATTERNS.iter() {
-            name = regex.replace(&name, "").to_string();
-        }
-
-        name = ID_PATTERN.replace(&name, "").to_string();
-
-        let name = name
-            .replace("13lufs", "")
-            .to_case(Case::Title)
-            .replace(" .", "")
-            .replace(" Ft ", " ft. ")
-            .replace("Ft.", "ft.")
-            .replace("Feat.", "ft.")
-            .replace(" W ", " w/ ");
-
-        // This is incremented for each digit in front of the song name.
-        let mut skip = 0;
-
-        for character in name.as_bytes() {
-            if character.is_ascii_digit()
-                || *character == b'.'
-                || *character == b')'
-                || *character == b'('
-            {
-                skip += 1;
-            } else {
-                break;
-            }
-        }
-
-        // If the entire name of the track is a number, then just return it.
-        if skip == name.len() {
-            Ok(name.trim().to_string())
-        } else {
-            // We've already checked before that the bound is at an ASCII digit.
-            #[allow(clippy::string_slice)]
-            Ok(String::from(name[skip..].trim()))
-        }
-    }
-
-    /// Creates a new [`TrackInfo`] from a possibly raw name & decoded data.
-    pub fn new(
-        name: TrackName,
-        full_path: String,
-        decoded: &DecodedData,
-    ) -> eyre::Result<Self, Error> {
-        let (display_name, custom_name) = match name {
-            TrackName::Raw(raw) => (Self::format_name(&raw)?, false),
-            TrackName::Formatted(custom) => (custom, true),
-        };
-
-        Ok(Self {
-            duration: decoded.total_duration(),
-            width: display_name.graphemes(true).count(),
-            full_path,
-            custom_name,
-            display_name,
-        })
-    }
-}
-
-/// This struct is seperate from [Track] since it is generated lazily from
-/// a track, and not when the track is first downloaded.
-pub struct DecodedTrack {
-    /// Has both the formatted name and some information from the decoded data.
-    pub info: Info,
-
-    /// The decoded data, which is able to be played by [rodio].
-    pub data: DecodedData,
-}
-
-impl DecodedTrack {
-    /// Creates a new track.
-    /// This is equivalent to [`QueuedTrack::decode`].
-    pub fn new(track: QueuedTrack) -> eyre::Result<Self, Error> {
-        let data = Decoder::builder()
-            .with_byte_len(track.data.len().try_into().unwrap())
-            .with_data(Cursor::new(track.data))
-            .build()
-            .track(track.full_path.clone())?;
-
-        let info = Info::new(track.name, track.full_path, &data)?;
-
-        Ok(Self { info, data })
-    }
-}

src/tracks/error.rs

@@ -1,73 +0,0 @@
-#[derive(Debug, thiserror::Error)]
-pub enum Kind {
-    #[error("unable to decode: {0}")]
-    Decode(#[from] rodio::decoder::DecoderError),
-
-    #[error("invalid name")]
-    InvalidName,
-
-    #[error("invalid file path")]
-    InvalidPath,
-
-    #[error("unknown target track length")]
-    UnknownLength,
-
-    #[error("unable to read file: {0}")]
-    File(#[from] std::io::Error),
-
-    #[error("unable to fetch data: {0}")]
-    Request(#[from] reqwest::Error),
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("{kind} (track: {track})")]
-pub struct Error {
-    pub track: String,
-
-    #[source]
-    pub kind: Kind,
-}
-
-impl Error {
-    pub fn is_timeout(&self) -> bool {
-        if let Kind::Request(x) = &self.kind {
-            x.is_timeout()
-        } else {
-            false
-        }
-    }
-}
-
-impl<T, E> From<(T, E)> for Error
-where
-    T: Into<String>,
-    Kind: From<E>,
-{
-    fn from((track, err): (T, E)) -> Self {
-        Self {
-            track: track.into(),
-            kind: Kind::from(err),
-        }
-    }
-}
-
-pub trait Context<T> {
-    fn track(self, name: impl Into<String>) -> Result<T, Error>;
-}
-
-impl<T, E> Context<T> for Result<T, E>
-where
-    (String, E): Into<Error>,
-    E: Into<Kind>,
-{
-    fn track(self, name: impl Into<String>) -> Result<T, Error> {
-        self.map_err(|e| {
-            let error = match e.into() {
-                Kind::Request(e) => Kind::Request(e.without_url()),
-                e => e,
-            };
-
-            (name.into(), error).into()
-        })
-    }
-}

src/tracks/list.rs

@@ -1,189 +0,0 @@
-//! The module containing all of the logic behind track lists,
-//! as well as obtaining track names & downloading the raw audio data
-
-use std::{cmp::min, sync::atomic::Ordering};
-
-use atomic_float::AtomicF32;
-use bytes::{BufMut, Bytes, BytesMut};
-use eyre::OptionExt as _;
-use futures::StreamExt;
-use reqwest::Client;
-use tokio::fs;
-
-use crate::{
-    data_dir,
-    tracks::{self, error::Context},
-};
-
-use super::QueuedTrack;
-
-/// Represents a list of tracks that can be played.
-///
-/// See the [README](https://github.com/talwat/lowfi?tab=readme-ov-file#the-format) for more details about the format.
-#[derive(Clone)]
-pub struct List {
-    /// The "name" of the list, usually derived from a filename.
-    #[allow(dead_code)]
-    pub name: String,
-
-    /// Just the raw file, but seperated by `/n` (newlines).
-    /// `lines[0]` is the base/heaeder, with the rest being tracks.
-    lines: Vec<String>,
-
-    /// The file path which the list was read from.
-    #[allow(dead_code)]
-    pub path: Option<String>,
-}
-
-impl List {
-    /// Gets the base URL of the [List].
-    pub fn base(&self) -> &str {
-        self.lines[0].trim()
-    }
-
-    /// Gets the path of a random track.
-    ///
-    /// The second value in the tuple specifies whether the
-    /// track has a custom display name.
-    fn random_path(&self) -> (String, Option<String>) {
-        // We're getting from 1 here, since the base is at `self.lines[0]`.
-        //
-        // We're also not pre-trimming `self.lines` into `base` & `tracks` due to
-        // how rust vectors work, since it is slower to drain only a single element from
-        // the start, so it's faster to just keep it in & work around it.
-        let random = fastrand::usize(1..self.lines.len());
-        let line = self.lines[random].clone();
-
-        if let Some((first, second)) = line.split_once('!') {
-            (first.to_owned(), Some(second.to_owned()))
-        } else {
-            (line, None)
-        }
-    }
-
-    /// Downloads a raw track, but doesn't decode it.
-    async fn download(
-        &self,
-        track: &str,
-        client: &Client,
-        progress: Option<&AtomicF32>,
-    ) -> Result<(Bytes, String), tracks::Error> {
-        // If the track has a protocol, then we should ignore the base for it.
-        let full_path = if track.contains("://") {
-            track.to_owned()
-        } else {
-            format!("{}{}", self.base(), track)
-        };
-
-        let data: Bytes = if let Some(x) = full_path.strip_prefix("file://") {
-            let path = if x.starts_with('~') {
-                let home_path =
-                    dirs::home_dir().ok_or((track, tracks::error::Kind::InvalidPath))?;
-                let home = home_path
-                    .to_str()
-                    .ok_or((track, tracks::error::Kind::InvalidPath))?;
-
-                x.replace('~', home)
-            } else {
-                x.to_owned()
-            };
-
-            let result = tokio::fs::read(path.clone()).await.track(track)?;
-            result.into()
-        } else {
-            let response = client.get(full_path.clone()).send().await.track(track)?;
-
-            if let Some(progress) = progress {
-                let total = response
-                    .content_length()
-                    .ok_or((track, tracks::error::Kind::UnknownLength))?;
-                let mut stream = response.bytes_stream();
-                let mut bytes = BytesMut::new();
-                let mut downloaded: u64 = 0;
-
-                while let Some(item) = stream.next().await {
-                    let chunk = item.track(track)?;
-                    let new = min(downloaded + (chunk.len() as u64), total);
-                    downloaded = new;
-                    progress.store((new as f32) / (total as f32), Ordering::Relaxed);
-
-                    bytes.put(chunk);
-                }
-
-                bytes.into()
-            } else {
-                response.bytes().await.track(track)?
-            }
-        };
-
-        Ok((data, full_path))
-    }
-
-    /// Fetches and downloads a random track from the [List].
-    ///
-    /// The Result's error is a bool, which is true if a timeout error occured,
-    /// and false otherwise. This tells lowfi if it shouldn't wait to try again.
-    pub async fn random(
-        &self,
-        client: &Client,
-        progress: Option<&AtomicF32>,
-    ) -> Result<QueuedTrack, tracks::Error> {
-        let (path, custom_name) = self.random_path();
-        let (data, full_path) = self.download(&path, client, progress).await?;
-
-        let name = custom_name.map_or_else(
-            || super::TrackName::Raw(path.clone()),
-            super::TrackName::Formatted,
-        );
-
-        Ok(QueuedTrack {
-            name,
-            full_path,
-            data,
-        })
-    }
-
-    /// Parses text into a [List].
-    pub fn new(name: &str, text: &str, path: Option<&str>) -> Self {
-        let lines: Vec<String> = text
-            .trim_end()
-            .lines()
-            .map(|x| x.trim_end().to_owned())
-            .collect();
-
-        Self {
-            lines,
-            path: path.map(ToOwned::to_owned),
-            name: name.to_owned(),
-        }
-    }
-
-    /// Reads a [List] from the filesystem using the CLI argument provided.
-    pub async fn load(tracks: Option<&String>) -> eyre::Result<Self> {
-        if let Some(arg) = tracks {
-            // Check if the track is in ~/.local/share/lowfi, in which case we'll load that.
-            let path = data_dir()?.join(format!("{arg}.txt"));
-            let path = if path.exists() { path } else { arg.into() };
-
-            let raw = fs::read_to_string(path.clone()).await?;
-
-            // Get rid of special noheader case for tracklists without a header.
-            let raw = raw
-                .strip_prefix("noheader")
-                .map_or(raw.as_ref(), |stripped| stripped);
-
-            let name = path
-                .file_stem()
-                .and_then(|x| x.to_str())
-                .ok_or_eyre("invalid track path")?;
-
-            Ok(Self::new(name, raw, path.to_str()))
-        } else {
-            Ok(Self::new(
-                "chillhop",
-                include_str!("../../data/chillhop.txt"),
-                None,
-            ))
-        }
-    }
-}

src/ui.rs

@@ -0,0 +1,58 @@
+use tokio::sync::mpsc::{self, Receiver, Sender};
+use crate::Message;
+mod input;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Render {
+    pub track: String,
+}
+
+#[derive(Debug)]
+struct Handles {
+    render: crate::Handle,
+    input: crate::Handle,
+}
+
+#[derive(Debug)]
+pub struct UI {
+    pub utx: Sender<Message>,
+    handles: Handles
+}
+
+impl Drop for UI {
+    fn drop(&mut self) {
+        self.handles.input.abort();
+        self.handles.render.abort();
+    }
+}
+
+impl UI {
+    pub async fn render(&mut self, data: Render) -> crate::Result<()> {
+        self.utx.send(Message::Render(data)).await?;
+
+        Ok(())
+    }
+
+    async fn ui(mut rx: Receiver<Message>) -> crate::Result<()> {
+        while let Some(message) = rx.recv().await {
+            let Message::Render(data) = message else {
+                continue;
+            };
+
+            eprintln!("data: {data:?}");
+        }
+        Ok(())
+    }
+
+    pub async fn init(tx: Sender<Message>) -> Self {
+        let (utx, urx) = mpsc::channel(8);
+
+        Self {
+            utx,
+            handles: Handles {
+                render: tokio::spawn(Self::ui(urx)),
+                input: tokio::spawn(input::listen(tx)),
+            }
+        }
+    }
+}

src/ui/input.rs

@@ -4,14 +4,10 @@
 use crossterm::event::{self, EventStream, KeyCode, KeyEventKind, KeyModifiers};
 use futures::{FutureExt as _, StreamExt as _};
 use tokio::sync::mpsc::Sender;
-
+use crate::Message;
-use crate::player::{
-    ui::{self, UIError},
-    Message,
-};
 
 /// Starts the listener to recieve input from the terminal for various events.
-pub async fn listen(sender: Sender<Message>) -> eyre::Result<(), UIError> {
+pub async fn listen(sender: Sender<Message>) -> crate::Result<()> {
     let mut reader = EventStream::new();
 
     loop {
@@ -66,10 +62,6 @@ pub async fn listen(sender: Sender<Message>) -> eyre::Result<(), UIError> {
             _ => continue,
         };
 
-        if let Message::ChangeVolume(_) = messages {
-            ui::flash_audio();
-        }
-
         sender.send(messages).await?;
     }
-}
+}