wojtek/musichoard
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects 1 Releases 2 Wiki Activity

Clean up interfaces (#62)

Browse Source 
Closes #61

Reviewed-on: https://git.wojciechkozlowski.eu/wojtek/musichoard/pulls/62
This commit is contained in:
Wojciech Kozlowski 2023-05-10 22:52:03 +02:00
parent c6ed827984
commit 282e0e6f19
17 changed files with 344 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -17,7 +17,7 @@ env CARGO_TARGET_DIR=codecov \
env RUSTFLAGS="-C instrument-coverage" \
LLVM_PROFILE_FILE="codecov/debug/profraw/musichoard-%p-%m.profraw" \
CARGO_TARGET_DIR=codecov \
cargo test --all-features
cargo test --all-features --all-targets
grcov codecov/debug/profraw \
--binary-path ./codecov/debug/ \
--output-types html \

178
src/collection/mod.rs
View File

@ -1,178 +0,0 @@
//! Module for managing the music collection, i.e. "The Music Hoard".
use std::fmt;
use crate::{
database::{self, Database},
library::{self, Library, Query},
Artist,
};
/// The collection type.
pub type Collection = Vec<Artist>;
/// Error type for collection manager.
#[derive(Debug, PartialEq, Eq)]
pub enum Error {
/// The [`CollectionManager`] failed to read/write from/to the library.
LibraryError(String),
/// The [`CollectionManager`] failed to read/write from/to the database.
DatabaseError(String),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Self::LibraryError(ref s) => write!(f, "failed to read/write from/to the library: {s}"),
Self::DatabaseError(ref s) => {
write!(f, "failed to read/write from/to the database: {s}")
}
}
}
}
impl From<library::Error> for Error {
fn from(err: library::Error) -> Error {
Error::LibraryError(err.to_string())
}
}
impl From<database::Error> for Error {
fn from(err: database::Error) -> Error {
Error::DatabaseError(err.to_string())
}
}
pub trait CollectionManager {
/// Rescan the library and integrate any updates into the collection.
fn rescan_library(&mut self) -> Result<(), Error>;
/// Save the collection state to the database.
fn save_to_database(&mut self) -> Result<(), Error>;
/// Get the current collection.
fn get_collection(&self) -> &Collection;
}
/// The collection manager. It is responsible for pulling information from both the library and the
/// database, ensuring its consistent and writing back any changes.
pub struct MhCollectionManager<LIB, DB> {
library: LIB,
database: DB,
collection: Collection,
}
impl<LIB: Library, DB: Database> MhCollectionManager<LIB, DB> {
/// Create a new [`CollectionManager`] with the provided [`Library`] and [`Database`].
pub fn new(library: LIB, database: DB) -> Self {
MhCollectionManager {
library,
database,
collection: vec![],
}
}
}
impl<LIB: Library, DB: Database> CollectionManager for MhCollectionManager<LIB, DB> {
fn rescan_library(&mut self) -> Result<(), Error> {
self.collection = self.library.list(&Query::new())?;
Ok(())
}
fn save_to_database(&mut self) -> Result<(), Error> {
self.database.write(&self.collection)?;
Ok(())
}
fn get_collection(&self) -> &Collection {
&self.collection
}
}
#[cfg(test)]
mod tests {
use mockall::predicate;
use crate::{
collection::Collection,
database::{self, MockDatabase},
library::{self, MockLibrary, Query},
tests::COLLECTION,
};
use super::{CollectionManager, Error, MhCollectionManager};
#[test]
fn read_get_write() {
let mut library = MockLibrary::new();
let mut database = MockDatabase::new();
let library_input = Query::new();
let library_result = Ok(COLLECTION.to_owned());
let database_input = COLLECTION.to_owned();
let database_result = Ok(());
library
.expect_list()
.with(predicate::eq(library_input))
.times(1)
.return_once(|_| library_result);
database
.expect_write()
.with(predicate::eq(database_input))
.times(1)
.return_once(|_: &Collection| database_result);
let mut collection_manager = MhCollectionManager::new(library, database);
collection_manager.rescan_library().unwrap();
assert_eq!(collection_manager.get_collection(), &*COLLECTION);
collection_manager.save_to_database().unwrap();
}
#[test]
fn library_error() {
let mut library = MockLibrary::new();
let database = MockDatabase::new();
let library_result = Err(library::Error::Invalid(String::from("invalid data")));
library
.expect_list()
.times(1)
.return_once(|_| library_result);
let mut collection_manager = MhCollectionManager::new(library, database);
let actual_err = collection_manager.rescan_library().unwrap_err();
let expected_err =
Error::LibraryError(library::Error::Invalid(String::from("invalid data")).to_string());
assert_eq!(actual_err, expected_err);
assert_eq!(actual_err.to_string(), expected_err.to_string());
}
#[test]
fn database_error() {
let library = MockLibrary::new();
let mut database = MockDatabase::new();
let database_result = Err(database::Error::IoError(String::from("I/O error")));
database
.expect_write()
.times(1)
.return_once(|_: &Collection| database_result);
let mut collection_manager = MhCollectionManager::new(library, database);
let actual_err = collection_manager.save_to_database().unwrap_err();
let expected_err =
Error::DatabaseError(database::Error::IoError(String::from("I/O error")).to_string());
assert_eq!(actual_err, expected_err);
assert_eq!(actual_err.to_string(), expected_err.to_string());
}
}

