#22 Add relative plots for albums and songs

src/main.rs

@@ -120,4 +120,8 @@ fn test(entries: &SongEntries) {
 #[allow(dead_code)]
 fn test_plot(entries: &SongEntries) {
  plot::absolute::artist(entries, &types::Artist::from_str("Sabaton"));
+
+ let coat = types::Album::from_str("Coat of Arms", "Sabaton");
+ plot::relative::to_all(entries, &coat);
+ plot::relative::to_artist(entries, &coat);
 }

src/plot.rs

@@ -9,7 +9,9 @@ use plotly::{Layout, Plot, Scatter};
 /// Responsible for plotting absolute plots
 pub mod absolute;
 
-/// Responsible for plotting plots relative to sum of plays
+/// Responsible for plotting relative plots
+///
+/// Either to all plays, the artist or the album
 pub mod relative;
 
 /// Creates a plot in a `plots/` folder

src/plot/relative.rs

@@ -1,30 +1,93 @@
 use super::{create_plot, find_dates};
 use crate::display::date;
-use crate::types::{Artist, SongEntries};
+use crate::types::{HasArtist, Music, Song, SongEntries};
 
-/// Creates a plot of the amount of plays of an [`Artist`] relative to all plays
+/// Creates a plot of the amount of plays of a [`Music`] relative to all plays
 ///
 /// Opens the plot in the browser
-pub fn artist(entries: &SongEntries, art: &Artist) {
+pub fn to_all<Asp: Music>(entries: &SongEntries, aspect: &Asp) {
  let mut times = Vec::<i64>::new();
  // percentages relative to the sum of all plays
  let mut plays = Vec::<f64>::new();
 
  // TODO!
  // each data point lies at the occurrence -> looks weird when you haven't listened in a long time
  // maybe make it so there's at least a data point once a week?
- let dates = find_dates(entries, art, false);
+ let dates = find_dates(entries, aspect, false);
 
  let start = dates.first().unwrap();
  let sum_start = &entries.first_date();
 
  #[allow(clippy::cast_precision_loss)]
  for date in &dates {
  times.push(date.timestamp());
- let sum_of_plays = date::gather_plays(entries, art, start, date) as f64;
+ let sum_of_plays = date::gather_plays(entries, aspect, start, date) as f64;
  let sum_of_all_plays = date::sum_plays(entries, sum_start, date) as f64;
- plays.push(sum_of_plays / sum_of_all_plays);
+ // *100 so that the percentage is easier to read...
+ plays.push(100.0 * (sum_of_plays / sum_of_all_plays));
  }
 
- create_plot(times, plays, format!("{art} - relative").as_str());
+ let title = format!("{aspect} | relative to all plays");
+ create_plot(times, plays, title.as_str());
+}
+
+/// Creates a plot of the amount of plays of an [`Album`] or [`Song`]
+/// relative to total plays of the affiated [`Artist`]
+///
+/// Opens the plot in the browser
+pub fn to_artist<Asp: HasArtist>(entries: &SongEntries, aspect: &Asp) {
+ let mut times = Vec::<i64>::new();
+ // percentages relative to the sum of all plays
+ let mut plays = Vec::<f64>::new();
+
+ // TODO!
+ // each data point lies at the occurrence -> looks weird when you haven't listened in a long time
+ // maybe make it so there's at least a data point once a week?
+ let dates = find_dates(entries, aspect, false);
+
+ let start = dates.first().unwrap();
+ let sum_start = &entries.first_date();
+
+ #[allow(clippy::cast_precision_loss)]
+ for date in &dates {
+ times.push(date.timestamp());
+ let sum_of_plays = date::gather_plays(entries, aspect, start, date) as f64;
+ let sum_of_artist_plays =
+ date::gather_plays(entries, aspect.artist(), sum_start, date) as f64;
+ // *100 so that the percentage is easier to read...
+ plays.push(100.0 * (sum_of_plays / sum_of_artist_plays));
+ }
+
+ let title = format!("{aspect} | relative to the artist");
+ create_plot(times, plays, title.as_str());
+}
+
+/// Creates a plot of the amount of plays of a [`Song`]
+/// relative to total plays of the affiated [`Album`]
+///
+/// Opens the plot in the browser
+pub fn to_album(entries: &SongEntries, aspect: &Song) {
+ let mut times = Vec::<i64>::new();
+ // percentages relative to the sum of all plays
+ let mut plays = Vec::<f64>::new();
+
+ // TODO!
+ // each data point lies at the occurrence -> looks weird when you haven't listened in a long time
+ // maybe make it so there's at least a data point once a week?
+ let dates = find_dates(entries, aspect, false);
+
+ let start = dates.first().unwrap();
+ let sum_start = &entries.first_date();
+
+ #[allow(clippy::cast_precision_loss)]
+ for date in &dates {
+ times.push(date.timestamp());
+ let sum_of_plays = date::gather_plays(entries, aspect, start, date) as f64;
+ let sum_of_album_plays = date::gather_plays(entries, &aspect.album, sum_start, date) as f64;
+ // *100 so that the percentage is easier to read...
+ plays.push(100.0 * (sum_of_plays / sum_of_album_plays));
+ }
+
+ let title = format!("{aspect} | relative to the album");
+ create_plot(times, plays, title.as_str());
 }

src/types.rs

@@ -58,6 +58,12 @@ pub trait Music: Display {
  fn is_entry(&self, entry: &SongEntry) -> bool;
 }
 
+/// Trait used to accept both [`Album`] and [`Song`]
+pub trait HasArtist: Music {
+ /// Returns a reference to the corresponding [`Artist`]
+ fn artist(&self) -> &Artist;
+}
+
 /// Struct for representing an artist
 #[derive(PartialEq, Eq, Hash, Debug, Clone)]
 pub struct Artist {
@@ -125,6 +131,11 @@ impl Music for Album {
  entry.artist.eq(&self.artist.name) && entry.album.eq(&self.name)
  }
 }
+impl HasArtist for Album {
+ fn artist(&self) -> &Artist {
+ &self.artist
+ }
+}
 
 /// Struct for representing a song
 // to allow for custom HashMap key
@@ -170,6 +181,11 @@ impl Music for Song {
  && entry.track.eq(&self.name)
  }
 }
+impl HasArtist for Song {
+ fn artist(&self) -> &Artist {
+ &self.album.artist
+ }
+}
 
 /// A more specific version of [`parse::Entry`]
 /// utilized by many functions here.
@@ -276,9 +292,19 @@ impl SongEntries {
  plot::absolute::artist(self, art);
  }
 
- /// Creates a plot of the artist relative to the total amount of plays
- pub fn plot_artist_relative(&self, art: &Artist) {
- plot::relative::artist(self, art);
+ /// Creates a plot of the `aspect` relative to the total amount of plays
+ pub fn plot_relative<Asp: Music>(&self, aspect: &Asp) {
+ plot::relative::to_all(self, aspect);
+ }
+
+ /// Creates a plot of the `aspect` relative to the plays of the artist
+ pub fn plot_relative_to_artist<Asp: HasArtist>(&self, aspect: &Asp) {
+ plot::relative::to_artist(self, aspect);
+ }
+
+ /// Creates a plot of the [`Song`] relative to the plays of the album
+ pub fn plot_relative_to_album(&self, song: &Song) {
+ plot::relative::to_album(self, song);
  }
 
  /// Adds search capability

src/ui.rs

@@ -31,6 +31,32 @@ const PROMPT_MAIN: &str = " >> ";
 /// red ` >` with [`ShellHelper`]
 const PROMPT_SECONDARY: &str = " > ";
 
+/// Errors raised by [`match_plot_album_relative()`] and
+/// [`match_plot_song_relative`]
+///
+/// when user argument for relative to what is invalid
+#[derive(Debug)]
+enum InvalidArgumentError {
+ /// Error message: Invalid argument! Try using 'all' or 'artist' next time
+ Artist,
+ /// Error message: Invalid argument! Try using 'all', 'artist' or 'album' next time
+ Album,
+}
+impl std::fmt::Display for InvalidArgumentError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ InvalidArgumentError::Artist => {
+ write!(f, "Invalid argument! Try using 'all' or 'artist' next time")
+ }
+ InvalidArgumentError::Album => write!(
+ f,
+ "Invalid argument! Try using 'all', 'artist' or 'album' next time"
+ ),
+ }
+ }
+}
+impl Error for InvalidArgumentError {}
+
 /// Helper for [`Editor`]
 #[derive(Completer, Helper, Hinter, Validator)]
 struct ShellHelper;
