advotracker_client: adopt usage of crate twine

* i18n crate
* twine::build_translations(): generate the i18n.rs with all
  language translation strings
* twine::build_translations_from_readers(): generates to t!() macro
  readers: the INI files with the translation strings
* twine::t() consumes the strings

crates/advotracker_client/Cargo.toml

@@ -9,22 +9,12 @@ edition = "2018"
 default-run = "advotracker"
 build = "build.rs"
 
-#[target.x86_64-pc-windows-gnu]
+[target.x86_64-pc-windows-gnu]
-#linker = "lld-link"
+linker = "lld-link"
-
-
-#[target.x86_64-pc-windows-msvc]
-#linker = "lld-link"
-# linker path on msvc set via system environment
-#linker = "link.exe"
-##windres = { git = "https://github.com/FaultyRAM/windres-rs", branch = "master" }
-##diesel = { version = "1.4", features = [ "postgres", "sqlite" ] }
-##winapi = { version = "0.3", features = [ "winuser" ] }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = [ "winuser" ] }
 windres = { git = "https://github.com/FaultyRAM/windres-rs", branch = "master" }
-#diesel = { version = "1.4", features = [ "postgres", "sqlite" ] }
 
 [dependencies]
 async-stream = "~0.2"
@@ -34,29 +24,23 @@ clap = { version = "~2.33", features = ["suggestions", "color"] }
 csv = { version = "~1.1" }
 dotenv = { version = "~0.15.0" }
 envy = { version = "~0.4" }
-#lettre ={ version = "0.10.0-beta.1", features = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"] }
 lettre ={ version = "0.10.0-beta.1" }
 lazy_static = { version = "~1.4.0" }
 log = { version = "~0.4.8" }
-locales = { version = "~0.1" }
 maud = { version = "~0.22.1" }
-#orbtk = { version = "~0.3.1-alpha4" }
 orbtk = { git = "https://github.com/redox-os/orbtk.git", branch = "develop" }
 #orbtk = { path = "../../../orbtk" }
-serde = { version = "~1.0", features = ["derive"] }
+serde = { version = "~1", features = ["derive"] }
 sdl2 = { version = "~0.34", features = ["bundled"] }
 substring = { version = "~1" }
-#tokio = { version = "~0.2", features = ["macros", "rt-threaded", "stream", "time"] }
 tracing = { version = "~0.1" }
 tracing-subscriber = { version = "~0.2.0", features = ["tracing-log"] }
 viperus =  { git = "https://github.com/maurocordioli/viperus", features = ["cache", "fmt-clap", "fmt-env", "global", "watch"] }
+twine = { version = "~0.3.8", features = ["serde"] }
 
 [build-dependencies]
-#winres = { version = "0.1" }
 winres = { version = "0.1.11" }
 
-#[dev-dependencies]
-
 [features]
 default = []
 debug = ["orbtk/debug"]
@@ -71,10 +55,6 @@ description = "Supports lawyers to capture relevant data encountered during an o
 [package.metadata.winres]
 LegalCopyright = "Copyright © 2020-2021"
 
-#[[bin]]
-#//name = "policycheck"
-#path = "src/bin/policycheck.rs"
-
 [[bin]]
 name = "advotracker"
 path = "src/main.rs"

crates/advotracker_client/build.rs

@@ -6,8 +6,14 @@
  */
 
 extern crate winres;