4
src/database/json/backend.rs
View File

@ -3,7 +3,7 @@
use std::fs;
use std::path::PathBuf;
use super::JsonDatabaseBackend;
use super::IJsonDatabaseBackend;
/// JSON database backend that uses a local file for persistent storage.
pub struct JsonDatabaseFileBackend {
@ -17,7 +17,7 @@ impl JsonDatabaseFileBackend {
}
}
impl JsonDatabaseBackend for JsonDatabaseFileBackend {
impl IJsonDatabaseBackend for JsonDatabaseFileBackend {
fn read(&self) -> Result<String, std::io::Error> {
// Read entire file to memory as for now this is faster than a buffered read from disk:
// https://github.com/serde-rs/json/issues/160

14
src/database/json/mod.rs
View File

@ -6,7 +6,7 @@ use serde::Serialize;
#[cfg(test)]
use mockall::automock;
use super::{Database, Error};
use super::{Error, IDatabase};
pub mod backend;
@ -18,7 +18,7 @@ impl From<serde_json::Error> for Error {
/// Trait for the JSON database backend.
#[cfg_attr(test, automock)]
pub trait JsonDatabaseBackend {
pub trait IJsonDatabaseBackend {
/// Read the JSON string from the backend.
fn read(&self) -> Result<String, std::io::Error>;
@ -31,7 +31,7 @@ pub struct JsonDatabase<JDB> {
backend: JDB,
}
impl<JDB: JsonDatabaseBackend> JsonDatabase<JDB> {
impl<JDB: IJsonDatabaseBackend> JsonDatabase<JDB> {
/// Create a new JSON database with the provided backend, e.g.
/// [`backend::JsonDatabaseFileBackend`].
pub fn new(backend: JDB) -> Self {
@ -39,7 +39,7 @@ impl<JDB: JsonDatabaseBackend> JsonDatabase<JDB> {
}
}
impl<JDB: JsonDatabaseBackend> Database for JsonDatabase<JDB> {
impl<JDB: IJsonDatabaseBackend> IDatabase for JsonDatabase<JDB> {
fn read<D: DeserializeOwned>(&self, collection: &mut D) -> Result<(), Error> {
let serialized = self.backend.read()?;
*collection = serde_json::from_str(&serialized)?;
@ -132,7 +132,7 @@ mod tests {
let write_data = COLLECTION.to_owned();
let input = artists_to_json(&write_data);
let mut backend = MockJsonDatabaseBackend::new();
let mut backend = MockIJsonDatabaseBackend::new();
backend
.expect_write()
.with(predicate::eq(input))
@ -147,7 +147,7 @@ mod tests {
let expected = COLLECTION.to_owned();
let result = Ok(artists_to_json(&expected));
let mut backend = MockJsonDatabaseBackend::new();
let mut backend = MockIJsonDatabaseBackend::new();
backend.expect_read().times(1).return_once(|| result);
let mut read_data: Vec<Artist> = vec![];
@ -162,7 +162,7 @@ mod tests {
let input = artists_to_json(&expected);
let result = Ok(input.clone());
let mut backend = MockJsonDatabaseBackend::new();
let mut backend = MockIJsonDatabaseBackend::new();
backend
.expect_write()
.with(predicate::eq(input))

20
src/database/mod.rs
View File

@ -10,6 +10,16 @@ use mockall::automock;
#[cfg(feature = "database-json")]
pub mod json;
/// Trait for interacting with the database.
#[cfg_attr(test, automock)]
pub trait IDatabase {
/// Read collection from the database.
fn read<D: DeserializeOwned + 'static>(&self, collection: &mut D) -> Result<(), Error>;
/// Write collection to the database.
fn write<S: Serialize + 'static>(&mut self, collection: &S) -> Result<(), Error>;
}
/// Error type for database calls.
#[derive(Debug)]
pub enum Error {
@ -36,16 +46,6 @@ impl From<std::io::Error> for Error {
}
}
/// Trait for interacting with the database.
#[cfg_attr(test, automock)]
pub trait Database {
/// Read collection from the database.
fn read<D: DeserializeOwned + 'static>(&self, collection: &mut D) -> Result<(), Error>;
/// Write collection to the database.
fn write<S: Serialize + 'static>(&mut self, collection: &S) -> Result<(), Error>;
}
#[cfg(test)]
mod tests {
use std::io;

156
src/lib.rs
View File

@ -1,12 +1,15 @@
//! MusicHoard - a music collection manager.
use serde::{Deserialize, Serialize};
use uuid::Uuid;
pub mod collection;
pub mod database;
pub mod library;
use std::fmt;
use database::IDatabase;
use library::{ILibrary, Query};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
/// [MusicBrainz Identifier](https://musicbrainz.org/doc/MusicBrainz_Identifier) (MBID).
pub type Mbid = Uuid;
@ -53,15 +56,160 @@ pub struct Artist {
pub albums: Vec<Album>,
}
/// The collection type. Currently, a collection is a list of artists.
pub type Collection = Vec<Artist>;
/// Error type for `musichoard`.
#[derive(Debug, PartialEq, Eq)]
pub enum Error {
/// The [`MusicHoard`] failed to read/write from/to the library.
LibraryError(String),
/// The [`MusicHoard`] failed to read/write from/to the database.
DatabaseError(String),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Self::LibraryError(ref s) => write!(f, "failed to read/write from/to the library: {s}"),
Self::DatabaseError(ref s) => {
write!(f, "failed to read/write from/to the database: {s}")
}
}
}
}
impl From<library::Error> for Error {
fn from(err: library::Error) -> Error {
Error::LibraryError(err.to_string())
}
}
impl From<database::Error> for Error {
fn from(err: database::Error) -> Error {
Error::DatabaseError(err.to_string())
}
}
/// The Music Hoard. It is responsible for pulling information from both the library and the
/// database, ensuring its consistent and writing back any changes.
pub struct MusicHoard<LIB, DB> {
library: LIB,
database: DB,
collection: Collection,
}
impl<LIB: ILibrary, DB: IDatabase> MusicHoard<LIB, DB> {
/// Create a new [`MusicHoard`] with the provided [`ILibrary`] and [`IDatabase`].
pub fn new(library: LIB, database: DB) -> Self {
MusicHoard {
library,
database,
collection: vec![],
}
}
pub fn rescan_library(&mut self) -> Result<(), Error> {
self.collection = self.library.list(&Query::new())?;
Ok(())
}
pub fn save_to_database(&mut self) -> Result<(), Error> {
self.database.write(&self.collection)?;
Ok(())
}
pub fn get_collection(&self) -> &Collection {
&self.collection
}
}
#[cfg(test)]
#[macro_use]
mod testlib;
#[cfg(test)]
mod tests {
use mockall::predicate;
use once_cell::sync::Lazy;
use crate::{database::MockIDatabase, library::MockILibrary};
use super::*;
pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| collection!());
#[test]
fn read_get_write() {
let mut library = MockILibrary::new();
let mut database = MockIDatabase::new();
let library_input = Query::new();
let library_result = Ok(COLLECTION.to_owned());
let database_input = COLLECTION.to_owned();
let database_result = Ok(());
library
.expect_list()
.with(predicate::eq(library_input))
.times(1)
.return_once(|_| library_result);
database
.expect_write()
.with(predicate::eq(database_input))
.times(1)
.return_once(|_: &Collection| database_result);
let mut music_hoard = MusicHoard::new(library, database);
music_hoard.rescan_library().unwrap();
assert_eq!(music_hoard.get_collection(), &*COLLECTION);
music_hoard.save_to_database().unwrap();
}
#[test]
fn library_error() {
let mut library = MockILibrary::new();
let database = MockIDatabase::new();
let library_result = Err(library::Error::Invalid(String::from("invalid data")));
library
.expect_list()
.times(1)
.return_once(|_| library_result);
let mut music_hoard = MusicHoard::new(library, database);
let actual_err = music_hoard.rescan_library().unwrap_err();
let expected_err =
Error::LibraryError(library::Error::Invalid(String::from("invalid data")).to_string());
assert_eq!(actual_err, expected_err);
assert_eq!(actual_err.to_string(), expected_err.to_string());
}
#[test]
fn database_error() {
let library = MockILibrary::new();
let mut database = MockIDatabase::new();
let database_result = Err(database::Error::IoError(String::from("I/O error")));
database
.expect_write()
.times(1)
.return_once(|_: &Collection| database_result);
let mut music_hoard = MusicHoard::new(library, database);
let actual_err = music_hoard.save_to_database().unwrap_err();
let expected_err =
Error::DatabaseError(database::Error::IoError(String::from("I/O error")).to_string());
assert_eq!(actual_err, expected_err);
assert_eq!(actual_err.to_string(), expected_err.to_string());
}
}

12
src/library/beets/executor.rs
View File

@ -8,11 +8,11 @@ use std::{
str,
};
use super::{BeetsLibraryExecutor, Error};
use super::{IBeetsLibraryExecutor, Error};
const BEET_DEFAULT: &str = "beet";
trait BeetsLibraryExecutorPrivate {
trait IBeetsLibraryExecutorPrivate {
fn output(output: Output) -> Result<Vec<String>, Error> {
if !output.status.success() {
return Err(Error::Executor(
@ -59,7 +59,7 @@ impl Default for BeetsLibraryProcessExecutor {
}
}
impl BeetsLibraryExecutor for BeetsLibraryProcessExecutor {
impl IBeetsLibraryExecutor for BeetsLibraryProcessExecutor {
fn exec<S: AsRef<str> + 'static>(&mut self, arguments: &[S]) -> Result<Vec<String>, Error> {
let mut cmd = Command::new(&self.bin);
if let Some(ref path) = self.config {
@ -71,7 +71,7 @@ impl BeetsLibraryExecutor for BeetsLibraryProcessExecutor {
}
}
impl BeetsLibraryExecutorPrivate for BeetsLibraryProcessExecutor {}
impl IBeetsLibraryExecutorPrivate for BeetsLibraryProcessExecutor {}
// GRCOV_EXCL_START
#[cfg(feature = "ssh-library")]
@ -128,7 +128,7 @@ pub mod ssh {
}
}
impl BeetsLibraryExecutor for BeetsLibrarySshExecutor {
impl IBeetsLibraryExecutor for BeetsLibrarySshExecutor {
fn exec<S: AsRef<str> + 'static>(&mut self, arguments: &[S]) -> Result<Vec<String>, Error> {
let mut cmd = self.session.command(&self.bin);
if let Some(ref path) = self.config {
@ -141,6 +141,6 @@ pub mod ssh {
}
}
impl BeetsLibraryExecutorPrivate for BeetsLibrarySshExecutor {}
impl IBeetsLibraryExecutorPrivate for BeetsLibrarySshExecutor {}
}
// GRCOV_EXCL_STOP

26
src/library/beets/mod.rs
View File

@ -11,7 +11,7 @@ use mockall::automock;
use crate::{Album, AlbumId, Artist, ArtistId, Track, TrackFormat};
use super::{Error, Field, Library, Query};
use super::{Error, Field, ILibrary, Query};
pub mod executor;
@ -78,7 +78,7 @@ impl ToBeetsArgs for Query {
/// Trait for invoking beets commands.
#[cfg_attr(test, automock)]
pub trait BeetsLibraryExecutor {
pub trait IBeetsLibraryExecutor {
/// Invoke beets with the provided arguments.
fn exec<S: AsRef<str> + 'static>(&mut self, arguments: &[S]) -> Result<Vec<String>, Error>;
}
@ -88,12 +88,12 @@ pub struct BeetsLibrary<BLE> {
executor: BLE,
}
trait LibraryPrivate {
trait ILibraryPrivate {
fn list_cmd_and_args(query: &Query) -> Vec<String>;
fn list_to_artists<S: AsRef<str>>(list_output: &[S]) -> Result<Vec<Artist>, Error>;
}
impl<BLE: BeetsLibraryExecutor> BeetsLibrary<BLE> {
impl<BLE: IBeetsLibraryExecutor> BeetsLibrary<BLE> {
/// Create a new beets library with the provided executor, e.g.
/// [`executor::BeetsLibraryProcessExecutor`].
pub fn new(executor: BLE) -> Self {
@ -101,7 +101,7 @@ impl<BLE: BeetsLibraryExecutor> BeetsLibrary<BLE> {
}
}
impl<BLE: BeetsLibraryExecutor> Library for BeetsLibrary<BLE> {
impl<BLE: IBeetsLibraryExecutor> ILibrary for BeetsLibrary<BLE> {
fn list(&mut self, query: &Query) -> Result<Vec<Artist>, Error> {
let cmd = Self::list_cmd_and_args(query);
let output = self.executor.exec(&cmd)?;
@ -109,7 +109,7 @@ impl<BLE: BeetsLibraryExecutor> Library for BeetsLibrary<BLE> {
}
}
impl<BLE: BeetsLibraryExecutor> LibraryPrivate for BeetsLibrary<BLE> {
impl<BLE: IBeetsLibraryExecutor> ILibraryPrivate for BeetsLibrary<BLE> {
fn list_cmd_and_args(query: &Query) -> Vec<String> {
let mut cmd: Vec<String> = vec![String::from(CMD_LIST)];
cmd.push(LIST_FORMAT_ARG.to_string());
@ -293,7 +293,7 @@ mod tests {
let arguments = vec!["ls".to_string(), LIST_FORMAT_ARG.to_string()];
let result = Ok(vec![]);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))
@ -313,7 +313,7 @@ mod tests {
let expected = COLLECTION.to_owned();
let result = Ok(artists_to_beets_string(&expected));
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))
@ -348,7 +348,7 @@ mod tests {
// track comes last.
expected[1].albums[0].tracks.rotate_left(1);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))
@ -370,7 +370,7 @@ mod tests {
let output = artists_to_beets_string(&expected);
let result = Ok(output);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))
@ -400,7 +400,7 @@ mod tests {
];
let result = Ok(vec![]);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::function(move |x: &[String]| {
@ -431,7 +431,7 @@ mod tests {
output[2] = invalid_string.clone();
let result = Ok(output);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))
@ -462,7 +462,7 @@ mod tests {
output[2] = invalid_string.clone();
let result = Ok(output);
let mut executor = MockBeetsLibraryExecutor::new();
let mut executor = MockIBeetsLibraryExecutor::new();
executor
.expect_exec()
.with(predicate::eq(arguments))

14
src/library/mod.rs
View File

@ -10,6 +10,13 @@ use crate::Artist;
#[cfg(feature = "library-beets")]
pub mod beets;
/// Trait for interacting with the music library.
#[cfg_attr(test, automock)]
pub trait ILibrary {
/// List lirbary items that match the a specific query.
fn list(&mut self, query: &Query) -> Result<Vec<Artist>, Error>;
}
/// Individual fields that can be queried on.
#[derive(Debug, Hash, PartialEq, Eq)]
pub enum Field {
@ -103,13 +110,6 @@ impl From<Utf8Error> for Error {
}
}
/// Trait for interacting with the music library.
#[cfg_attr(test, automock)]
pub trait Library {
/// List lirbary items that match the a specific query.
fn list(&mut self, query: &Query) -> Result<Vec<Artist>, Error>;
}
#[cfg(test)]
mod tests {
use std::io;

32
src/main.rs
View File

@ -5,23 +5,23 @@ use ratatui::{backend::CrosstermBackend, Terminal};
use structopt::StructOpt;
use musichoard::{
collection::MhCollectionManager,
database::{
json::{backend::JsonDatabaseFileBackend, JsonDatabase},
Database,
IDatabase,
},
library::{
beets::{
executor::{ssh::BeetsLibrarySshExecutor, BeetsLibraryProcessExecutor},
BeetsLibrary,
},
Library,
ILibrary,
},
MusicHoard,
};
mod tui;
use tui::ui::MhUi;
use tui::{event::EventChannel, handler::TuiEventHandler, listener::TuiEventListener, Tui};
use tui::ui::Ui;
use tui::{event::EventChannel, handler::EventHandler, listener::EventListener, Tui};
#[derive(StructOpt)]
struct Opt {
@ -39,18 +39,18 @@ struct Opt {
database_file_path: PathBuf,
}
fn with<LIB: Library, DB: Database>(lib: LIB, db: DB) {
let collection_manager = MhCollectionManager::new(lib, db);
fn with<LIB: ILibrary, DB: IDatabase>(lib: LIB, db: DB) {
let music_hoard = MusicHoard::new(lib, db);
// Initialize the terminal user interface.
let backend = CrosstermBackend::new(io::stdout());
let terminal = Terminal::new(backend).expect("failed to initialise terminal");
let channel = EventChannel::new();
let listener = TuiEventListener::new(channel.sender());
let handler = TuiEventHandler::new(channel.receiver());
let listener = EventListener::new(channel.sender());
let handler = EventHandler::new(channel.receiver());
let ui = MhUi::new(collection_manager).expect("failed to initialise ui");
let ui = Ui::new(music_hoard).expect("failed to initialise ui");
// Run the TUI application.
Tui::run(terminal, ui, handler, listener).expect("failed to run tui");
@ -85,21 +85,9 @@ mod testlib;
#[cfg(test)]
mod tests {
use mockall::mock;
use once_cell::sync::Lazy;
use musichoard::collection::{self, Collection, CollectionManager};
use musichoard::*;
pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| collection!());
mock! {
pub CollectionManager {}
impl CollectionManager for CollectionManager {
fn rescan_library(&mut self) -> Result<(), collection::Error>;
fn save_to_database(&mut self) -> Result<(), collection::Error>;
fn get_collection(&self) -> &Collection;
}
}
}

16
src/tui/handler.rs
View File

@ -5,30 +5,30 @@ use mockall::automock;
use super::{
event::{Event, EventError, EventReceiver},
ui::Ui,
ui::IUi,
};
#[cfg_attr(test, automock)]
pub trait EventHandler<UI> {
pub trait IEventHandler<UI> {
fn handle_next_event(&self, ui: &mut UI) -> Result<(), EventError>;
}
trait EventHandlerPrivate<UI> {
trait IEventHandlerPrivate<UI> {
fn handle_key_event(ui: &mut UI, key_event: KeyEvent);
}
pub struct TuiEventHandler {
pub struct EventHandler {
events: EventReceiver,
}
// GRCOV_EXCL_START
impl TuiEventHandler {
impl EventHandler {
pub fn new(events: EventReceiver) -> Self {
TuiEventHandler { events }
EventHandler { events }
}
}
impl<UI: Ui> EventHandler<UI> for TuiEventHandler {
impl<UI: IUi> IEventHandler<UI> for EventHandler {
fn handle_next_event(&self, ui: &mut UI) -> Result<(), EventError> {
match self.events.recv()? {
Event::Key(key_event) => Self::handle_key_event(ui, key_event),
@ -39,7 +39,7 @@ impl<UI: Ui> EventHandler<UI> for TuiEventHandler {
}
}
impl<UI: Ui> EventHandlerPrivate<UI> for TuiEventHandler {
impl<UI: IUi> IEventHandlerPrivate<UI> for EventHandler {
fn handle_key_event(ui: &mut UI, key_event: KeyEvent) {
match key_event.code {
// Exit application on `ESC` or `q`.

30
src/tui/lib.rs Normal file
View File

@ -0,0 +1,30 @@
use musichoard::{database::IDatabase, library::ILibrary, Collection, MusicHoard};
#[cfg(test)]
use mockall::automock;
use super::Error;
#[cfg_attr(test, automock)]
pub trait IMusicHoard {
fn rescan_library(&mut self) -> Result<(), Error>;
fn get_collection(&self) -> &Collection;
}
impl From<musichoard::Error> for Error {
fn from(err: musichoard::Error) -> Error {
Error::Lib(err.to_string())
}
}
// GRCOV_EXCL_START
impl<LIB: ILibrary, DB: IDatabase> IMusicHoard for MusicHoard<LIB, DB> {
fn rescan_library(&mut self) -> Result<(), Error> {
Ok(MusicHoard::rescan_library(self)?)
}
fn get_collection(&self) -> &Collection {
MusicHoard::get_collection(self)
}
}
// GRCOV_EXCL_STOP

10
src/tui/listener.rs
View File

@ -7,22 +7,22 @@ use mockall::automock;
use super::event::{Event, EventError, EventSender};
#[cfg_attr(test, automock)]
pub trait EventListener {
pub trait IEventListener {
fn spawn(self) -> thread::JoinHandle<EventError>;
}
pub struct TuiEventListener {
pub struct EventListener {
events: EventSender,
}
// GRCOV_EXCL_START
impl TuiEventListener {
impl EventListener {
pub fn new(events: EventSender) -> Self {
TuiEventListener { events }
EventListener { events }
}
}
impl EventListener for TuiEventListener {
impl IEventListener for EventListener {
fn spawn(self) -> thread::JoinHandle<EventError> {
thread::spawn(move || {
loop {

92
src/tui/mod.rs
View File

@ -1,35 +1,30 @@
use crossterm::event::{DisableMouseCapture, EnableMouseCapture};
use crossterm::terminal::{self, EnterAlternateScreen, LeaveAlternateScreen};
use musichoard::collection;
use ratatui::backend::Backend;
use ratatui::Terminal;
use std::io;
use std::marker::PhantomData;
pub mod event;
pub mod handler;
pub mod listener;
pub mod ui;
mod lib;
use crossterm::event::{DisableMouseCapture, EnableMouseCapture};
use crossterm::terminal::{self, EnterAlternateScreen, LeaveAlternateScreen};
use ratatui::backend::Backend;
use ratatui::Terminal;
use std::io;
use std::marker::PhantomData;
use self::event::EventError;
use self::handler::EventHandler;
use self::listener::EventListener;
use self::ui::Ui;
use self::handler::IEventHandler;
use self::listener::IEventListener;
use self::ui::IUi;
#[derive(Debug, PartialEq, Eq)]
pub enum Error {
Collection(String),
Lib(String),
Io(String),
Event(String),
ListenerPanic,
}
impl From<collection::Error> for Error {
fn from(err: collection::Error) -> Error {
Error::Collection(err.to_string())
}
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Error {
Error::Io(err.to_string())
@ -47,7 +42,7 @@ pub struct Tui<B: Backend, UI> {
_phantom: PhantomData<UI>,
}
impl<B: Backend, UI: Ui> Tui<B, UI> {
impl<B: Backend, UI: IUi> Tui<B, UI> {
fn init(&mut self) -> Result<(), Error> {
self.terminal.hide_cursor()?;
self.terminal.clear()?;
@ -64,7 +59,7 @@ impl<B: Backend, UI: Ui> Tui<B, UI> {
self.exit();
}
fn main_loop(&mut self, mut ui: UI, handler: impl EventHandler<UI>) -> Result<(), Error> {
fn main_loop(&mut self, mut ui: UI, handler: impl IEventHandler<UI>) -> Result<(), Error> {
while ui.is_running() {
self.terminal.draw(|frame| ui.render(frame))?;
handler.handle_next_event(&mut ui)?;
@ -76,8 +71,8 @@ impl<B: Backend, UI: Ui> Tui<B, UI> {
fn main(
term: Terminal<B>,
ui: UI,
handler: impl EventHandler<UI>,
listener: impl EventListener,
handler: impl IEventHandler<UI>,
listener: impl IEventListener,
) -> Result<(), Error> {
let mut tui = Tui {
terminal: term,
@ -135,8 +130,8 @@ impl<B: Backend, UI: Ui> Tui<B, UI> {
pub fn run(
term: Terminal<B>,
ui: UI,
handler: impl EventHandler<UI>,
listener: impl EventListener,
handler: impl IEventHandler<UI>,
listener: impl IEventListener,
) -> Result<(), Error> {
Self::enable()?;
let result = Self::main(term, ui, handler, listener);
@ -160,16 +155,17 @@ impl<B: Backend, UI: Ui> Tui<B, UI> {
mod tests {
use std::{io, thread};
use musichoard::collection::{self, Collection};
use musichoard::Collection;
use ratatui::{backend::TestBackend, Terminal};
use crate::tests::{MockCollectionManager, COLLECTION};
use crate::tests::COLLECTION;
use super::{
event::EventError,
handler::MockEventHandler,
listener::MockEventListener,
ui::{MhUi, Ui},
handler::MockIEventHandler,
lib::MockIMusicHoard,
listener::MockIEventListener,
ui::{IUi, Ui},
Error, Tui,
};
@ -178,21 +174,17 @@ mod tests {
Terminal::new(backend).unwrap()
}
pub fn ui(collection: Collection) -> MhUi<MockCollectionManager> {
let mut collection_manager = MockCollectionManager::new();
pub fn ui(collection: Collection) -> Ui<MockIMusicHoard> {
let mut music_hoard = MockIMusicHoard::new();
collection_manager
.expect_rescan_library()
.returning(|| Ok(()));
collection_manager
.expect_get_collection()
.return_const(collection);
music_hoard.expect_rescan_library().returning(|| Ok(()));
music_hoard.expect_get_collection().return_const(collection);
MhUi::new(collection_manager).unwrap()
Ui::new(music_hoard).unwrap()
}
fn listener() -> MockEventListener {
let mut listener = MockEventListener::new();
fn listener() -> MockIEventListener {
let mut listener = MockIEventListener::new();
listener.expect_spawn().return_once(|| {
thread::spawn(|| {
thread::park();
@ -202,11 +194,11 @@ mod tests {
listener
}
fn handler() -> MockEventHandler<MhUi<MockCollectionManager>> {
let mut handler = MockEventHandler::new();
fn handler() -> MockIEventHandler<Ui<MockIMusicHoard>> {
let mut handler = MockIEventHandler::new();
handler
.expect_handle_next_event()
.return_once(|ui: &mut MhUi<MockCollectionManager>| {
.return_once(|ui: &mut Ui<MockIMusicHoard>| {
ui.quit();
Ok(())
});
@ -232,7 +224,7 @@ mod tests {
let listener = listener();
let mut handler = MockEventHandler::new();
let mut handler = MockIEventHandler::new();
handler
.expect_handle_next_event()
.return_once(|_| Err(EventError::Recv));
@ -254,10 +246,10 @@ mod tests {
let listener_handle: thread::JoinHandle<EventError> = thread::spawn(|| error);
while !listener_handle.is_finished() {}
let mut listener = MockEventListener::new();
let mut listener = MockIEventListener::new();
listener.expect_spawn().return_once(|| listener_handle);
let mut handler = MockEventHandler::new();
let mut handler = MockIEventHandler::new();
handler
.expect_handle_next_event()
.return_once(|_| Err(EventError::Recv));
@ -277,10 +269,10 @@ mod tests {
let listener_handle: thread::JoinHandle<EventError> = thread::spawn(|| panic!());
while !listener_handle.is_finished() {}
let mut listener = MockEventListener::new();
let mut listener = MockIEventListener::new();
listener.expect_spawn().return_once(|| listener_handle);
let mut handler = MockEventHandler::new();
let mut handler = MockIEventHandler::new();
handler
.expect_handle_next_event()
.return_once(|_| Err(EventError::Recv));
@ -292,12 +284,12 @@ mod tests {
#[test]
fn errors() {
let collection_err: Error = collection::Error::DatabaseError(String::from("")).into();
let lib_err: Error = musichoard::Error::DatabaseError(String::from("")).into();
let io_err: Error = io::Error::new(io::ErrorKind::Interrupted, "error").into();
let event_err: Error = EventError::Recv.into();
let listener_err = Error::ListenerPanic;
assert!(!format!("{:?}", collection_err).is_empty());
assert!(!format!("{:?}", lib_err).is_empty());
assert!(!format!("{:?}", io_err).is_empty());
assert!(!format!("{:?}", event_err).is_empty());
assert!(!format!("{:?}", listener_err).is_empty());

106
src/tui/ui.rs
View File

@ -1,7 +1,4 @@
use musichoard::{
collection::{Collection, CollectionManager},
Album, Artist, Track, TrackFormat,
};
use musichoard::{Album, Artist, Collection, Track, TrackFormat};
use ratatui::{
backend::Backend,
layout::{Alignment, Rect},
@ -10,7 +7,20 @@ use ratatui::{
Frame,
};
use super::Error;
use super::{lib::IMusicHoard, Error};
pub trait IUi {
fn is_running(&self) -> bool;
fn quit(&mut self);
fn increment_category(&mut self);
fn decrement_category(&mut self);
fn increment_selection(&mut self);
fn decrement_selection(&mut self);
fn render<B: Backend>(&mut self, frame: &mut Frame<'_, B>);
}
struct TrackSelection {
state: ListState,
@ -239,8 +249,8 @@ impl Selection {
}
}
pub struct MhUi<CM> {
collection_manager: CM,
pub struct Ui<MH> {
music_hoard: MH,
selection: Selection,
running: bool,
}
@ -428,12 +438,12 @@ impl<'a, 'b> TrackState<'a, 'b> {
}
}
impl<CM: CollectionManager> MhUi<CM> {
pub fn new(mut collection_manager: CM) -> Result<Self, Error> {
collection_manager.rescan_library()?;
let selection = Selection::new(Some(collection_manager.get_collection()));
Ok(MhUi {
collection_manager,
impl<MH: IMusicHoard> Ui<MH> {
pub fn new(mut music_hoard: MH) -> Result<Self, Error> {
music_hoard.rescan_library()?;
let selection = Selection::new(Some(music_hoard.get_collection()));
Ok(Ui {
music_hoard,
selection,
running: true,
})
@ -512,20 +522,7 @@ impl<CM: CollectionManager> MhUi<CM> {
}
}
pub trait Ui {
fn is_running(&self) -> bool;
fn quit(&mut self);
fn increment_category(&mut self);
fn decrement_category(&mut self);
fn increment_selection(&mut self);
fn decrement_selection(&mut self);
fn render<B: Backend>(&mut self, frame: &mut Frame<'_, B>);
}
impl<CM: CollectionManager> Ui for MhUi<CM> {
impl<MH: IMusicHoard> IUi for Ui<MH> {
fn is_running(&self) -> bool {
self.running
}
@ -544,19 +541,19 @@ impl<CM: CollectionManager> Ui for MhUi<CM> {
fn increment_selection(&mut self) {
self.selection
.increment_selection(self.collection_manager.get_collection());
.increment_selection(self.music_hoard.get_collection());
}
fn decrement_selection(&mut self) {
self.selection
.decrement_selection(self.collection_manager.get_collection());
.decrement_selection(self.music_hoard.get_collection());
}
fn render<B: Backend>(&mut self, frame: &mut Frame<'_, B>) {
let active = self.selection.active;
let areas = FrameArea::new(frame.size());
let artists = self.collection_manager.get_collection();
let artists = self.music_hoard.get_collection();
let artist_selection = &mut self.selection.artist;
let artist_state = ArtistState::new(
active == Category::Artist,
@ -600,7 +597,8 @@ impl<CM: CollectionManager> Ui for MhUi<CM> {
#[cfg(test)]
mod tests {
use crate::tests::{MockCollectionManager, COLLECTION};
use crate::tests::COLLECTION;
use crate::tui::lib::MockIMusicHoard;
use crate::tui::tests::{terminal, ui};
use super::*;
@ -759,17 +757,17 @@ mod tests {
#[test]
fn ui_running() {
let mut collection_manager = MockCollectionManager::new();
let mut music_hoard = MockIMusicHoard::new();
collection_manager
music_hoard
.expect_rescan_library()
.times(1)
.return_once(|| Ok(()));
collection_manager
music_hoard
.expect_get_collection()
.return_const(COLLECTION.to_owned());
let mut ui = MhUi::new(collection_manager).unwrap();
let mut ui = Ui::new(music_hoard).unwrap();
assert!(ui.is_running());
ui.quit();
@ -778,17 +776,17 @@ mod tests {
#[test]
fn ui_modifiers() {
let mut collection_manager = MockCollectionManager::new();
let mut music_hoard = MockIMusicHoard::new();
collection_manager
music_hoard
.expect_rescan_library()
.times(1)
.return_once(|| Ok(()));
collection_manager
music_hoard
.expect_get_collection()
.return_const(COLLECTION.to_owned());
let mut ui = MhUi::new(collection_manager).unwrap();
let mut ui = Ui::new(music_hoard).unwrap();
assert!(ui.is_running());
assert_eq!(ui.selection.active, Category::Artist);
@ -877,19 +875,17 @@ mod tests {
#[test]
fn app_no_tracks() {
let mut collection_manager = MockCollectionManager::new();
let mut music_hoard = MockIMusicHoard::new();
let mut collection = COLLECTION.to_owned();
collection[0].albums[0].tracks = vec![];
collection_manager
music_hoard
.expect_rescan_library()
.times(1)
.return_once(|| Ok(()));
collection_manager
.expect_get_collection()
.return_const(collection);
music_hoard.expect_get_collection().return_const(collection);
let mut app = MhUi::new(collection_manager).unwrap();
let mut app = Ui::new(music_hoard).unwrap();
assert!(app.is_running());
assert_eq!(app.selection.active, Category::Artist);
@ -915,19 +911,17 @@ mod tests {
#[test]
fn app_no_albums() {
let mut collection_manager = MockCollectionManager::new();
let mut music_hoard = MockIMusicHoard::new();
let mut collection = COLLECTION.to_owned();
collection[0].albums = vec![];
collection_manager
music_hoard
.expect_rescan_library()
.times(1)
.return_once(|| Ok(()));
collection_manager
.expect_get_collection()
.return_const(collection);
music_hoard.expect_get_collection().return_const(collection);
let mut app = MhUi::new(collection_manager).unwrap();
let mut app = Ui::new(music_hoard).unwrap();
assert!(app.is_running());
assert_eq!(app.selection.active, Category::Artist);
@ -966,18 +960,16 @@ mod tests {
#[test]
fn app_no_artists() {
let mut collection_manager = MockCollectionManager::new();
let mut music_hoard = MockIMusicHoard::new();
let collection = vec![];
collection_manager
music_hoard
.expect_rescan_library()
.times(1)
.return_once(|| Ok(()));
collection_manager
.expect_get_collection()
.return_const(collection);
music_hoard.expect_get_collection().return_const(collection);
let mut app = MhUi::new(collection_manager).unwrap();
let mut app = Ui::new(music_hoard).unwrap();
assert!(app.is_running());
assert_eq!(app.selection.active, Category::Artist);

2
tests/database/json.rs
View File

@ -3,7 +3,7 @@ use std::{fs, path::PathBuf};
use musichoard::{
database::{
json::{backend::JsonDatabaseFileBackend, JsonDatabase},
Database,
IDatabase,
},
Artist,
};

2
tests/library/beets.rs
View File

@ -9,7 +9,7 @@ use once_cell::sync::Lazy;
use musichoard::{
library::{
beets::{executor::BeetsLibraryProcessExecutor, BeetsLibrary},
Field, Library, Query,
Field, ILibrary, Query,
},
Artist,
};