Migrated some files to new LANG system

src/events.rs

@@ -1,9 +1,10 @@
 use crate::db::reddit::update_data;
 use crate::r#gen::set_status;
+use crate::lang::Lang;
 use crate::messages::{make_post_embed, make_removed_embed, EmbedOptions};
 use crate::cmds::reddit::generic_fns::{is_bk_mod, is_bk_mod_serenity, serenity_edit_msg_embed, serenity_send_msg};
 use crate::websocket::send_cmd_json;
-use crate::{Data, Error, lang, rs_println};
+use crate::{Data, Error, rs_println};
 use crate::db::reddit::POSTS_KEY;
 
 use poise::serenity_prelude::{self as serenity, ChannelId, ComponentInteraction, Interaction, Member, MessageId, Ready};
@@ -67,11 +68,11 @@ async fn handle_buttons(ctx: &serenity::Context, data: &Data, interaction: &Inte
 }
 
 
-async fn update_embed(ctx: &serenity::Context, url: &str, new_data: &Value, c_id: &ChannelId, m_id: &MessageId) {
+async fn update_embed(ctx: &serenity::Context, lang: &Lang, url: &str, new_data: &Value, c_id: &ChannelId, m_id: &MessageId) {
   let remove = new_data["removed"]["removed"].as_bool().unwrap();
   let e: EmbedOptions =
-    if remove { make_removed_embed(new_data, url, true) }
-    else      { make_post_embed   (new_data, url, true) };
+    if remove { make_removed_embed(lang, new_data, url, true) }
+    else      { make_post_embed   (lang, new_data, url, true) };
   
   serenity_edit_msg_embed(ctx, c_id, m_id, e).await;
 }
@@ -89,19 +90,14 @@ async fn approve_btn(ctx: &serenity::Context, data: &Data, c_member: &Member, co
   let new_data = &data.reddit_data
     .lock().await[POSTS_KEY][&url];
 
-  update_embed(ctx, &url, new_data, &c_id, &m_id).await;
+  update_embed(ctx, &data.lang, &url, new_data, &c_id, &m_id).await;
 
   if r["value"].as_bool().unwrap() {
-    if approve {
-      serenity_send_msg(ctx, component, lang!("dc_msg_re_post_approve_success"), true).await;
-    }
-    else {
-      serenity_send_msg(ctx, component, lang!("dc_msg_re_post_disapprove_success"), true).await;
-    }
-  }
-  else {
-    serenity_send_msg(ctx, component, lang!("dc_msg_re_post_approve_remove"), true).await;
+    if approve
+      { serenity_send_msg(ctx, component, data.lang.get("dc.re.approve.disapprove", &[]), true).await; }
+    else { serenity_send_msg(ctx, component, data.lang.get("dc.re.approve.success", &[]), true).await; }
   }
+  else { serenity_send_msg(ctx, component, data.lang.get("dc.re.approve.post_removed", &[]), true).await; }
 
   return Ok(());
 }
@@ -110,12 +106,9 @@ async fn approve_btn(ctx: &serenity::Context, data: &Data, c_member: &Member, co
 async fn remove_btn(ctx: &serenity::Context, data: &Data, c_member: &Member, component: &ComponentInteraction, url: String, remove: bool) -> Result<(), Error> {
   if !is_bk_mod_serenity(ctx, data, c_member, component).await { return Ok(()); }
 
-  let r: Value = if remove {
-    send_cmd_json("remove_post_url", Some(json!([&url, &c_member.user.name, None::<String>])), true).await.unwrap()
-  }
-  else {
-    send_cmd_json("add_post_url", Some(json!([&url, false, true])), true).await.unwrap()
-  };
+  let r: Value =
+    if remove { send_cmd_json("remove_post_url", Some(json!([&url, &c_member.user.name, None::<String>])), true).await.unwrap() }
+  else { send_cmd_json("add_post_url", Some(json!([&url, false, true])), true).await.unwrap() };
 
   let c_id = component.channel_id;
   let m_id = component.message.id;
@@ -124,15 +117,11 @@ async fn remove_btn(ctx: &serenity::Context, data: &Data, c_member: &Member, com
   let new_data = &data.reddit_data
     .lock().await[POSTS_KEY][&url];
 
-  update_embed(ctx, &url, new_data, &c_id, &m_id).await;
+  update_embed(ctx, &data.lang, &url, new_data, &c_id, &m_id).await;
 
   if r["value"].as_bool().unwrap() {
-    if remove {
-      serenity_send_msg(ctx, component, lang!("dc_msg_re_post_remove_success", &url), true).await;
-    }
-    else {
-      serenity_send_msg(ctx, component, lang!("dc_msg_re_post_unremove_success", &url), true).await;
-    }
+    if remove { serenity_send_msg(ctx, component, data.lang.get("dc.re.remove.success", &[url]), true).await; }
+    else { serenity_send_msg(ctx, component, data.lang.get("dc.re.remove.unremove", &[url]), true).await; }
   }
 
   return Ok(());
@@ -152,22 +141,22 @@ async fn vote_btn(ctx: &serenity::Context, data: &Data, c_member: &Member, compo
   let new_data = &data.reddit_data
     .lock().await[POSTS_KEY][&url];
 
-  update_embed(ctx, &url, new_data, &c_id, &m_id).await;
+  update_embed(ctx, &data.lang, &url, new_data, &c_id, &m_id).await;
 
   if r["value"].as_bool().unwrap() {
     if vote {
-      if is_mod { serenity_send_msg(ctx, component, lang!("dc_msg_re_vote_mod_success"), true).await; }
-      else      { serenity_send_msg(ctx, component, lang!("dc_msg_re_vote_success"),     true).await; }
+      if is_mod { serenity_send_msg(ctx, component, data.lang.get("dc.re.vote.mod", &[]), true).await; }
+      else { serenity_send_msg(ctx, component, data.lang.get("dc.re.vote.success", &[]), true).await; }
     }
     else {
-      serenity_send_msg(ctx, component, lang!("dc_msg_re_vote_remove_success"), true).await;
+      serenity_send_msg(ctx, component, data.lang.get("dc.re.vote.removed", &[]), true).await;
     }
   }
   else if new_data["removed"]["removed"].as_bool().unwrap() {
-    serenity_send_msg(ctx, component, lang!("dc_msg_re_post_vote_removed_post"), true).await;
+    serenity_send_msg(ctx, component, data.lang.get("dc.re.vote.post_removed", &[]), true).await;
   }
   else if !vote {
-    serenity_send_msg(ctx, component, lang!("dc_msg_re_vote_remove_havent"), true).await;
+    serenity_send_msg(ctx, component, data.lang.get("dc.re.vote.remove_hasnt_voted", &[]), true).await;
   }
 
   return Ok(());

src/gen.rs

@@ -1,3 +1,4 @@
+use std::path::PathBuf;
 use std::{collections::HashSet, process};
 
 use poise::serenity_prelude::{ActivityData, UserId};
@@ -24,14 +25,19 @@ pub async fn gen_data(args: Args, env_vars: AssistantEnv) -> Data {
   let dc_data = discord::read_data(args.clone().wipe).await;
   let cf_data = cfg::    read_data(args.clone().wipe).await;
 
+  let cf_bind = cf_data.clone();
+  let lang_name = cf_bind["general"]["lang"].as_str().unwrap();
+  let lang_path = ["./data/lang/", lang_name, ".json"].concat();
+  let lang_pathbuf = PathBuf::from(lang_path);
+  
   return Data {
     args:         args.clone(),
     ball_prompts: [ball_classic, ball_quirk],
     cfg:          cf_data,
     discord_data: dc_data.into(),
     env_vars:     env_vars,
-    lang_name:    "".to_string().into(),
-    lang:         Lang::new().into(),
+    lang_name:    lang_name.to_string(),
+    lang:         Lang::from_file(lang_pathbuf).unwrap(),
     reddit_data:  re_data.into(),
     rps_game:     Mutex::new(RPSGame::new())
   };

src/macros.rs

@@ -59,43 +59,4 @@ macro_rules! warnln {
       format!($($arg)*)
     );
   };
-}
-
-
-#[macro_export]
-macro_rules! lang {
-  ($key:expr) => {
-    {
-      /*use $crate::{LANG, errln};
-      let value = unsafe {
-        LANG
-          .as_ref()
-          .expect("LANG must be initialized before use")
-          .get($key)
-      };
-
-      if value.is_none() { errln!("Key not found in LANG JSON: \"{}\"", $key); }
-
-      value.unwrap().as_str().expect("LANG JSON value is not a string!").to_string()*/
-      
-      "hello".to_string()
-    }
-  };
-  ($key:expr, $($arg:expr),*) => {{
-    /*use $crate::{LANG, errln};
-    use formatx::formatx;
-
-    let value = unsafe {
-      LANG
-        .as_ref()
-        .expect("LANG must be initialized before use")
-        .get($key)
-    };
-
-    if value.is_none() { errln!("Key not found in LANG JSON: \"{}\"", $key); }
-
-    let format_str = value.unwrap().as_str().expect("LANG JSON value is not a string!");
-    formatx!(format_str, $($arg),*).unwrap()*/
-    "hello".to_string()
-  }};
 }

src/main.rs

@@ -48,7 +48,7 @@ async fn main() {
   rs_println!("Generating and/or fetching data and config...");
   let data = gen_data(args, env_vars).await;
   
-  rs_println!("[IMPORTANT] The below message is a test message, it should be written in the language you've selected\nTest message: {}", lang!("log_lang_load_success"));
+  rs_println!("[IMPORTANT] The below message is a test message, it should be written in the language you've selected\nTest message: {}", data.lang.get("log_lang_load_success", &[]));
 
   // We start this here cuz we have all the data that we need
   if data.args.py && !data.args.rs {

src/messages.rs

@@ -1,7 +1,8 @@
 use std::io::{Read, Write};
 
 use crate::db::bot_data::Data;
-use crate::{lang, Context};
+use crate::Context;
+use crate::lang::Lang;
 
 use base64::engine::general_purpose;
 use base64::Engine;
@@ -36,7 +37,7 @@ pub struct EmbedOptions {
 impl Default for EmbedOptions {
   fn default() -> Self {
     return EmbedOptions {
-      desc: lang!("dc_msg_embed_default_embed_desc"),
+      desc: "Default english embed description.".to_string(),
       title: None,
       col: None,
       url: None,
@@ -226,19 +227,19 @@ pub async fn send_dm_min(msg: String, token: String, bot_owners: Vec<u64>) {
 }
 
 
-pub fn make_post_embed(post_data: &Value, url: &str, ephemeral: bool) -> EmbedOptions {
+pub fn make_post_embed(lang: &Lang, post_data: &Value, url: &str, ephemeral: bool) -> EmbedOptions {
   let media_type = &post_data["post_data"]["media_type"];
 
-  let desc_str = lang!(
-    "dc_msg_embed_re_post",
-    post_data["post_data"]["subreddit"].as_str().unwrap(),
-    post_data["post_data"]["upvotes"].as_i64().unwrap(),
-    post_data["votes"]["mod_voters"].as_array().unwrap().len(),
+  let desc_str = lang.get(
+    "dc.re.embed.post",
+    &[post_data["post_data"]["subreddit"].as_str().unwrap(),
+    post_data["post_data"]["upvotes"].as_i64().unwrap().to_string().as_str(),
+    post_data["votes"]["mod_voters"].as_array().unwrap().len().to_string().as_str(),
     if !media_type.is_null() { media_type.as_str().unwrap() } else { "None" },
 
     if post_data["added"]   ["by_human"].as_bool().unwrap() { "✅" } else { "❌" },
     if post_data["added"]   ["by_bot"].as_bool().unwrap()   { "✅" } else { "❌" },
-    if post_data["approved"]["by_human"].as_bool().unwrap() { "✅" } else { "❌" }
+    if post_data["approved"]["by_human"].as_bool().unwrap() { "✅" } else { "❌" }].map(String::from)
   );
 
   let trimmed = desc_str
@@ -248,7 +249,7 @@ pub fn make_post_embed(post_data: &Value, url: &str, ephemeral: bool) -> EmbedOp
     .join("\n");
 
   let media_urls = post_data["post_data"]["media_urls"].as_array().unwrap();
-  let action_row = make_post_components();
+  let action_row = make_post_components(lang);
 
   let json_encoded = trim_compress_and_encode_json(post_data);
 
@@ -268,25 +269,25 @@ pub fn make_post_embed(post_data: &Value, url: &str, ephemeral: bool) -> EmbedOp
 }
 
 
-pub fn make_removed_embed(post_data: &Value, url: &str, ephemeral: bool) -> EmbedOptions {
-  let action_row = make_removed_components();
+pub fn make_removed_embed(lang: &Lang, post_data: &Value, url: &str, ephemeral: bool) -> EmbedOptions {
+  let action_row = make_removed_components(lang);
 
-  let none = lang!("none");
+  let none = lang.get("generic.none", &[]);
 
-  let desc = lang!(
-    "dc_msg_embed_re_removed",
-    if !post_data["removed"]["by"].is_null()
+  let desc = lang.get(
+    "dc.re.embed.post_removed",
+    &[if !post_data["removed"]["by"].is_null()
       { post_data["removed"]["by"].as_str().unwrap() }
       else { &none },
     if !post_data["removed"]["reason"].is_null()
       { post_data["removed"]["reason"].as_str().unwrap() }
-      else { &none }
+      else { &none }].map(String::from)
   );
 
   let json_encoded = trim_compress_and_encode_json(post_data);
 
   return EmbedOptions { 
-    title: Some(lang!("dc_msg_removed_square_brackets", post_data["post_data"]["title"].clone())),
+    title: Some(lang.get("dc_msg_removed_square_brackets", &[post_data["post_data"]["title"].clone().to_string()])),
     desc: format!("{}\n\n{}{}{}", desc, JSON_TEXT_START, json_encoded, JSON_TEXT_END),
     col: Some(REMOVED_DC_COL),
     url: Some(url.to_string()),
@@ -341,19 +342,19 @@ pub fn decode_and_decompress_json(t: String) -> Result<Value, serde_json::Error>
 }
 
 
-fn make_post_components() -> CreateActionRow {
+fn make_post_components(lang: &Lang) -> CreateActionRow {
   return CreateActionRow::Buttons(vec![
-    CreateButton::new("vote_btn")     .label(lang!("dc_btn_vote"))     .emoji(ReactionType::Unicode("⬆️".to_string())),
-    CreateButton::new("unvote_btn")   .label(lang!("dc_btn_unvote")),
-    CreateButton::new("approve_btn")  .label(lang!("dc_btn_approve"))    .emoji(ReactionType::Unicode("✅".to_string())),
-    CreateButton::new("unapprove_btn").label(lang!("dc_btn_unapprove")) .emoji(ReactionType::Unicode("❌".to_string())),
-    CreateButton::new("remove_btn")   .label(lang!("dc_btn_remove"))     .emoji(ReactionType::Unicode("🗑️".to_string()))
+    CreateButton::new("vote_btn")     .label(lang.get("dc.re.buttons.vote", &[])).emoji(ReactionType::Unicode("⬆️".to_string())),
+    CreateButton::new("unvote_btn")   .label(lang.get("dc.re.buttons.unvote", &[])),
+    CreateButton::new("approve_btn")  .label(lang.get("dc.re.buttons.approve", &[])).emoji(ReactionType::Unicode("✅".to_string())),
+    CreateButton::new("unapprove_btn").label(lang.get("dc.re.buttons.disapprove", &[])).emoji(ReactionType::Unicode("❌".to_string())),
+    CreateButton::new("remove_btn")   .label(lang.get("dc.re.buttons.remove", &[])).emoji(ReactionType::Unicode("🗑️".to_string()))
   ]);
 }
 
 
-fn make_removed_components() -> CreateActionRow {
+fn make_removed_components(lang: &Lang) -> CreateActionRow {
   return CreateActionRow::Buttons(vec![
-    CreateButton::new("unremove_btn").label(lang!("dc_btn_unremove")).emoji(ReactionType::Unicode("↩️".to_string()))
+    CreateButton::new("unremove_btn").label(lang.get("dc.re.buttons.unremove", &[])).emoji(ReactionType::Unicode("↩️".to_string()))
   ]);
 }

src/python.rs

@@ -1,7 +1,7 @@
 use crate::db::env_vars::AssistantEnv;
 use crate::db::terminal_args::Args;
 use crate::messages::send_dm_min;
-use crate::{errln, lang, rs_println};
+use crate::{errln, rs_println};
 
 use std::fs;
 use std::ffi::CString;
@@ -57,7 +57,7 @@ pub async fn start(args: Args, lang_name: String, env_vars: AssistantEnv) -> PyR
 
   if is_error {
     send_dm_min(
-      lang!("dc_msg_dm_python_err", traceback),
+      format!("Unknown internal Python Error:\n```\n{0}\n```", traceback),
       env_vars.token.clone(),
       env_vars.bot_owners.clone()
     ).await;

src/websocket.rs

@@ -10,7 +10,7 @@ use serde_json::{Value, json};
 
 use crate::db::bot_data::Data;
 use crate::messages::send_dm_min;
-use crate::{lang, rs_println};
+use crate::rs_println;
 use crate::Args;
 
 type Sender = Arc<Mutex<Option<futures::stream::SplitSink<tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>, tungstenite::Message>>>>;
@@ -142,7 +142,7 @@ async fn handle_connections(
 async fn handle_message(
   msg: tungstenite::protocol::Message,
   token: String,
-  bot_owners: Vec<u64>
+  bot_owners: Vec<u64>,
 ) {
   match msg {
     tungstenite::Message::Text(text) => {
@@ -152,7 +152,7 @@ async fn handle_message(
         let t_json: Value = serde_json::from_str(stripped).unwrap();
         if t_json.get("error").is_some() {
           send_dm_min(
-            lang!("dc_msg_dm_python_err_socket"),
+            "Unknown internal Python error occurred: Websocket response error".to_string(),
             token,
             bot_owners
           ).await;