Internationalisation des applications Rust : de zéro au multilinguisme

Pourquoi votre application Rust a besoin d'internationalisation (et comment éviter les pièges)

Vous avez écrit un analyseur parfait en Rust. Il vole plus vite que l'éclair et consomme moins de mémoire qu'une modeste mésange. Mais il y a un problème : votre texte s'affiche uniquement en anglais. Et les utilisateurs de Tokyo, Berlin et Saint-Pétersbourg veulent voir l'interface dans leur langue maternelle.

L'internationalisation (i18n) n'est pas simplement « traduire les boutons ». C'est une décision architecturale qui peut transformer votre code en un constructeur élégant ou en un dépotoir infernal de if-else. Dans cet article, nous allons voir comment faire de l'internationalisation en Rust correctement : sans douleur, avec des exemples et dans le respect du cerveau du futur développeur (le vôtre).

Nous parlerons de deux approches puissantes : la bibliothèque fluent (recommandation de Mozilla) et le classique rust-i18n basé sur gettext. À la fin de cet article, vous pourrez ajouter la prise en charge du russe, de l'anglais et de toute autre langue à votre outil en 15 minutes.

Plan de bataille : qu'est-ce que i18n et l10n dans le monde Rust

Avant de se jeter dans le code, mettons-nous d'accord sur les termes :

\n
• Internationalisation (i18n) — la préparation du code à la traduction. Vous extrayez toutes les chaînes dans des fichiers séparés et apprenez au programme à charger la locale appropriée.
\n
• Localisation (l10n) — la traduction elle-même. Création de fichiers pour chaque langue.
\n
• Locale — une combinaison de langue et de région (par exemple, ru-RU, en-US, de-DE).
\n

En Rust, il existe plusieurs chemins. Nous allons examiner les deux plus populaires :

\n
• Fluent — un système moderne de Mozilla. Puissant, flexible, avec prise en charge de la pluralisation et du contexte.
\n
• rust-i18n — des macros inspirées de Ruby on Rails. Plus simple, mais moins flexible.
\n

Le choix dépend de la tâche. Pour les utilitaires CLI, rust-i18n suffit. Pour les applications web ou les GUI complexes (par exemple, sur Tauri), il est préférable d'utiliser Fluent.

Méthode n°1 : Internationalisation Rust avec Fluent (approche professionnelle)

Installation et configuration de Fluent

Créons un nouveau projet et ajoutons les dépendances :

cargo new i18n_demo\ncd i18n_demo\ncargo add fluent fluent-bundle fluent-langtag unic-langid\n

La structure des fichiers sera la suivante :

projet/\n├── Cargo.toml\n├── locales/\n│   ├── ru/\n│   │   └── main.ftl\n│   └── en/\n│       └── main.ftl\n└── src/\n    └── main.rs\n

Création des fichiers de localisation (FTL)

Fluent utilise le format FTL (Fluent Translation List). C'est la pureté et la puissance :

locales/en/main.ftl :

greeting = Hello, { $name }!\ngoodbye = Goodbye\napples = { $count ->\n    [one] { $count } apple\n    [few] { $count } apples\n    *[other] { $count } apples\n}\n

locales/ru/main.ftl :

greeting = Привет, { $name }!\ngoodbye = До свидания\napples = { $count ->\n    [one] { $count } яблоко\n    [few] { $count } яблока\n    [many] { $count } яблок\n    *[other] { $count } яблок\n}\n

Remarquez la pluralisation. En russe, il y a quatre formes (un, deux-quatre, cinq-vingt, le reste), tandis qu'en anglais il y en a deux (un, le reste). Fluent gère cela automatiquement.

Écriture du code Rust pour charger les locales

Maintenant, la partie intéressante — le code qui sélectionnera la langue appropriée en fonction du système de l'utilisateur :

use fluent_bundle::{FluentBundle, FluentResource};\nuse unic_langid::LanguageIdentifier;\nuse std::fs;\nuse std::path::Path;\n\nfn load_locale(locale: &str) -> FluentBundle<FluentResource> {\n    let langid: LanguageIdentifier = locale.parse().expect("Locale invalide");\n    let mut bundle = FluentBundle::new(vec![langid]);\n\n    let file_path = format!("locales/{}/main.ftl", locale);\n    let source = fs::read_to_string(&file_path)\n        .expect(&fo