+extern crate twine;
+
+use twine::build_translations;
 
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    twine::build_translations(&["./i18n/localization.ini"], "i18n.rs").unwrap();
+
     if cfg!(target_os = "windows") {
 	let mut res = winres::WindowsResource::new();
 	//res.set_icon(".\assets\icons\adovtracker\advotracker.ico")

crates/advotracker_client/src/locales/advotracker.json

@@ -1,248 +0,0 @@
-{
-    "err.lang.not_found": {
-	"de_DE.UTF-8": "Konnte Sprachkode nicht auslesen",
-	"de_DE": "Konnte Sprachkode nicht auslesen",
-	"C": "Couldn't read LANG"
-    },
-    "err.user.not_found": {
-	"fr": "Utilisateur introuvable: $email, $id",
-	"de_DE.UTF-8": "Anwender nicht gefunden: $email, $id",
-	"de_DE": "Anwender nicht gefunden: $email, $id",
-	"C": "User not found: $email, $id"
-    },
-    "main.started": {
-	"de_DE.UTF-8": "Programmlogik starten",
-	"de_DE": "Programmlogik starten",
-	"C": "Program logic started"
-    },
-    "main.finished": {
-	"de_DE.UTF-8": "Programmlogik beendet",
-	"de_DE": "Programmlogik beendet",
-	"C": "Program logic finished"
-    },
-    "parse.arguments": {
-	"de_DE.UTF-8": "Programmargumente prüfen",
-	"de_DE": "Programmargumente prüfen",
-	"C": "Parsing arguments"
-    },
-    "parse.environment": {
-	"de_DE.UTF-8": "Umgebungsvariablen prüfen",
-	"de_DE": "Umgebungsvariablen prüfen",
-	"C": "Parsing environment"
-    },
-    "parse.results": {
-	"de_DE.UTF-8": "Ergebnisse der Konfigurations-Parameterprüfung",
-	"de_DE": "Ergebnisse der Konfigurationsparameterprüfung",
-	"C": "Config parsing results"
-    },
-    "config.name": {
-	"de_DE.UTF-8": "Konfigurationswert für",
-	"de_DE": "Konfigurationswert für",
-	"C": "Config Value for"
-    },
-    "config.name.lang": {
-	"de_DE.UTF-8": "Sprach-Code_DE",
-	"de_DE": "Sprach-Code_DE",
-	"C": "Language code_DE"
-    },
-    "config.name.verbositylevel": {
-	"de_DE.UTF-8": "Ausgabe-Ebene",
-	"de_DE": "Ausgabe-Ebene",
-	"C": "verbosity level"
-    },
-    "config.name.environment": {
-	"de_DE.UTF-8": "Umgebungsvariablen",
-	"de_DE": "Umgebungsvariablen",
-	"C": "environment"
-    },
-    "config.name.configfile": {
-	"de_DE.UTF-8": "Konfigurations-Datei",
-	"de_DE": "Konfigurations-Datei",
-	"C": "config file"
-    },
-    "config.name.dbdriver": {
-	"de_DE.UTF-8": "Datenbank-Treiber",
-	"de_DE": "Datenbank-Treiber",
-	"C": "database driver"
-    },
-    "config.name.redis": {
-	"de_DE.UTF-8": "Redis Datenbank",
-	"de_DE": "Redis Datenbank",
-	"C": "Redis database"
-    },
-    "csv.export.started": {
-	"de_DE.UTF-8": "Export in eine CSV Datei starten",
-	"de_DE": "Export in eine CSV Datei starten",
-	"C": "Export to csv file started"
-    },
-    "csv.export.finished": {
-	"de_DE.UTF-8": "Export in eine CSV Datei beendet",
-	"de_DE": "Export in eine CSV Datei beendet",
-	"C": "Export to csv file finished"
-    },
-    "csv.import.started": {
-	"de_DE.UTF-8": "Import aus einer CSV Datei",
-	"de_DE": "Import aus einer CSV Datei",
-	"C": "Import from a csv file"
-    },
-    "csv.import.finished": {
-	"de_DE.UTF-8": "Import aus einer CSV Datei beendet",
-	"de_DE": "Import aus einer CSV Datei beendet",
-	"C": "Import from a csv file finished"
-    },
-    "redis.connection.error": {
-	"de_DE.UTF-8": "Es konnte keine Redis Verbindung aufgebaut werden",
-	"de_DE": "Es konnte keine Redis Verbindung aufgebaut werden",
-	"C": "Could not establish a redis connection"
-    },
-    "policy.hashmap.success": {
-	"de_DE.UTF-8": "Hashmap wurde erfolgreich erstellt",
-	"de_DE": "Hashmap wurde erfolgreich erstellt",
-	"C": "Hashmap creation was successfull"
-    },
-    "policy.hashmap.failed": {
-	"de_DE.UTF-8": "Hashmap konnte nicht erstellt werden",
-	"de_DE": "Hashmap konnte nicht erstellt werden",
-	"C": "Hashmap creation failed"
-    },
-    "policy.menu.label": {
-	"de_DE.UTF-8": "Menü",
-	"de_DE": "Menü",
-	"C": "Menu"
-    },
-    "policy.menu.label_account": {
-	"de_DE.UTF-8": "Aktueller Benutzer",
-	"de_DE": "Aktueller Benutzer",
-	"C": "Active user"
-    },
-    "policy.menu.label_quit": {
-	"de_DE.UTF-8": "Beenden",
-	"de_DE": "Beenden",
-	"C": "Quit"
-    },
-    "policy.menu.label_toggle_theme": {
-	"de_DE.UTF-8": "Thema wechseln",
-	"de_DE": "Thema wechseln",
-	"C": "Toggle theme"
-    },
-    "policy.string.header": {
-	"de_DE.UTF-8": "Validierung Versicherungsnummer",
-	"de_DE": "Validierung Versicherungsnummer",
-	"C": "Policy number validation"
-    },
-    "policy.string.label_policy_data": {
-	"de_DE.UTF-8": "Importierte Daten",
-	"de_DE": "Importierte Daten",
-	"C": "imported data"
-    },
-    "policy.string.label_policy_list": {
-	"de_DE.UTF-8": "Versicherungsnummern-Liste",
-	"de_DE": "Versicherungsnummern-Liste",
-	"C": "policy list"
-    },
-    "policy.string.label_policy_number": {
-	"de_DE.UTF-8": "Versicherungsnummer",
-	"de_DE": "Versicherungsnummer",
-	"C": "policy number"
-    },
-    "policy.string.label_result": {
-	"de_DE.UTF-8": "Prüfungsergebnis",
-	"de_DE": "Prüfungsergebnis",
-	"C": "check result"
-    },
-    "policy.string.data_count": {
-	"de_DE.UTF-8": "Anzahl Prüflistenelemente",
-	"de_DE": "Anzahl Prüflistenelemente",
-	"C": "Number of checklist elements"
-    },
-    "policy.string.import_data": {
-	"de_DE.UTF-8": "Importieren der Prüflisten-Elemente",
-	"de_DE": "Importieren der Prüflisten-Elemente",
-	"C": "Import checklist elements"
-    },
-    "policy.string.progress_time": {
-	"de_DE.UTF-8": "Bearbeitungszeit",
-	"de_DE": "Bearbeitungszeit",
-	"C": "processing time"
-    },
-    "policy.string.progress_text": {
-	"de_DE.UTF-8": "Importiere Daten",
-	"de_DE": "Importiere Daten",
-	"C": "Importing data"
-    },
-    "policy.validation.button_failed": {
-	"de_DE.UTF-8": "ungültig",
-	"de_DE": "ungültig",
-	"C": "invalid"
-    },
-    "policy.validation.button_success": {
-	"de_DE.UTF-8": "gültig",
-	"de_DE": "gültig",
-	"C": "valid"
-    },
-    "policy.validation.failed": {
-	"de_DE.UTF-8": "Die Versicherungsscheinnummber ist ungültig",
-	"de_DE": "Die Versicherungsscheinnummber ist ungültig",
-	"C": "The given policy number is invalid"
-    },
-    "policy.validation.new": {
-	"de_DE.UTF-8": "Neue Prüfung",
-	"de_DE": "Neue Prüfung",
-	"C": "New validation"
-    },
-    "policy.validation.success": {
-	"de_DE.UTF-8": "Die Versicherungsscheinnummber ist gültig",
-	"de_DE": "Die Versicherungsscheinnummber ist gültig",
-	"C": "The given policy number is valid"
-    },
-    "policy.validation.started": {
-	"de_DE.UTF-8": "Die Prüfung der Versicherungsscheinnummber wurde gestartet",
-	"de_DE": "Die Prüfung der Versicherungsscheinnummber wurde gestartet",
-	"C": "Validation of the policy number started"
-    },
-    "policy.validation.finished": {
-	"de_DE.UTF-8": "Die Prüfung der Versicherungsscheinnummber wurde beendet",
-	"de_DE": "Die Prüfung der Versicherungsscheinnummber wurde beendet",
-	"C": "Validation of the policy number finished"
-    },
-    "policy.validation.invalid_input": {
-	"de_DE.UTF-8": "Nur Nummer sind zulässig",
-	"de_DE": "Nur Nummer sind zulässig",
-	"C": "Only numbers are valid"
-    },
-    "policy.validation.not_found": {
-	"de_DE.UTF-8": "Nummer ist nicht aktiviert",
-	"de_DE": "Nummer ist nicht aktiviert",
-	"C": "number isn't marked active"
-    },
-    "policy.validation.to_long": {
-	"de_DE.UTF-8": "Die Nummer ist zu lang",
-	"de_DE": "Die Nummer ist zu lang",
-	"C": "Policy number is to long"
-    },
-    "policy.validation.to_short": {
-	"de_DE.UTF-8": "Die Nummer ist zu kurz",
-	"de_DE": "Die Nummer ist zu kurz",
-	"C": "Policy number is to short"
-    },
-    "sendticketdata.export.started":{
-	"de_DE.UTF-8": "Versenden von ticket daten via eMail gestartet",
-	"de_DE": "Versenden von ticket daten via eMail gestartet",
-	"C": "Send ticket data via eMail started"
-    },
-    "sendticketdata.export.finished":{
-	"de_DE.UTF-8": "Versenden von ticket daten via eMail beendet",
-	"de_DE": "Versenden von ticket daten via eMail beendet",
-	"C": "Send ticket data via eMail finished"
-    },
-    "state.started": {
-	"de_DE.UTF-8": "gestartet",
-	"de_DE": "gestartet",
-	"C": "started"
-    },
-    "state.finished": {
-	"de_DE.UTF-8": "beendet",
-	"de_DE": "beended",
-	"C": "finished"
-    }
-}

crates/advotracker_client/src/main.rs

@@ -8,18 +8,15 @@
 // suppress creation of a new console window on window
 #![windows_subsystem = "windows"]
 
-//#[macro_use]
-//extern crate lazy_static;
-
 //use chrono::{Local, DateTime};
 use dotenv::dotenv;
-use locales::t;
 use cfg_if::cfg_if;
 use serde::Deserialize;
 use std::env;
 //use std::process;
 use substring::Substring;
 use tracing::{info, trace, Level};
+use twine::t;
 
 use orbtk::{
     prelude::*,
@@ -60,8 +57,8 @@ static ADVOTRACKER_DE_DE: &str = include_str!("../assets/advotracker/advotracker
 /// Get the active language environment.
 fn get_lang() -> String {
     // get system environment
-    let mut lang = env::var("LANG").unwrap_or_else(|_| "C".to_string());
+    let mut lang = env::var("LANG").unwrap_or_else(|_| "en".to_string());
-    lang = lang.substring(0,5).to_string();   // "de_DE.UTF-8" -> "de_DE"
+    lang = lang.substring(0,2).to_string();   // "de_DE.UTF-8" -> "de"
     info!("GUI-Language: preset to {:?}", lang);
 
     // testing environment: read from .env file
@@ -146,28 +143,31 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 	// get system environment
 	let lang = get_lang();
 
-        let mut state = t!("state.started", lang);
+	// include localization strings
-        let mut res = t!("parse.environment", lang);
+	include!(concat!(env!("OUTDIR"), "/i18n.rs"));
+
+	let mut state = t!(state_started => lang);
+	let mut res = t!(parse_environment => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
 	trace!(target: "advotracker", environment = "system", lang = ?lang);
 	trace!(target: "advotracker", machine = ?&machine_kind);
 
 	// how to handle unimplemented lang resources??
-        res = t!("parse.environment", lang);
+	res = t!(parse_environment => lang);
 	trace!(target: "advotracker", environment = "envy", lang = ?lang);
-        state = t!("state.finished", lang);
+	state = t!(state_finished => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
 
 	// initialize viperus structure
 	let mut viperus = Viperus::new();
 
 	// parse commandline arguments
-        res = t!("parse.arguments", lang);
+	res = t!(parse_arguments => lang);
-        state = t!("state.started", lang);
+	state = t!(state_started => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
 
 	let _ = parse_args(&mut viperus);
-        state = t!("state.finished", lang);
+	state = t!(state_finished => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
 
 	// type conversion (viperus String -> u64)
@@ -175,8 +175,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 	trace!(target: "advotracker", test_policy_number = ?test_policy_number);
 
 	// main tasks
-        res = t!("main.started", lang);
+	res = t!(main_started => lang);
-        state = t!("state.started", lang);
+	state = t!(state_started => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
 
 	// use this only if you want to run it as web application.
@@ -185,8 +185,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 	// Preset localization and language from given environment.
 	// if no dictionary is set for the chosen default language
 	// the content of the text property will be drawn.
-        //let language = lang.substring(0,5);   // "de_DE.UTF-8" -> "de_DE"
-        //info!("GUI-Language: preset to {:?}", language);
 	let localization = RonLocalization::create()
 	    .language(&lang)
 	    .dictionary("de_DE", ADVOTRACKER_DE_DE)
@@ -208,8 +206,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 	    })
 	    .run();
 
-        state = t!("state.finished", lang);
+	state = t!(state_finished => lang);
-        res = t!("main.finished", lang);
+	res = t!(main_finished => lang);
 	trace!(target: "advotracker", process = ?res, state = ?state);
     });
 

crates/advotracker_client/src/services/exports/allianzdirectcall.rs

@@ -18,8 +18,11 @@ pub fn export(p: &mut String, lang: &str) -> Result<(), Box<dyn Error>> {
     use std::path::Path;
     //use std::ffi::OsStr;
 
-    let mut res = t!("csv.export.started", lang);
+    // include localization strings
-    let mut state = t!("state.started", lang);
+    include!(concat!(env!("OUT_DIR"), "/i18n.rs"));
+
+    let mut res = t!(csv_export_started => lang);
+    let mut state = t!(state_started => lang);
     trace!(target: "csv-export", process = ?res, state = ?state);
 
     // Note: slash syntax also works on Windows!
@@ -29,8 +32,8 @@ pub fn export(p: &mut String, lang: &str) -> Result<(), Box<dyn Error>> {
     let file = File::open(path)?;
 
     trace!(target: "csv.export", extension = ?path.extension(), file = ?file);
-    state = t!("state.finished", lang);
+    state = t!(state_finished => lang);
-    res = t!("csv.export.finished", lang);
+    res = t!(csv_export_finished", lang);
     trace!(target: "csv-export", process = ?res, state = ?state);
 
     Ok(())

crates/advotracker_client/src/services/exports/send_ticketdata.rs

@@ -20,8 +20,11 @@ use crate::data::structures::Email;
 
 /// send ticket data via eMail
 pub fn sendticketdata(email: &Email, lang: &str) -> Result<(), Box<dyn Error>> {
-    let mut res = t!("sendticketdata.export.started", lang);
+    // include localization strings
-    let mut state = t!("state.started", lang);
+    include!(concat!(env!("OUT_DIR"), "/i18n.rs"));
+
+    let mut res = t!(sendticketdata_export_started => lang);
+    let mut state = t!(state_started =>lang);
     trace!(target: "sendticketdata", process = ?res, state = ?state);
 
     // The html we want to send.
@@ -114,8 +117,8 @@ pub fn sendticketdata(email: &Email, lang: &str) -> Result<(), Box<dyn Error>> {
     // Send the email and catch the error if it isn't successfully
     let _result = mailer.send(&message)?;
 
-    state = t!("state.finished", lang);
+    state = t!(state_finished => lang);
-    res = t!("sendticketdata.export.finished", lang);
+    res = t!(sendticketdata_export_finished => lang);
     trace!(target: "sendticketdata", process = ?res, state = ?state);
 
     Ok(())

crates/advotracker_client/src/services/imports/allianzdirectcall.rs

@@ -29,6 +29,9 @@ pub fn import(p: &mut String, data_list: &mut PolicyDataList,
     use std::path::Path;
     use std::ffi::OsStr;
 
+    // include localization strings
+    include!(concat!(env!("OUT_DIR"), "/i18n.rs"));
+
     let mut res = t!("csv.import.started", lang);
     let mut state = t!("state.started", lang);
     let time_start = SystemTime::now();

crates/advotracker_client/src/widgets/policycheck/policycheck_state.rs

@@ -92,8 +92,11 @@ impl PolicycheckState {
 	let policy_list = PolicyList::new("policy list");
 	trace!(target: "advotracker",  policy_list = ?policy_list);
 
+	// include localization strings
+	include!(concat!(env!("OUTDIR"), "/i18n.rs"));
+
 	// create vector to hold imported data
-        let res = t!("policy.string.label_policy_data", self.lang);
+	let res = t!(policy_string_label_policy_data => self.lang);
 	let mut policy_data = PolicyDataList::new(res);
 	trace!(target: "advotracker",  policy_data = ?policy_data);
 
@@ -155,7 +158,7 @@ impl PolicycheckState {
 		// importing policy code elements from csv-file
 		match self.create_hashmap(ctx) {
 		    Ok(()) => {
-                        let res = t!("policy.hashmap.success", self.lang);
+			let res = t!(policy_hashmap_success => self.lang);
 			info!("hashmap has: {:?} entries", self.policy_data_count);
 			trace!(target: "advotracker",
 			       hashmap_status = ?res,
@@ -166,7 +169,7 @@ impl PolicycheckState {
 
 		    }
 		    _ => {
-                        let res = t!("policy.hashmap.failed", self.lang);
+			let res = t!(policy_hashmap_failed => self.lang);
 			error!("{:?}", res);
 			trace!(target: "advotracker", hashmap_status = ?res);
 		    }
@@ -254,7 +257,7 @@ impl PolicycheckState {
 			}
 			_ => {
 			    // no matching key
-                            let res = t!("policy.validation.failed", self.lang);
+			    let res = t!(policy_validation_failed => self.lang);
 			    trace!(target: "advotracker", state = ?res, policy_number = ?p);
 
 			    TextBox::foreground_set(&mut ctx.child(ID_POLICY_CHECK_POLICY_NUMBER), String::from("#FF0000"));
@@ -292,7 +295,7 @@ impl PolicycheckState {
 	    }
 	}
 	if policy_number_length < 10 {
-            let res = t!("policy.validation.failed", self.lang);
+	    let res = t!(policy_validation_failed => self.lang);
 	    trace!(target: "advotracker", state = ?res, reason = "number to short");
 
 	    TextBox::foreground_set(&mut ctx.child(ID_POLICY_CHECK_POLICY_NUMBER), String::from("#FF0000"));
@@ -312,7 +315,7 @@ impl PolicycheckState {
 	    TextBlock::visibility_set(&mut ctx.child(ID_POLICY_CHECK_LABEL_HINT), Visibility::Visible);
 	}
 	if policy_number_length > 10 {
-            let res = t!("policy.validation.failed", self.lang);
+	    let res = t!(policy_validation_failed => self.lang);
 	    trace!(target: "advotracker", state = ?res, reason = "number to long");
 
 	    TextBox::foreground_set(&mut ctx.child(ID_POLICY_CHECK_POLICY_NUMBER), String::from("#FF0000"));
@@ -420,7 +423,7 @@ impl PolicycheckState {
     }
 
     fn update_progress_bar(&self, ctx: &mut Context<'_>) {
-        let res = t!("policy.string.progress_time", self.lang);
+	let res = t!(policy_string_progress_time => self.lang);
 	let string_duration = format!("{}: {:?}", res, self.duration);
 
 	TextBlock::text_set(&mut ctx.child(ID_POLICY_CHECK_PROGRESS_TIME), string_duration);