From bdb3a5f2b45a0bed26963a1323fab5f378f49167 Mon Sep 17 00:00:00 2001 From: mxve <68632137+mxve@users.noreply.github.com> Date: Sun, 1 Sep 2024 08:11:00 +0200 Subject: [PATCH] cleanup misc --- src/main.rs | 2 +- src/misc.rs | 113 ++++++++++++++++++++++--------------------------- src/structs.rs | 2 +- 3 files changed, 53 insertions(+), 64 deletions(-) diff --git a/src/main.rs b/src/main.rs index 02b037e..d6e0c05 100644 --- a/src/main.rs +++ b/src/main.rs @@ -13,7 +13,7 @@ use structs::*; #[macro_use] extern crate simple_log; -use colored::*; +use colored::Colorize; use indicatif::ProgressBar; #[cfg(windows)] use mslnk::ShellLink; diff --git a/src/misc.rs b/src/misc.rs index ac1ccb1..4720be8 100644 --- a/src/misc.rs +++ b/src/misc.rs @@ -1,18 +1,18 @@ use indicatif::{ProgressBar, ProgressStyle}; use std::{ - fs::{self, OpenOptions}, - io::Write, - path::Path, + fs::{self, File}, + io::Read, + path::{Path, PathBuf}, }; use crate::{global, structs}; -pub fn file_blake3(file: &std::path::Path) -> std::io::Result { +pub fn file_blake3(file: &Path) -> std::io::Result { let mut blake3 = blake3::Hasher::new(); - let mut file = std::fs::File::open(file)?; + let mut file = File::open(file)?; let mut buffer = [0; 1024]; loop { - let n = std::io::Read::read(&mut file, &mut buffer)?; + let n = file.read(&mut buffer)?; if n == 0 { break; } @@ -52,14 +52,14 @@ pub fn human_readable_bytes(bytes: u64) -> String { } pub fn pb_style_download(pb: &ProgressBar, state: bool) { - if state { - pb.set_style( - ProgressStyle::with_template("{spinner:.magenta} {msg:.magenta} > {bytes}/{total_bytes} | {bytes_per_sec} | {eta}") - .unwrap(), - ); + let style = if state { + ProgressStyle::with_template( + "{spinner:.magenta} {msg:.magenta} > {bytes}/{total_bytes} | {bytes_per_sec} | {eta}", + ) } else { - pb.set_style(ProgressStyle::with_template("{spinner:.magenta} {msg}").unwrap()); - } + ProgressStyle::with_template("{spinner:.magenta} {msg}") + }; + pb.set_style(style.unwrap()); } pub fn cute_path(path: &Path) -> String { @@ -68,15 +68,16 @@ pub fn cute_path(path: &Path) -> String { #[cfg(unix)] pub fn is_program_in_path(program: &str) -> bool { - if let Ok(path) = std::env::var("PATH") { - for p in path.split(':') { - let p_str = format!("{p}/{program}"); - if fs::metadata(p_str).is_ok() { - return true; - } - } - } - false + std::env::var_os("PATH") + .map(|paths| { + paths.to_str().map(|paths| { + paths + .split(':') + .any(|dir| fs::metadata(format!("{}/{}", dir, program)).is_ok()) + }) + }) + .flatten() + .unwrap_or(false) } #[macro_export] @@ -99,22 +100,20 @@ macro_rules! println_error { fn install_dependency(path: &Path, args: &[&str]) { if path.exists() { match runas::Command::new(path).args(args).status() { + Ok(status) if status.success() || matches!(status.code(), Some(1638) | Some(3010)) => { + info!("{} installed successfully", path.display()); + } Ok(status) => { - if !status.success() && !matches!(status.code(), Some(1638) | Some(3010)) { - println_error!("Error installing dependency {}, {status}", path.display()); - } else { - info!("{} installed successfully", path.display()); - } + println_error!("Error installing dependency {}, {status}", path.display()); + } + Err(e) if e.raw_os_error() == Some(740) => { + println_error!( + "Error: Process requires elevation. Please run the launcher as administrator or install {} manually", + path.display() + ); } Err(e) => { - if let Some(740) = e.raw_os_error() { - println_error!( - "Error: Process requires elevation. Please run the launcher as administrator or install {} manually", - path.display() - ); - } else { - println_error!("Error running file {}: {e}", path.display()); - } + println_error!("Error running file {}: {e}", path.display()); } } } else { @@ -127,17 +126,17 @@ async fn download_and_install_dependency(url: &str, path: &Path, args: &[&str]) if !path.exists() { info!("Downloading {} from {url}", path.display()); if let Some(parent) = path.parent() { - match fs::create_dir_all(parent) { - Ok(_) => (), - Err(e) => { - println_error!("Error creating directory {}: {e}", parent.display()); - return; - } + if let Err(e) = fs::create_dir_all(parent) { + println_error!("Error creating directory {}: {e}", parent.display()); + return; } } - match crate::http_async::download_file(url, &std::path::PathBuf::from(path)).await { + match crate::http_async::download_file(url, &PathBuf::from(path)).await { Ok(_) => info!("Downloaded {}", path.display()), - Err(e) => println_error!("Error downloading {}: {e}", path.display()), + Err(e) => { + println_error!("Error downloading {}: {e}", path.display()); + return; + } } } install_dependency(path, args); @@ -170,29 +169,19 @@ pub fn prefix(tag_name: &str) -> String { } pub fn get_cache(dir: &Path) -> structs::Cache { - let mut cache_file = OpenOptions::new() - .read(true) - .create(true) - .append(true) - .open(dir.join("awcache.json")) - .unwrap(); - let mut cache_s = String::new(); - std::io::Read::read_to_string(&mut cache_file, &mut cache_s).unwrap(); - let cache: structs::Cache = if cache_s.trim().is_empty() { + let cache_path = dir.join("awcache.json"); + let cache_content = fs::read_to_string(cache_path).unwrap_or_default(); + if cache_content.trim().is_empty() { structs::Cache::default() } else { - serde_json::from_str(&cache_s).unwrap_or(structs::Cache::default()) - }; - cache + serde_json::from_str(&cache_content).unwrap_or_default() + } } pub fn save_cache(dir: &Path, cache: structs::Cache) { - let mut cache_file = OpenOptions::new() - .write(true) - .create(true) - .truncate(true) - .open(dir.join("awcache.json")) - .unwrap(); + let cache_path = dir.join("awcache.json"); let cache_serialized = serde_json::to_string_pretty(&cache).unwrap(); - cache_file.write_all(cache_serialized.as_bytes()).unwrap(); + fs::write(cache_path, cache_serialized).unwrap_or_else(|e| { + println_error!("Failed to save cache: {}", e); + }); } diff --git a/src/structs.rs b/src/structs.rs index c8c6d72..378c863 100644 --- a/src/structs.rs +++ b/src/structs.rs @@ -1,4 +1,4 @@ -use colored::*; +use colored::ColoredString; use std::{collections::HashMap, path::Path}; #[derive(serde::Deserialize, serde::Serialize, Clone)]