Configuration

Internationalisation (i18n)

Runique intègre un système d'internationalisation léger, sans dépendance externe.

Langues supportées

Variante `Lang`	Code	Exemples de locales reconnues
`Lang::Fr`	`fr`	`fr`, `fr-FR`, `fr-CA`, `fr-BE`, `fr-CH`
`Lang::En`	`en`	`en`, `en-US`, `en-GB`, `en-CA`
`Lang::De`	`de`	`de`, `de-DE`, `de-AT`, `de-CH`
`Lang::Es`	`es`	`es`, `es-ES`, `es-MX`, `es-AR`
`Lang::It`	`it`	`it`, `it-IT`, `it-CH`
`Lang::Pt`	`pt`	`pt`, `pt-PT`, `pt-BR`
`Lang::Ja`	`ja`	`ja`, `ja-JP`
`Lang::Zh`	`zh`	`zh`, `zh-CN`, `zh-TW`, `zh-HK`
`Lang::Ru`	`ru`	`ru`, `ru-RU`, `ru-BY`, `ru-UA`

La langue par défaut est Lang::En si aucune configuration explicite n'est fournie.

API disponible

use runique::utils::trad::{set_lang, current_lang, t, tf, Lang};

// Définir la langue globale
set_lang(Lang::Fr);

// Lire la langue active
let lang = current_lang(); // → Lang::Fr

// Traduire une clé
let msg = t("forms.required"); // → "Ce champ est obligatoire"

// Traduire une clé avec paramètres (remplace {} par les arguments)
let msg = tf("forms.too_short", &[3]); // → "Trop court (min 3)"

Fonction	Signature	Description
`set_lang`	`fn set_lang(lang: Lang)`	Définit la langue globale de l'application
`current_lang`	`fn current_lang() -> Lang`	Retourne la langue active (défaut : `En`)
`t`	`fn t(key: &str) -> Cow<'static, str>`	Traduit une clé simple
`tf`	`fn tf<T: Display>(key: &str, args: &[T]) -> String`	Traduit une clé avec substitutions `{}`

Format des clés

Les clés suivent la notation pointée "section.sous_section.clé" qui correspond à la hiérarchie du JSON de traduction.

"forms.required"       → { "forms": { "required": "..." } }
"forms.too_short"      → { "forms": { "too_short": "Trop court (min {})" } }
"error.not_found"      → { "error": { "not_found": "..." } }

Le {} dans une valeur est remplacé séquentiellement par les arguments passés à tf.

Comportement de fallback

Si une clé est absente dans la langue cible, Runique applique le fallback suivant :

Cherche la clé dans la langue configurée (ex : Lang::Fr)
Si absente, essaie Lang::En
Si toujours absente, retourne la clé brute (ex : "forms.required")

Ce mécanisme garantit qu'une traduction incomplète ne provoque jamais de panique.

Configuration dans `main.rs`

Appelle set_lang() avant la construction du builder, typiquement juste après le chargement de la configuration :

use runique::prelude::*;
use runique::utils::trad::{set_lang, Lang};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = RuniqueConfig::from_env();

    // Définir la langue de l'application
    set_lang(Lang::Fr);

    RuniqueApp::builder(config)
        .routes(urls::routes())
        .with_database(db)
        .build()
        .await?
        .run()
        .await?;

    Ok(())
}

La langue définie ici s'applique aux messages visibles par l'utilisateur : validation de formulaires et messages d'erreur. Les logs internes (tracing::warn!) sont hardcodés en français dans le source et ne sont pas traduits.

Variable `LANG` pour la CLI

La CLI runique lit la variable d'environnement LANG (ou LC_ALL / LC_MESSAGES en fallback) pour choisir sa propre langue d'affichage.

Important : LANG dans .env ne s'applique qu'à la CLI (runique start, runique new, etc.). La langue de l'application web est contrôlée par set_lang() dans main.rs.

Priorité pour la CLI :

Variable LANG dans .env (chargé via dotenvy)
Variable LANG / LC_ALL / LC_MESSAGES du système
En par défaut si aucune variable n'est définie ou reconnue

# .env — CLI uniquement
LANG=fr

Les locales complètes sont normalisées automatiquement : fr_FR.UTF-8 est interprété comme fr.