Fluent translations

use fluent.qweruse fluent_format, fluent_format_file from fluent      // Quillo 0.6: only these

fluent-bundle = "=0.16.0"fluent-syntax = "=0.12.0"unic-langid = "0.9"serde_json = { version = "1", features = ["preserve_order"] }

// A shop in English, French and Polish with Project Fluent's .ftl files: plural forms by each language's rules, a gender selector, attributes, and fallback to English for what a translation lacks.////   quillo run fluent.qwe      then open http://localhost:8080/cartuse "fluent.qwer"let FILES = "fluent_sample_{locale}.ftl"fn tr(locale, id, args) = fluent_format_file(FILES, [locale, "en"], id, args)?.textroute GET /cart {    {        en: [tr("en", "cart-items", { count: 1 }), tr("en", "cart-items", { count: 3 })],        fr: [tr("fr", "cart-items", { count: 0 }), tr("fr", "cart-items", { count: 2 })],        // Polish has three forms: 1, 2-4 (and 22-24...), and 5 and up.        pl: [tr("pl", "cart-items", { count: 1 }), tr("pl", "cart-items", { count: 3 }), tr("pl", "cart-items", { count: 5 }), tr("pl", "cart-items", { count: 22 })],        welcome_fr: tr("fr", "welcome", { name: "Ana" }),        photos: tr("en", "shared-photos", { user: "Ana", count: 3, gender: "female" }),        placeholder: tr("fr", "login.placeholder", {}),        // Polish has no login message yet: it comes from English.        fallback: fluent_format_file(FILES, ["pl", "en"], "login.title", {})?,        missing_pl: fluent_missing(read_file("fluent_sample_en.ftl"), read_file("fluent_sample_pl.ftl"))?,        inline: fluent_format("hello = Hello, { $who }!", "en", "hello", { who: "world" })?,        broken: fluent_check("hello = Hello, { $who\nbye = Bye"),    }}

