Extract server locale code to own crate

1 files changed, 0 insertions, 154 deletions

diff --git a/server/src/message.rs b/server/src/message.rs
deleted file mode 100644
index 31084ada..00000000
--- a/server/src/message.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
-    Hurry Curry! - a game about cooking
-    Copyright (C) 2025 Hurry Curry! Contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, version 3 of the License only.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-*/
-
-use anyhow::{anyhow, Result};
-use hurrycurry_protocol::Message;
-use std::{
-    collections::HashMap,
-    fmt::{Debug, Display},
-    ops::Index,
-    sync::LazyLock,
-};
-
-#[macro_export]
-macro_rules! trm {
-    ($id:literal $(, $typ:ident = $param:expr)*) => {
-        hurrycurry_protocol::Message::Translation {
-            id: $id.to_owned(),
-            params: vec![$($crate::trm_param!($typ, $param)),*]
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! trm_param {
-    (s, $x:expr) => {
-        hurrycurry_protocol::Message::Text($x)
-    };
-    (i, $x:expr) => {
-        hurrycurry_protocol::Message::Item($x)
-    };
-    (t, $x:expr) => {
-        hurrycurry_protocol::Message::Tile($x)
-    };
-    (m, $x:expr) => {
-        $x
-    };
-}
-
-pub enum TrError {
-    Tr {
-        id: &'static str,
-        params: Vec<Message>,
-    },
-    Plain(String),
-}
-impl From<TrError> for Message {
-    fn from(value: TrError) -> Self {
-        match value {
-            TrError::Tr { id, params } => Self::Translation {
-                id: id.to_owned(),
-                params,
-            },
-            TrError::Plain(s) => Self::Text(s),
-        }
-    }
-}
-impl Debug for TrError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TrError::Tr { id, params } => write!(f, "{} {:?}", tr(id), params),
-            TrError::Plain(s) => write!(f, "{s}"),
-        }
-    }
-}
-impl Display for TrError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TrError::Tr { id, params } => {
-                if params.is_empty() {
-                    write!(f, "{}", tr(id))
-                } else {
-                    let mut s = tr(id).to_string();
-                    for (i, p) in params.iter().enumerate() {
-                        s = s.replace(&format!("{{{i}}}"), &format!("{p:?}"));
-                    }
-                    write!(f, "{s}")
-                }
-            }
-            TrError::Plain(s) => write!(f, "{s}"),
-        }
-    }
-}
-
-#[macro_export]
-macro_rules! tre {
-    ($id:literal $(, $typ:ident = $param:expr)*) => {
-        $crate::message::TrError::Tr {
-            id: $id,
-            params: vec![$($crate::tre_param!($typ, $param)),*]
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! tre_param {
-    (s, $x:expr) => {
-        hurrycurry_protocol::Message::Text($x)
-    };
-    (i, $x:expr) => {
-        hurrycurry_protocol::Message::Item($x)
-    };
-    (t, $x:expr) => {
-        hurrycurry_protocol::Message::Tile($x)
-    };
-    (m, $x:expr) => {
-        $x
-    };
-}
-
-pub struct Strings(HashMap<String, String>);
-impl Index<&'static str> for Strings {
-    type Output = str;
-    fn index(&self, index: &'static str) -> &Self::Output {
-        self.0.get(index).map(|s| s.as_str()).unwrap_or(index)
-    }
-}
-
-impl Strings {
-    pub fn load() -> Result<Self> {
-        Ok(Self(
-            include_str!("../../locale/en.ini")
-                .lines()
-                .skip(1)
-                .map(|l| {
-                    let (k, v) = l.split_once("=").ok_or(anyhow!("'=' missing"))?;
-                    Ok::<_, anyhow::Error>((
-                        k.trim_end().to_owned(),
-                        v.trim_start().replace("%n", "\n"),
-                    ))
-                })
-                .try_collect()?,
-        ))
-    }
-}
-
-static TR: LazyLock<Strings> = LazyLock::new(|| Strings::load().unwrap());
-pub fn tr(s: &'static str) -> &'static str {
-    &TR[s]
-}