@@ -133,7 +159,8 @@ pub fn start(entries: &SongEntries) {
 
 /// Handles errors thrown by [`match_input()`] in [`start()`]
 ///
-/// Prints error messages for [`NotFoundError`],
+/// Prints error messages for
+/// [`NotFoundError`], [`InvalidArgumentError`]
 /// [`ParseError`][`chrono::format::ParseError`],
 /// and [`ParseIntError`][`std::num::ParseIntError`]
 #[allow(clippy::borrowed_box)]
@@ -142,6 +169,7 @@ fn handle_error(err: &Box<dyn Error>) {
  // also thx ChatGPT
  match err.as_ref() {
  not_found if not_found.is::<NotFoundError>() => eprintln!("{not_found}"),
+ invalid_arg if invalid_arg.is::<InvalidArgumentError>() => eprintln!("{invalid_arg}"),
  date if date.is::<chrono::format::ParseError>() => {
  eprintln!("Invalid date! Make sure you input the date in YYYY-MM-DD format.");
  }
@@ -175,6 +203,8 @@ fn match_input(
  "print top songs" | "ptsons" => match_print_top(entries, rl, &Aspect::Songs)?,
  "plot artist" | "gart" => match_plot_artist(entries, rl)?,
  "plot artist relative" | "gartr" => match_plot_artist_relative(entries, rl)?,
+ "plot album relative" | "galbr" => match_plot_album_relative(entries, rl)?,
+ "plot song relative" | "gsonr" => match_plot_song_relative(entries, rl)?,
  // when you press ENTER -> nothing happens, new prompt
  "" => (),
  _ => {
@@ -451,7 +481,71 @@ fn match_plot_artist_relative(
  let usr_input_art = rl.readline(PROMPT_MAIN)?;
  let art = entries.find().artist(&usr_input_art)?;
 
- entries.plot_artist_relative(&art);
+ entries.plot_relative(&art);
+ Ok(())
+}
+
+/// Used by [`match_input()`] for `plot album relative` command
+fn match_plot_album_relative(
+ entries: &SongEntries,
+ rl: &mut Editor<ShellHelper, FileHistory>,
+) -> Result<(), Box<dyn Error>> {
+ // 1st prompt: artist name
+ println!("Artist name?");
+ let usr_input_art = rl.readline(PROMPT_MAIN)?;
+ let art = entries.find().artist(&usr_input_art)?;
+
+ // 2nd prompt: album name
+ println!("Album name?");
+ let usr_input_alb = rl.readline(PROMPT_MAIN)?;
+ let alb = entries.find().album(&usr_input_alb, &art.name)?;
+
+ // 3rd prompt: relative to what
+ println!("Relative to all or artist?");
+ let usr_input_rel = rl.readline(PROMPT_SECONDARY)?;
+
+ match usr_input_rel.as_str() {
+ "all" => entries.plot_relative(&alb),
+ "artist" => entries.plot_relative_to_artist(&alb),
+ _ => return Err(Box::new(InvalidArgumentError::Artist)),
+ }
+
+ Ok(())
+}
+
+/// Used by [`match_input()`] for `plot song relative` command
+fn match_plot_song_relative(
+ entries: &SongEntries,
+ rl: &mut Editor<ShellHelper, FileHistory>,
+) -> Result<(), Box<dyn Error>> {
+ // 1st prompt: artist name
+ println!("Artist name?");
+ let usr_input_art = rl.readline(PROMPT_MAIN)?;
+ let art = entries.find().artist(&usr_input_art)?;
+
+ // 2nd prompt: album name
+ println!("Album name?");
+ let usr_input_alb = rl.readline(PROMPT_MAIN)?;
+ let alb = entries.find().album(&usr_input_alb, &art.name)?;
+
+ // 3rd prompt: song name
+ println!("Song name?");
+ let usr_input_son = rl.readline(PROMPT_MAIN)?;
+ let son = entries
+ .find()
+ .song_from_album(&usr_input_son, &alb.name, &alb.artist.name)?;
+
+ // 4th prompt: relative to what
+ println!("Relative to all, artist or album?");
+ let usr_input_rel = rl.readline(PROMPT_SECONDARY)?;
+
+ match usr_input_rel.as_str() {
+ "all" => entries.plot_relative(&son),
+ "artist" => entries.plot_relative_to_artist(&son),
+ "album" => entries.plot_relative_to_album(&son),
+ _ => return Err(Box::new(InvalidArgumentError::Album)),
+ }
+
  Ok(())
 }
 

src/ui/help.rs

@@ -208,6 +208,20 @@ fn plot_commands<'a>() -> Vec<[&'a str; 3]> {
  "creates a plot of the amount of plays of the given artist
  relative to all plays and opens it in the web browser",
  ],
+ [
+ "plot album relative",
+ "gartr",
+ "creates a plot of the amount of plays of the given album
+ relative to all plays or the artist
+ and opens it in the web browser",
+ ],
+ [
+ "plot song relative",
+ "gartr",
+ "creates a plot of the amount of plays of the given album
+ relative to all plays, the artist or the album
+ and opens it in the web browser",
+ ],
  ]
 }