121 lines
3.5 KiB
Rust
121 lines
3.5 KiB
Rust
use crate::structs::{Library, Shelf};
|
|
use std::{
|
|
fs,
|
|
io::{self, Write},
|
|
path::Path,
|
|
};
|
|
use xdg::BaseDirectories;
|
|
|
|
pub fn prompt(text: &str) -> Result<String, std::io::Error> {
|
|
print!("{} ", text);
|
|
std::io::stdout().flush()?;
|
|
|
|
let mut response = String::new();
|
|
std::io::stdin().read_line(&mut response);
|
|
|
|
Ok(response.trim_end().to_owned())
|
|
}
|
|
|
|
pub fn get_shelf_index(shelves: &Vec<Shelf>, id: &u8) -> Option<usize> {
|
|
shelves.iter().position(|shelf| shelf.id == *id)
|
|
}
|
|
|
|
pub fn deserialize_state_file() -> io::Result<Library> {
|
|
let xdg_dirs = get_xdg();
|
|
let state_file_path = xdg_dirs.place_state_file("shelf-state.json")?;
|
|
|
|
let state_file_content = match fs::read_to_string(state_file_path) {
|
|
Ok(content) => content,
|
|
Err(e) => {
|
|
eprintln!("Could not read state file: {}", e);
|
|
return Ok(initialize_library());
|
|
}
|
|
};
|
|
|
|
let state_file_decoded: Library = serde_json::from_str(&state_file_content)?;
|
|
|
|
Ok(state_file_decoded)
|
|
}
|
|
|
|
pub fn get_xdg() -> BaseDirectories {
|
|
let xdg_dirs = xdg::BaseDirectories::with_prefix("shelf");
|
|
return xdg_dirs;
|
|
}
|
|
|
|
pub fn get_state_file() -> io::Result<std::path::PathBuf> {
|
|
let xdg_dirs = get_xdg();
|
|
let state_file_path = xdg_dirs.place_state_file("shelf-state.json")?;
|
|
Ok(state_file_path)
|
|
}
|
|
|
|
pub fn save_library(library: Library) -> io::Result<()> {
|
|
let seralized_library = serde_json::to_string(&library).unwrap_or_default();
|
|
let state_file = get_state_file()?;
|
|
|
|
fs::write(state_file, seralized_library)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_current_shelf(library: &mut Library) -> &mut Shelf {
|
|
// Rust variable nonsense (get current shelf index)
|
|
let shelves = &library.shelves;
|
|
let current_shelf = &library.current_shelf;
|
|
let shelf_index = get_shelf_index(shelves, current_shelf).unwrap_or(0);
|
|
|
|
// Get current shelf index and push the file
|
|
let current_shelf = &mut library.shelves[*&shelf_index];
|
|
current_shelf.content.sort();
|
|
current_shelf.content.dedup();
|
|
return current_shelf;
|
|
}
|
|
|
|
pub fn initialize_library() -> Library {
|
|
let default_shelf: Shelf = Shelf {
|
|
id: 0,
|
|
name: "default".to_string(),
|
|
content: Vec::new(),
|
|
};
|
|
|
|
let mut shelf_vec: Vec<Shelf> = Vec::new();
|
|
shelf_vec.push(default_shelf);
|
|
let default_library: Library = Library {
|
|
current_shelf: 0,
|
|
shelves: shelf_vec,
|
|
};
|
|
return default_library;
|
|
}
|
|
|
|
pub fn match_file_name(file_name: &str, shelf: &mut Shelf) -> Result<usize, std::io::Error> {
|
|
// Turn given file into string
|
|
let match_path = Path::new(file_name);
|
|
|
|
// Check if there is a match in the shelf before taking the path verbatim
|
|
let file_ending = match_path.file_name().expect("Error getting file name");
|
|
// For every entry in current shelf
|
|
for (i, path) in shelf.content.iter().enumerate() {
|
|
// Turn the string back into a path
|
|
let shelf_path = Path::new(path).canonicalize()?;
|
|
|
|
if shelf_path.ends_with(file_ending) {
|
|
return Ok(i);
|
|
};
|
|
}
|
|
|
|
if match_path.exists() {
|
|
let cannonical_path = match_path.canonicalize()?;
|
|
|
|
for (i, path) in shelf.content.iter().enumerate() {
|
|
let shelf_path = Path::new(path).canonicalize()?;
|
|
if cannonical_path == shelf_path {
|
|
return Ok(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(io::Error::new(
|
|
io::ErrorKind::NotFound,
|
|
format!("File not Found in Shelf \"{}\": {file_name}", shelf.name),
|
|
))
|
|
}
|