//! Project Fluent translations (.ftl files, as Firefox uses): messages formatted by locale with plurals ("one", "few", "many"...), selectors on gender or anything else, terms and attributes, falling back from "fr-CA" to "fr" to "en"; and translation files checked and compared.//! version: 1.0.0//!//! [dependencies]//! fluent-bundle = "=0.16.0"//! fluent-syntax = "=0.12.0"//! unic-langid = "0.9"//! serde_json = { version = "1", features = ["preserve_order"] }use fluent_bundle::{FluentArgs, FluentBundle, FluentResource, FluentValue};use fluent_syntax::ast::Entry;use serde_json::{json, Value};use unic_langid::LanguageIdentifier;const MAX_FILE: u64 = 10 * 1024 * 1024;fn resource(source: &str, name: &str) -> Result<FluentResource, String> {    FluentResource::try_new(source.to_string()).map_err(|(_, errs)| format!("{}: {}", name, errs.iter().map(|e| format!("{:?}", e.kind)).collect::<Vec<_>>().join("; ")))}fn args_of(args: &Value) -> FluentArgs<'static> {    let mut a = FluentArgs::new();    if let Some(o) = args.as_object() {        for (k, v) in o {            match v {                Value::Number(n) => a.set(k.clone(), FluentValue::from(n.as_f64().unwrap_or(0.0))),                Value::String(s) => a.set(k.clone(), FluentValue::from(s.clone())),                Value::Bool(b) => a.set(k.clone(), FluentValue::from(if *b { "true" } else { "false" })),                Value::Null => {}                other => a.set(k.clone(), FluentValue::from(other.to_string())),            }        }    }    a}fn locale(l: &str) -> Result<LanguageIdentifier, String> {    l.trim().parse().map_err(|_| format!("`{}` is not a locale (\"en\", \"fr-CA\")", l))}// The message `id` ("welcome", or "login.placeholder" for an attribute) formatted, or None when the bundle lacks it.fn format(bundle: &FluentBundle<FluentResource>, id: &str, args: &Value) -> Result<Option<String>, String> {    let (mid, attr) = match id.split_once('.') { Some((m, a)) => (m, Some(a)), None => (id, None) };    let Some(msg) = bundle.get_message(mid) else { return Ok(None) };    let pattern = match attr {        Some(a) => match msg.get_attribute(a) { Some(at) => at.value(), None => return Ok(None) },        None => match msg.value() { Some(p) => p, None => return Err(format!("`{}` has no value, only attributes", mid)) },    };    let fa = args_of(args);    let mut errors = vec![];    let s = bundle.format_pattern(pattern, Some(&fa), &mut errors);    Ok(Some(s.to_string()))}fn bundle_for(source: &str, loc: &str, name: &str) -> Result<FluentBundle<FluentResource>, String> {    let mut b = FluentBundle::new(vec![locale(loc)?]);    b.set_use_isolating(false);    b.add_resource(resource(source, name)?).map_err(|e| format!("{}: {:?}", name, e))?;    Ok(b)}/// The message `id` of the FTL text `source` formatted for `locale` with `args` (`{ count: 3, name: "Ana" }`): numbers choose plural forms by the locale's rules. `id` may name an attribute, `"login.placeholder"`. An error value when the message is missing.pub fn fluent_format(source: &str, locale: &str, id: &str, args: serde_json::Value) -> Result<String, String> {    let b = bundle_for(source, locale, "the FTL")?;    format(&b, id, &args)?.ok_or_else(|| format!("no message `{}`", id))}/// The message `id` from translation files: `path` has `{locale}` in it (`"locales/{locale}.ftl"`), and each of `locales` is tried in order (`["fr-CA", "fr", "en"]`) until one has the message; files that do not exist are skipped. `{ text, locale }`, the locale it came from.pub fn fluent_format_file(path: &str, locales: Vec<String>, id: &str, args: serde_json::Value) -> Result<Value, String> {    if !path.contains("{locale}") { return Err("the path holds `{locale}`, as in \"locales/{locale}.ftl\"".into()) }    for l in &locales {        let file = path.replace("{locale}", l);        let Ok(f) = std::fs::File::open(&file) else { continue };        let mut text = String::new();        std::io::Read::read_to_string(&mut std::io::Read::take(f, MAX_FILE), &mut text).map_err(|e| format!("{}: {}", file, e))?;        let b = bundle_for(&text, l, &file)?;        if let Some(s) = format(&b, id, &args)? { return Ok(json!({ "text": s, "locale": l })) }    }    Err(format!("no message `{}` for {}", id, locales.join(", ")))}/// The messages an FTL text defines, in order, with their attributes as `"id.attribute"`: for checking a translation is complete.pub fn fluent_messages(source: &str) -> Result<Vec<String>, String> {    let r = resource(source, "the FTL")?;    let mut out = Vec::new();    for e in r.entries() {        if let Entry::Message(m) = e {            out.push(m.id.name.to_string());            for a in &m.attributes { out.push(format!("{}.{}", m.id.name, a.id.name)) }        }    }    Ok(out)}/// Whether an FTL text parses: `{ valid, errors, messages }`, each error `{ line, kind }`, for checking translators' files on upload.pub fn fluent_check(source: &str) -> Value {    match FluentResource::try_new(source.to_string()) {        Ok(r) => json!({ "valid": true, "errors": [], "messages": r.entries().filter(|e| matches!(e, Entry::Message(_))).count() }),        Err((r, errs)) => {            let errors: Vec<Value> = errs.iter().map(|e| {                let line = source[..e.pos.start.min(source.len())].matches('\n').count() + 1;                json!({ "line": line, "kind": format!("{:?}", e.kind) })            }).collect();            json!({ "valid": false, "errors": errors, "messages": r.entries().filter(|e| matches!(e, Entry::Message(_))).count() })        }    }}/// What a translation lacks: the messages and attributes of `reference` (the source language's FTL) not in `translation`, and those `translation` has that `reference` does not: `{ missing, extra }`.pub fn fluent_missing(reference: &str, translation: &str) -> Result<Value, String> {    let a = fluent_messages(reference)?;    let b = fluent_messages(translation)?;    Ok(json!({        "missing": a.iter().filter(|x| !b.contains(x)).collect::<Vec<_>>(),        "extra": b.iter().filter(|x| !a.contains(x)).collect::<Vec<_>>(),    }))}