Refactor Paths

Store `Strings` instead of `PathBuf`s, add `view_options_file` prop, and use the paths struct in more places

Author: probablykasper

ferrum-addon/addon.d.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 export declare class ItunesImport {
   static new(): ItunesImport
-  start(path: string, tracksDir: string): Promise<ImportStatus>
+  start(path: string): Promise<ImportStatus>
   finish(): void
 }
 
@@ -53,7 +53,7 @@ export declare function get_genres(): Array<string>
 
 export declare function get_image(index: number): JsImage | null
 
-export declare function get_paths(): PathsJs
+export declare function get_paths(): Paths
 
 export declare function get_track(id: string): Track
 
@@ -99,13 +99,15 @@ export declare function move_tracks(playlistId: string, itemIds: Array<ItemId>,
 
 export declare function new_playlist(name: string, description: string, isFolder: boolean, parentId: string): void
 
-export interface PathsJs {
+export interface Paths {
+  pathSeparator: string
   libraryDir: string
   tracksDir: string
   libraryJson: string
+  cacheDir: string
   cacheDb: string
   localDataDir: string
-  pathSeparator: string
+  viewOptionsFile: string
 }
 
 export interface Playlist {

src-native/data.rs

@@ -7,9 +7,16 @@ use dirs_next;
 use serde::Serialize;
 use std::env;
 use std::io::Write;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::time::Instant;
 
+pub fn path_to_string<P: AsRef<Path>>(path: P) -> String {
+	path.as_ref()
+		.to_str()
+		.expect("Invalid path str")
+		.to_string()
+}
+
 pub struct Data {
 	pub paths: Paths,
 	pub library: Library,
@@ -62,19 +69,22 @@ impl Data {
 				.context("Local data folder not found")?
 				.join("space.kasper.ferrum");
 		};
+		let local_data_dir = match local_data_path {
+			Some(path) => PathBuf::from(path),
+			None => local_data_dir,
+		};
 		if let Some(library_path) = library_path {
 			library_dir = PathBuf::from(library_path);
 		}
 		let paths = Paths {
-			library_dir: library_dir.clone(),
-			tracks_dir: library_dir.join("Tracks"),
-			library_json: library_dir.join("Library.json"),
-			cache_dir: cache_dir.clone(),
-			cache_db: cache_dir.join("Cache.redb"),
-			local_data_dir: match local_data_path {
-				Some(path) => PathBuf::from(path),
-				None => local_data_dir,
-			},
+			path_separator: std::path::MAIN_SEPARATOR_STR.into(),
+			library_dir: path_to_string(&library_dir),
+			tracks_dir: path_to_string(library_dir.join("Tracks")),
+			library_json: path_to_string(library_dir.join("Library.json")),
+			cache_dir: path_to_string(&cache_dir),
+			cache_db: path_to_string(cache_dir.join("Cache.redb")),
+			local_data_dir: path_to_string(&local_data_dir),
+			view_options_file: path_to_string(local_data_dir.join("view.json")),
 		};
 
 		let loaded_library = load_library(&paths)?;

src-native/data_js.rs

@@ -1,5 +1,6 @@
 use crate::FerrumStatus;
 use crate::data::Data;
+use crate::library::Paths;
 use anyhow::Result;
 use napi::Env;
 use rfd::MessageDialog;
@@ -56,28 +57,11 @@ pub fn load_data(
 	return Ok(());
 }
 
-#[napi(object)]
-pub struct PathsJs {
-	pub library_dir: String,
-	pub tracks_dir: String,
-	pub library_json: String,
-	pub cache_db: String,
-	pub local_data_dir: String,
-	pub path_separator: String,
-}
-
 #[napi(js_name = "get_paths")]
 #[allow(dead_code)]
-pub fn get_paths(env: Env) -> PathsJs {
-	let data: &mut Data = get_data(&env);
-	PathsJs {
-		library_dir: data.paths.library_dir.to_string_lossy().into(),
-		tracks_dir: data.paths.tracks_dir.to_string_lossy().into(),
-		library_json: data.paths.library_json.to_string_lossy().into(),
-		cache_db: data.paths.cache_db.to_string_lossy().into(),
-		local_data_dir: data.paths.local_data_dir.to_string_lossy().into(),
-		path_separator: std::path::MAIN_SEPARATOR_STR.into(),
-	}
+pub fn get_paths(env: Env) -> Paths {
+	let data: &Data = get_data(&env);
+	data.paths.clone()
 }
 
 #[napi(js_name = "save")]

src-native/itunes_import.rs

@@ -1,5 +1,6 @@
 use crate::data_js::get_data;
 use crate::get_now_timestamp;
+use crate::library::Paths;
 use crate::library_types::{
 	CountObject, Folder, Library, Playlist, Track, TrackList, new_item_ids_from_track_ids,
 };
@@ -11,7 +12,7 @@ use napi::Env;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::sync::Mutex;
 use time::OffsetDateTime;
 use time::serde::iso8601;
@@ -319,11 +320,7 @@ fn parse_file_url(value: &str) -> Result<PathBuf> {
 }
 
 /// Parses track but does not move it to `tracks_dir`
-fn parse_track(
-	xml_track: XmlTrack,
-	start_time: i64,
-	tracks_dir: &Path,
-) -> Result<(PathBuf, Track)> {
+fn parse_track(xml_track: XmlTrack, start_time: i64, paths: &Paths) -> Result<(PathBuf, Track)> {
 	let xml_location = xml_track.location.context("Missing track location")?;
 	if xml_track.track_type != Some("File".to_string()) {
 		bail!(
@@ -358,7 +355,7 @@ fn parse_track(
 
 	let name = xml_track.name.unwrap_or_default();
 	let artist = xml_track.artist.unwrap_or_default();
-	let filename = generate_filename(tracks_dir, &artist, &name, file_type.file_extension());
+	let filename = generate_filename(&paths, &artist, &name, file_type.file_extension());
 
 	let track = Track {
 		size: file_md.len() as i64,
@@ -584,6 +581,7 @@ pub struct ItunesImport {
 	new_library: Mutex<Option<Library>>,
 	/// iTunes path -> Ferrum file
 	itunes_track_paths: Mutex<HashMap<PathBuf, String>>,
+	paths: Paths,
 }
 #[napi]
 impl ItunesImport {
@@ -593,18 +591,19 @@ impl ItunesImport {
 		Ok(Self {
 			new_library: Some(data.library.clone()).into(),
 			itunes_track_paths: HashMap::new().into(),
+			paths: data.paths.clone(),
 		})
 	}
 	#[napi]
-	pub async fn start(&self, path: String, tracks_dir: String) -> napi::Result<ImportStatus> {
-		Ok(import_itunes(self, path, tracks_dir).await?)
+	pub async fn start(&self, path: String) -> napi::Result<ImportStatus> {
+		Ok(import_itunes(self, path).await?)
 	}
 	#[napi]
 	pub fn finish(&mut self, env: Env) -> napi::Result<()> {
 		let data = get_data(&env);
 		let itunes_track_paths = &mut *self.itunes_track_paths.lock().unwrap();
 		for (itunes_path, ferrum_file) in itunes_track_paths {
-			let new_path = data.paths.tracks_dir.join(ferrum_file);
+			let new_path = data.paths.get_track_file_path(ferrum_file);
 			fs::copy(itunes_path, new_path).context("Error copying file")?;
 		}
 		let new_library = &mut self.new_library.lock().unwrap();
@@ -613,11 +612,7 @@ impl ItunesImport {
 	}
 }
 
-pub async fn import_itunes(
-	itunes_import: &ItunesImport,
-	path: String,
-	tracks_dir: String,
-) -> Result<ImportStatus> {
+async fn import_itunes(itunes_import: &ItunesImport, path: String) -> Result<ImportStatus> {
 	let new_library_lock = &mut *itunes_import.new_library.lock().unwrap();
 	let mut library = match new_library_lock {
 		Some(library) => library,
@@ -663,7 +658,7 @@ pub async fn import_itunes(
 			errors.push(format!("Missing track artist: {artist_title}"));
 		}
 
-		match parse_track(xml_track, start_time, Path::new(&tracks_dir)) {
+		match parse_track(xml_track, start_time, &itunes_import.paths) {
 			Ok((xml_track_path, track)) => {
 				let generated_id = library.generate_id();
 				// immediately insert into library so new generated ids are unique

src-native/lib.rs

@@ -2,7 +2,6 @@ use anyhow::{Context, Result};
 use serde::de::DeserializeOwned;
 use std::fs::File;
 use std::io::BufReader;
-use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[macro_use]
@@ -58,7 +57,7 @@ fn str_to_option(s: String) -> Option<String> {
 	}
 }
 
-fn path_to_json<J>(path: PathBuf) -> Result<J>
+fn path_to_json<J>(path: &str) -> Result<J>
 where
 	J: DeserializeOwned,
 {

src-native/library.rs

@@ -3,21 +3,23 @@ use crate::data_js::get_data;
 use crate::library_types::{Library, VersionedLibrary};
 use anyhow::{Context, Result, bail};
 use napi::Env;
-use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use std::fs::{File, create_dir_all};
 use std::io::{ErrorKind, Read};
 use std::path::PathBuf;
 use std::time::Instant;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Clone)]
+#[napi(object)]
 pub struct Paths {
-	pub library_dir: PathBuf,
-	pub tracks_dir: PathBuf,
-	pub library_json: PathBuf,
-	pub cache_dir: PathBuf,
-	pub cache_db: PathBuf,
-	pub local_data_dir: PathBuf,
+	pub path_separator: String,
+	pub library_dir: String,
+	pub tracks_dir: String,
+	pub library_json: String,
+	pub cache_dir: String,
+	pub cache_db: String,
+	pub local_data_dir: String,
+	pub view_options_file: String,
 }
 impl Paths {
 	fn ensure_dirs_exists(&self) -> Result<()> {
@@ -27,6 +29,9 @@ impl Paths {
 		create_dir_all(&self.cache_dir)?;
 		return Ok(());
 	}
+	pub fn get_track_file_path(&self, file: &str) -> PathBuf {
+		PathBuf::from(&self.tracks_dir).join(file)
+	}
 }
 
 pub fn load_library(paths: &Paths) -> Result<Library> {
@@ -35,10 +40,7 @@ pub fn load_library(paths: &Paths) -> Result<Library> {
 	paths
 		.ensure_dirs_exists()
 		.context("Error ensuring folder exists")?;
-	println!(
-		"Loading library at path: {}",
-		paths.library_dir.to_string_lossy()
-	);
+	println!("Loading library at path: {}", paths.library_dir);
 
 	let mut library_file = match File::open(&paths.library_json) {
 		Ok(file) => file,

src-native/library_types.rs

@@ -1,5 +1,6 @@
 #![allow(non_snake_case)]
 
+use crate::library::Paths;
 use crate::playlists::{delete_file, remove_from_all_playlists};
 use crate::{FerrumStatus, get_now_timestamp};
 use anyhow::{Context, Result, bail};
@@ -8,7 +9,6 @@ use nanoid::nanoid;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::HashSet;
-use std::path::PathBuf;
 use std::sync::RwLock;
 use std::time::Instant;
 
@@ -138,14 +138,10 @@ impl Library {
 		track_id_map.push(id.clone());
 		self.track_item_ids.insert(id, item_id);
 	}
-	pub fn delete_track_and_file(
-		&mut self,
-		id: &TrackID,
-		tracks_dir: &PathBuf,
-	) -> Result<FerrumStatus> {
+	pub fn delete_track_and_file(&mut self, id: &TrackID, paths: &Paths) -> Result<FerrumStatus> {
 		let file_path = {
 			let track = self.get_track(id)?;
-			tracks_dir.join(&track.file)
+			paths.get_track_file_path(&track.file)
 		};
 		if !file_path.exists() {
 			return Ok(FerrumStatus::FileDeletionError(format!(

src-native/playlists.rs

@@ -221,7 +221,7 @@ pub fn delete_tracks_with_item_ids(item_ids: Vec<ItemId>, env: Env) -> Result<Fe
 	let library = &mut data.library;
 	let track_ids = get_track_ids_from_item_ids(&item_ids);
 	for track_id in &track_ids {
-		let status = library.delete_track_and_file(track_id, &data.paths.tracks_dir)?;
+		let status = library.delete_track_and_file(track_id, &data.paths)?;
 		if status.is_err() {
 			return Ok(status);
 		}

src-native/tracks/import.rs

@@ -2,7 +2,7 @@ use crate::data::Data;
 use crate::library_types::Track;
 use crate::sys_time_to_timestamp;
 use crate::tracks::generate_filename;
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use lofty::file::{AudioFile, TaggedFileExt};
 use lofty::tag::{Accessor, ItemKey, TagExt};
 use std::fs;
@@ -94,14 +94,13 @@ pub fn import(data: &Data, track_path: &Path, now: i64) -> Result<Track> {
 	};
 	let artist = tag.artist().map(|s| s.into_owned()).unwrap_or_default();
 
-	let tracks_dir = &data.paths.tracks_dir;
 	let extension = match FileType::from_path(track_path)? {
 		FileType::Opus => "opus",
 		FileType::M4a => "m4a",
 		FileType::Mp3 => "mp3",
 	};
-	let filename = generate_filename(tracks_dir, &artist, &title, extension);
-	let dest_path = tracks_dir.join(&filename);
+	let filename = generate_filename(&data.paths, &artist, &title, extension);
+	let dest_path = data.paths.get_track_file_path(&filename);
 
 	fs::copy(track_path, &dest_path).context("Error copying file")?;
 	println!(

src-native/tracks/md.rs

@@ -1,12 +1,12 @@
 #![allow(non_snake_case)]
 
 use super::{Tag, generate_filename};
+use crate::library::Paths;
 use crate::library_types::Track;
 use crate::{get_now_timestamp, str_to_option};
 use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
 use std::fs;
-use std::path::PathBuf;
 
 #[derive(Serialize, Deserialize, Debug)]
 #[napi(object)]
@@ -32,12 +32,12 @@ pub struct TrackMD {
 }
 
 pub fn update_track_info(
-	tracks_dir: &PathBuf,
+	paths: &Paths,
 	track: &mut Track,
 	tag: &mut Tag,
 	new_info: TrackMD,
 ) -> Result<()> {
-	let old_path = tracks_dir.join(&track.file);
+	let old_path = paths.get_track_file_path(&track.file);
 	if !old_path.exists() {
 		bail!("File does not exist: {}", track.file);
 	}
@@ -146,8 +146,8 @@ pub fn update_track_info(
 
 	// move file
 	if new_name != track.name || new_artist != track.artist {
-		let new_filename = generate_filename(tracks_dir, &new_artist, &new_name, &ext);
-		let new_path = tracks_dir.join(&new_filename);
+		let new_filename = generate_filename(&paths, &new_artist, &new_name, &ext);
+		let new_path = paths.get_track_file_path(&new_filename);
 		match fs::rename(old_path, new_path) {
 			Ok(_) => {
 				track.file = new_filename;