From bd56febe8fe1e03baed36c3451f14116c8bb4eff Mon Sep 17 00:00:00 2001 From: theMackabu Date: Thu, 26 Oct 2023 21:03:51 -0700 Subject: [PATCH] add localization via hashmap --- src/lib.rs | 48 ++++++++++++++++++++- src/project/init.rs | 7 +-- src/project/package.rs | 5 ++- src/registry/auth.rs | 23 ++++++---- src/registry/manager.rs | 96 ++++++++++++++++++++++++++--------------- src/registry/package.rs | 40 ++++++++--------- 6 files changed, 149 insertions(+), 70 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index aa4f842..382d620 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,7 +9,53 @@ lazy_static! { let mut default = HashMap::new(); default.insert("template_error", "unable create template, please try again"); default.insert("template_downloaded", "downloaded template"); - default + default.insert("create_error_1", "An error happened when asking for "); + default.insert("create_error_2", ", try again later."); + default.insert("create_project", "This utility will walk you through creating a package.yml file.\n"); + default.insert("saved_project", "\n✨ success, saved package.yml"); + default.insert("read_error", "unable to find package.yml"); + default.insert("yaml_error", " in package.yml"); + default.insert("registry_login", "logging into "); + default.insert("home_error", "Impossible to get your home dir."); + default.insert("login_error_generic", "unable to login: "); + default.insert("login_error", "unable to login, invalid username or password"); + default.insert("logout_error", "unable to logout, no token file (are you logged in?)"); + default.insert("login_msg", "logged in"); + default.insert("logout_msg", "logged out"); + default.insert("tar_error", "- unable to remove temporary tarfile. does it exist?"); + default.insert("cwd_error", "cannot retrive current directory"); + default.insert("unpack_error", "failed to unpack tarball"); + default.insert("publish_error", "unable to publish package"); + default.insert("publish_error_generic", "unable to publish package, please try again"); + default.insert("publish_error_login", "unable to publish package, please login"); + default.insert("publish_error_token", "your token might be expired, please login again"); + default.insert("publish_msg", "publishing"); + default.insert("publish_wait", "publishing..."); + default.insert("publish_done", "created package "); + default.insert("file_error", "unable remove file, please try again"); + default.insert("file_error", "unable remove file, please try again"); + default.insert("find_error", "unable to find "); + default.insert("remove_error", "unable to remove "); + default.insert("pkg_error", "unable to add package "); + default.insert("pkg_skip", "xskipped installed package "); + default.insert("pkg_fs_error", "unable to add package, filesystem error"); + default.insert("pkg_create_error", "Failed to create file "); + default.insert("pkg_add_error", "unable to add "); + default.insert("pkg_fetch_error", "failed to get from "); + default.insert("pkg_content_error", "failed to get content length of "); + default.insert("pkg_find_msg", "locating..."); + default.insert("pkg_found", "located package "); + default.insert("dep_found", "located dependency "); + default.insert("dep_skip", "skipped installed dependency "); + default.insert("write_error", "Error while downloading file"); + default.insert("download_error", "Error while writing to file"); + default.insert("install_done", "✨ done in "); + default.insert("is_question_install", "is it installed?"); + default.insert("pkg_unused", "removed unused package "); + default.insert("pkg_remove", "removed package "); + default.insert("clean_error", "unable to clean packages, try again"); + + return default; }; } diff --git a/src/project/init.rs b/src/project/init.rs index f9d3647..4bd7101 100644 --- a/src/project/init.rs +++ b/src/project/init.rs @@ -1,16 +1,17 @@ +use crate::MESSAGES; use colored::Colorize; use inquire::{Confirm, Text}; use std::fs::File; use std::io::Write; fn create_error(name: &str) { - println!("An error happened when asking for {name}, try again later."); + println!("{}{name}{}", MESSAGES.get("create_error_1").unwrap(), MESSAGES.get("create_error_2").unwrap()); std::fs::remove_file("package.yml").unwrap(); std::process::exit(1); } pub fn create_project() { - println!("This utility will walk you through creating a package.yml file.\n"); + println!("{}", MESSAGES.get("create_project").unwrap()); let mut file = File::create("package.yml").unwrap(); let current_dir = std::env::current_dir().unwrap(); @@ -70,5 +71,5 @@ pub fn create_project() { } writeln!(&mut file, "dependencies:").unwrap(); - println!("{}", "\n✨ success, saved package.yml".yellow()) + println!("{}", MESSAGES.get("saved_project").unwrap().yellow()) } diff --git a/src/project/package.rs b/src/project/package.rs index 29052e2..7c33534 100644 --- a/src/project/package.rs +++ b/src/project/package.rs @@ -1,3 +1,4 @@ +use crate::MESSAGES; use colored::Colorize; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -31,7 +32,7 @@ pub fn read() -> Package { let contents = match fs::read_to_string("package.yml") { Ok(content) => content, Err(_) => { - eprintln!("{} {}", "✖".red(), "unable to find package.yml".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("read_error").unwrap().bright_red()); std::process::exit(1); } }; @@ -40,7 +41,7 @@ pub fn read() -> Package { let parsed = match yaml_file { Ok(project) => project, Err(error) => { - eprintln!("{}", format!("{} in package.yml", error).red()); + eprintln!("{}", format!("{}{}", MESSAGES.get("yaml_error").unwrap(), error).red()); std::process::exit(1); } }; diff --git a/src/registry/auth.rs b/src/registry/auth.rs index 40f8a48..a0b59c6 100644 --- a/src/registry/auth.rs +++ b/src/registry/auth.rs @@ -1,4 +1,4 @@ -use crate::helpers; +use crate::{helpers, MESSAGES}; use colored::Colorize; use global_placeholders::global; use indicatif::{ProgressBar, ProgressStyle}; @@ -32,7 +32,7 @@ pub fn login() { println!("created {}/.{name}/credentials", &path.display()); } - println!("logging into {registry_link}"); + println!("{}{registry_link}", MESSAGES.get("registry_login").unwrap()); let identity_string: String; let password_string: String; @@ -74,19 +74,24 @@ pub fn login() { Ok(json) => { let mut file = std::fs::File::create(format!("{}/.{name}/credentials/{}].json", path.display(), registry_link.replace("://", "["))).unwrap(); file.write_all(format!("{{\"token\":\"{}\",\"access\":\"{}\"}}", json.token, json.record.id).as_bytes()).unwrap(); - pb.finish_with_message(format!("\x08{} {} {}", "✔".green(), "logged in".bright_green(), format!("({})", json.record.id).white())); + pb.finish_with_message(format!( + "\x08{} {} {}", + "✔".green(), + MESSAGES.get("login_msg").unwrap().bright_green(), + format!("({})", json.record.id).white() + )); } Err(_) => { - eprint!("\r{} {}\n", "✖".red(), "unable to login, invalid username or password".bright_red()); + eprint!("\r{} {}\n", "✖".red(), MESSAGES.get("login_error").unwrap().bright_red()); std::process::exit(1); } }; } - Err(err) => eprint!("\r{} {}\n", "✖".red(), format!("unable to login: {}", err.to_string()).bright_red()), + Err(err) => eprint!("\r{} {}\n", "✖".red(), format!("{}{}", MESSAGES.get("login_error_generic").unwrap(), err.to_string()).bright_red()), }; } None => { - eprintln!("{}", "Impossible to get your home dir.".red()); + eprintln!("{}", MESSAGES.get("home_error").unwrap().red()); std::process::exit(1); } } @@ -98,13 +103,13 @@ pub fn logout() { match home::home_dir() { Some(path) => { if let Err(_) = std::fs::remove_file(format!("{}/.{name}/credentials.json", path.display())) { - eprintln!("{} {}", "unable to logout, no token file".red(), "(are you logged in?)".bright_red()); + eprintln!("{}", MESSAGES.get("logout_error").unwrap().red()); } else { - println!("{}", "logged out".green()) + println!("{}", MESSAGES.get("logout_msg").unwrap().green()) } } None => { - eprintln!("{}", "Impossible to get your home dir.".red()); + eprintln!("{}", MESSAGES.get("home_error").unwrap().red()); std::process::exit(1); } } diff --git a/src/registry/manager.rs b/src/registry/manager.rs index cb5196d..347f90f 100644 --- a/src/registry/manager.rs +++ b/src/registry/manager.rs @@ -1,4 +1,4 @@ -use crate::project; +use crate::{project, MESSAGES}; use anyhow::Context; use brown; @@ -7,7 +7,7 @@ use flate2::read::GzDecoder; use futures_util::StreamExt; use global_placeholders::global; use indicatif::{HumanDuration, ProgressBar, ProgressStyle}; -use macros_rs::{fmtstr, ternary}; +use macros_rs::{fmtstr, string, ternary}; use std::cmp::min; use std::collections::HashMap; use std::time::{Duration, Instant}; @@ -27,12 +27,12 @@ struct Response { fn remove_file(file: &str) { if let Err(_) = fs::remove_file(file) { - eprintln!("{} {}", "✖".red(), "unable remove file, please try again".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("file_error").unwrap().bright_red()); std::process::exit(1); } } fn move_package(file: &str, name: &str, version: &str) { - let current_dir = std::env::current_dir().expect("cannot retrive current directory"); + let current_dir = std::env::current_dir().expect(MESSAGES.get("cwd_error").unwrap()); let mut package = project::package::read(); let dependencies = package.dependencies.clone(); @@ -46,7 +46,9 @@ fn move_package(file: &str, name: &str, version: &str) { let tar = GzDecoder::new(tarball); let mut archive = Archive::new(tar); - archive.unpack(format!("{}/packages/{name}@{version}", current_dir.display())).expect("failed to unpack tarball"); + archive + .unpack(format!("{}/packages/{name}@{version}", current_dir.display())) + .expect(MESSAGES.get("unpack_error").unwrap()); remove_file(file); if package.dependencies.get(name) == None { @@ -61,12 +63,12 @@ fn move_package(file: &str, name: &str, version: &str) { } if let Err(err) = File::create("package.yml").unwrap().write_all(serde_yaml::to_string(&package).unwrap().as_bytes()) { - eprintln!("{} {}", "✖".red(), format!("unable to add {name}@{version}, {err}").bright_red()); + eprintln!("{} {}", "✖".red(), format!("{}{name}@{version}, {err}", MESSAGES.get("pkg_add_error").unwrap()).bright_red()); std::process::exit(1); }; } Err(_) => { - eprintln!("{} {}", "✖".red(), "unable to add package, filesystem error".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("pkg_fs_error").unwrap().bright_red()); remove_file(file); std::process::exit(1); } @@ -78,23 +80,23 @@ pub async fn download(client: &reqwest::Client, url: &str, path: &str, package_i .get(url) .send() .await - .or(Err(format!("\r{} {}\n", "✖".red(), format!("failed to get from {}", &url).bright_red())))?; + .or(Err(format!("\r{} {}\n", "✖".red(), format!("{}{}", MESSAGES.get("pkg_fetch_error").unwrap(), &url).bright_red())))?; let total_size = res .content_length() - .ok_or(format!("\r{} {}\n", "✖".red(), format!("failed to get content length of {}", &url).bright_red()))?; + .ok_or(format!("\r{} {}\n", "✖".red(), format!("{}{}", MESSAGES.get("pkg_content_error").unwrap(), &url).bright_red()))?; let pb = ProgressBar::new(total_size); pb.set_style(ProgressStyle::with_template("{msg}: [{bar:.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})").unwrap()); pb.set_message(format!("{}", format!("+ {package_info}").bright_cyan())); - let mut file = File::create(path).or(Err(format!("Failed to create file '{}'", path)))?; + let mut file = File::create(path).or(Err(format!("{}'{}'", MESSAGES.get("pkg_create_error").unwrap(), path)))?; let mut downloaded: u64 = 0; let mut stream = res.bytes_stream(); while let Some(item) = stream.next().await { - let chunk = item.or(Err(format!("Error while downloading file")))?; - file.write_all(&chunk).or(Err(format!("Error while writing to file")))?; + let chunk = item.or(Err(string!(MESSAGES.get("download_error").unwrap())))?; + file.write_all(&chunk).or(Err(string!(MESSAGES.get("write_error").unwrap())))?; let new = min(downloaded + (chunk.len() as u64), total_size); downloaded = new; pb.set_position(new); @@ -112,7 +114,7 @@ pub fn install() { add(&format!("{}@{}", name, ver.trim_matches(' ')), false) } } - println!("{}", format!("✨ done in {}", HumanDuration(started.elapsed())).yellow()); + println!("{}", format!("{}{}", MESSAGES.get("install_done").unwrap(), HumanDuration(started.elapsed())).yellow()); } pub fn add(input: &str, timer: bool) { @@ -122,7 +124,7 @@ pub fn add(input: &str, timer: bool) { let version; let started = Instant::now(); let name = input.split("@").collect::>()[0]; - let current_dir = std::env::current_dir().expect("cannot retrive current directory"); + let current_dir = std::env::current_dir().expect(MESSAGES.get("cwd_error").unwrap()); let client = reqwest::blocking::Client::builder().user_agent(format!("{app_name}/{}", env!("CARGO_PKG_VERSION"))).build().unwrap(); let style = ProgressStyle::with_template("{spinner:.yellow} {msg}").unwrap().tick_strings(&[ "[ ]", "[= ]", "[== ]", "[=== ]", "[ ===]", "[ ==]", "[ =]", "[ ]", "[ =]", "[ ==]", "[ ===]", "[====]", "[=== ]", "[== ]", "[= ]", "", @@ -137,7 +139,7 @@ pub fn add(input: &str, timer: bool) { let pb = ProgressBar::new_spinner(); pb.enable_steady_tick(Duration::from_millis(80)); pb.set_style(style.clone()); - pb.set_message("locating..."); + pb.set_message(string!(MESSAGES.get("pkg_find_msg").unwrap())); match client.get(format!("{registry}/{package_info}")).send() { Ok(res) => { @@ -145,28 +147,40 @@ pub fn add(input: &str, timer: bool) { Ok(json) => { version = json.dist.version.clone(); if !std::path::Path::new(fmtstr!("{}/packages/{name}@{version}", current_dir.display())).is_dir() { - pb.finish_with_message(format!("\x08{} {}", "✔".green(), format!("located package {name}@{}", json.dist.version).green())); + pb.finish_with_message(format!("\x08{} {}", "✔".green(), format!("{}{name}@{}", MESSAGES.get("pkg_found").unwrap(), json.dist.version).green())); let runtime = tokio::runtime::Runtime::new().unwrap(); match runtime.block_on(download(&reqwest::Client::new(), &json.dist.tarball, &format!("{name}.tgz"), format!("{name}@{}", &json.dist.version))) { Ok(_) => move_package(&format!("{name}.tgz"), &name, &json.dist.version), Err(err) => { - eprint!("\r{} {}\n", "✖".red(), format!("unable to add package {}: {}", package_info, err.to_string()).bright_red()); + eprint!( + "\r{} {}\n", + "✖".red(), + format!("{}{}: {}", MESSAGES.get("pkg_error").unwrap(), package_info, err.to_string()).bright_red() + ); std::process::exit(1); } }; } else { - pb.finish_with_message(format!("\x08{} {}", "ℹ".magenta(), format!("skipped installed package {name}@{}", json.dist.version).bright_magenta())); + pb.finish_with_message(format!( + "\x08{} {}", + "ℹ".magenta(), + format!("{}{name}@{}", MESSAGES.get("pkg_skip").unwrap(), json.dist.version).bright_magenta() + )); } } Err(_) => { - pb.finish_with_message(format!("\x08{} {}", "✖".red(), format!("unable to find {}", package_info).bright_red())); + pb.finish_with_message(format!("\x08{} {}", "✖".red(), format!("{}{}", MESSAGES.get("find_error").unwrap(), package_info).bright_red())); std::process::exit(1); } }; } Err(err) => { - eprint!("\r{} {}\n", "✖".red(), format!("unable to add package {}: {}", package_info, err.to_string()).bright_red()); + eprint!( + "\r{} {}\n", + "✖".red(), + format!("{}{}: {}", MESSAGES.get("pkg_error").unwrap(), package_info, err.to_string()).bright_red() + ); std::process::exit(1); } }; @@ -189,9 +203,13 @@ pub fn add(input: &str, timer: bool) { pb_dep.set_message("locating..."); if !std::path::Path::new(fmtstr!("{}/packages/{name}@{version}", current_dir.display())).is_dir() { - pb_dep.finish_with_message(format!("\x08{} {}", "✔".green(), format!("located dependency {name}@{}", &version).bright_green())); + pb_dep.finish_with_message(format!("\x08{} {}", "✔".green(), format!("{}{name}@{}", MESSAGES.get("dep_found").unwrap(), &version).bright_green())); } else { - pb_dep.finish_with_message(format!("\x08{} {}", "ℹ".magenta(), format!("skipped installed dependency {name}@{}", &version).bright_magenta())); + pb_dep.finish_with_message(format!( + "\x08{} {}", + "ℹ".magenta(), + format!("{}{name}@{}", MESSAGES.get("dep_skip").unwrap(), &version).bright_magenta() + )); } } @@ -203,7 +221,11 @@ pub fn add(input: &str, timer: bool) { match runtime.block_on(download(&reqwest::Client::new(), link, &format!("{name}.tgz"), format!("{name}@{}", version))) { Ok(_) => move_package(&format!("{name}.tgz"), &name, &version), Err(err) => { - eprint!("\r{} {}\n", "✖".red(), format!("unable to add package {}: {}", package_info, err.to_string()).bright_red()); + eprint!( + "\r{} {}\n", + "✖".red(), + format!("{}{}: {}", MESSAGES.get("pkg_error").unwrap(), package_info, err.to_string()).bright_red() + ); std::process::exit(1); } }; @@ -214,24 +236,28 @@ pub fn add(input: &str, timer: bool) { }; } Err(err) => { - eprint!("\r{} {}\n", "✖".red(), format!("unable to add package {}: {}", package_info, err.to_string()).bright_red()); + eprint!( + "\r{} {}\n", + "✖".red(), + format!("{}{}: {}", MESSAGES.get("pkg_error").unwrap(), package_info, err.to_string()).bright_red() + ); std::process::exit(1); } }; if timer { - println!("{}", format!("✨ done in {}", HumanDuration(started.elapsed())).yellow()); + println!("{}", format!("{}{}", MESSAGES.get("install_done").unwrap(), HumanDuration(started.elapsed())).yellow()); } } pub fn remove(name: &String) { let started = Instant::now(); - let current_dir = std::env::current_dir().expect("cannot retrive current directory"); + let current_dir = std::env::current_dir().expect(MESSAGES.get("cwd_error").unwrap()); let mut package = project::package::read(); let dependencies = package.dependencies.clone(); let key = name.split("@").collect::>()[0]; - let generic_error = |err: String| -> String { format!("{} {}", "✖".red(), format!("unable to remove {name}, {err}").bright_red()) }; + let generic_error = |err: String| -> String { format!("{} {}", "✖".red(), format!("{}{name}, {err}", MESSAGES.get("remove_error").unwrap()).bright_red()) }; - let mut versions = match dependencies.get(key).with_context(|| generic_error(String::from("is it installed?"))) { + let mut versions = match dependencies.get(key).with_context(|| generic_error(string!(MESSAGES.get("is_question_install").unwrap()))) { Ok(content) => content.split(",").collect::>(), Err(err) => { eprintln!("{err}"); @@ -246,7 +272,7 @@ pub fn remove(name: &String) { ); if let Err(_) = std::fs::remove_dir_all(format!("{}/packages/{package_dir}", current_dir.display())) { - eprintln!("{}", generic_error(String::from("is it installed?"))); + eprintln!("{}", generic_error(string!(MESSAGES.get("is_question_install").unwrap()))); std::process::exit(1); } else { if name.split("@").collect::>().len() > 1 { @@ -265,16 +291,16 @@ pub fn remove(name: &String) { eprintln!("{}", generic_error(err.to_string())); std::process::exit(1); } - println!("\x08{} {}", "✔".green(), format!("removed package {name}").green()); + println!("\x08{} {}", "✔".green(), format!("{}{name}", MESSAGES.get("pkg_remove").unwrap()).green()); } - println!("{}", format!("✨ done in {}", HumanDuration(started.elapsed())).yellow()); + println!("{}", format!("{}{}", MESSAGES.get("install_done").unwrap(), HumanDuration(started.elapsed())).yellow()); } pub fn clean() { let package = project::package::read(); let dependencies = package.dependencies.clone(); - let generic_error = |name: &str, err: &str| -> String { format!("{} {}", "✖".red(), format!("unable to remove {name}, {err}").bright_red()) }; + let generic_error = |name: &str, err: &str| -> String { format!("{} {}", "✖".red(), format!("{}{name}, {err}", MESSAGES.get("remove_error").unwrap()).bright_red()) }; match brown::get_dirs("packages") { Ok(paths) => { @@ -284,14 +310,14 @@ pub fn clean() { if dependencies.get(package_name).is_none() { if let Err(_) = brown::remove_dir_brute(&package_dir) { - eprintln!("{}", generic_error(package_name, "is it installed?")); + eprintln!("{}", generic_error(package_name, MESSAGES.get("is_question_install").unwrap())); std::process::exit(1); } else { - println!("\x08{} {}", "✔".blue(), format!("removed unused package {package_name}").bright_blue()); + println!("\x08{} {}", "✔".blue(), format!("{}{package_name}", MESSAGES.get("pkg_unused").unwrap()).bright_blue()); } } } } - Err(_) => eprintln!("{} {}", "✖".red(), format!("unable to clean packages, try again").bright_red()), + Err(_) => eprintln!("{} {}", "✖".red(), MESSAGES.get("clean_error").unwrap().bright_red()), }; } diff --git a/src/registry/package.rs b/src/registry/package.rs index 19d4425..2bedecf 100644 --- a/src/registry/package.rs +++ b/src/registry/package.rs @@ -1,12 +1,11 @@ -use crate::helpers; -use crate::project; +use crate::{helpers, project, MESSAGES}; use colored::Colorize; use flate2::write::GzEncoder; use flate2::Compression; use global_placeholders::global; use indicatif::{ProgressBar, ProgressStyle}; -use macros_rs::{fmtstr, str, ternary}; +use macros_rs::{fmtstr, str, string, ternary}; use std::fs::File; #[derive(Debug, serde::Deserialize)] @@ -22,13 +21,13 @@ struct Response { fn remove_tar(file: &str) { if let Err(_) = std::fs::remove_file(file) { - eprintln!(" {}", "- unable to remove temporary tarfile. does it exist?".bright_red()); + eprintln!(" {}", MESSAGES.get("tar_error").unwrap().bright_red()); std::process::exit(1); } } fn write_tar(file_name: &String) -> Result<(), std::io::Error> { - let current_dir = std::env::current_dir().expect("cannot retrive current directory"); + let current_dir = std::env::current_dir().expect(MESSAGES.get("tar_error").unwrap()); log::info!("creating file: {}", file_name); let tar_gz = File::create(file_name)?; let enc = GzEncoder::new(tar_gz, Compression::default()); @@ -61,19 +60,19 @@ pub fn publish() { Ok(content) => match serde_json::from_str::(&content) { Ok(json) => json, Err(_) => { - eprintln!("{} {}", "✖".red(), "unable to publish, please login".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("publish_error_login").unwrap().bright_red()); std::process::exit(1); } }, Err(_) => { - eprintln!("{} {}", "✖".red(), "unable to publish, please login".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("publish_error_login").unwrap().bright_red()); std::process::exit(1); } }; println!( "{} {}@{}", - "publishing".bright_yellow(), + MESSAGES.get("publish_msg").unwrap().bright_yellow(), format!("{}", package.info.name).bold(), format!("{}", package.info.version).bold() ); @@ -83,10 +82,10 @@ pub fn publish() { pb.set_style(ProgressStyle::with_template("{spinner:.yellow} {msg}").unwrap().tick_strings(&[ "[ ]", "[= ]", "[== ]", "[=== ]", "[ ===]", "[ ==]", "[ =]", "[ ]", "[ =]", "[ ==]", "[ ===]", "[====]", "[=== ]", "[== ]", "[= ]", "", ])); - pb.set_message("publishing..."); + pb.set_message(string!(MESSAGES.get("publish_wait").unwrap())); if let Err(err) = write_tar(&file_name) { - eprintln!("{} {}", "✖".red(), "unable to publish, please try again".bright_red()); + eprintln!("{} {}", "✖".red(), MESSAGES.get("publish_error_generic").unwrap().bright_red()); eprintln!(" {} {}", "-".bright_red(), err.to_string().bright_red()); remove_tar(&file_name); std::process::exit(1); @@ -124,38 +123,39 @@ pub fn publish() { "\x08{} {}", "✖".red(), format!( - "unable to publish package\n - {}", - ternary!( - helpers::trim_start_end(&error) == "ul", - "your token might be expired, please login again", - helpers::trim_start_end(&error) - ) + "{}\n - {}", + MESSAGES.get("publish_error").unwrap(), + ternary!(helpers::trim_start_end(&error) == "ul", MESSAGES.get("publish_error_token").unwrap(), helpers::trim_start_end(&error)) ) .bright_red() )); remove_tar(&file_name); std::process::exit(1); } else { - pb.finish_with_message(format!("\x08{} {}", "✔".green(), format!("created package {}", &json.message["created"]).bright_green())); + pb.finish_with_message(format!( + "\x08{} {}", + "✔".green(), + format!("{}{}", MESSAGES.get("publish_done").unwrap(), &json.message["created"]).bright_green() + )); remove_tar(&file_name); } } Err(_) => { - eprint!("\r{} {}\n", "✖".red(), "unable to publish package, please try again".bright_red()); + eprint!("\r{} {}\n", "✖".red(), MESSAGES.get("publish_error_generic").unwrap().bright_red()); remove_tar(&file_name); std::process::exit(1); } }; } Err(err) => { - eprint!("\r{} {}\n", "✖".red(), format!("unable to publish package: {}", err.to_string()).bright_red()); + eprint!("\r{} {}\n", "✖".red(), format!("{}: {}", MESSAGES.get("publish_error").unwrap(), err.to_string()).bright_red()); remove_tar(&file_name); std::process::exit(1); } }; } None => { - eprintln!("{}", "Impossible to get your home dir.".red()); + eprintln!("{}", MESSAGES.get("home_error").unwrap().red()); std::process::exit(1); } } -- GitLab