diff --git a/src/base/component/poweredby.rs b/src/base/component/poweredby.rs index cb02726f..c85e632c 100644 --- a/src/base/component/poweredby.rs +++ b/src/base/component/poweredby.rs @@ -1,15 +1,5 @@ use crate::prelude::*; -// Enlace a la página oficial de PageTop. -const PAGETOP_LINK: &str = concat!( - "", - "PageTop", - "", -); - /// Componente que muestra el típico mensaje *Powered by* (*Funciona con*) en el pie de página. /// /// Por defecto, usando [`default()`](Self::default) sólo se muestra un reconocimiento a PageTop. @@ -34,13 +24,18 @@ impl Component for PoweredBy { } async fn prepare(&self, cx: &mut Context) -> Result { + let pagetop_link = html! { + a href="https://pagetop.cillero.es" target="_blank" rel="noopener noreferrer" { + "PageTop" + } + }; Ok(html! { div id=[self.id()] class="poweredby" { @if let Some(c) = self.copyright() { span class="poweredby__copyright" { (c) "." } " " } span class="poweredby__pagetop" { - (Lc::l("poweredby_pagetop").with_arg("pagetop_link", PAGETOP_LINK).using(cx)) + (Lc::l("poweredby_pagetop").with_markup("pagetop_link", pagetop_link).using(cx)) } } }) diff --git a/src/locale/lc.rs b/src/locale/lc.rs index e7d51b48..507ea7da 100644 --- a/src/locale/lc.rs +++ b/src/locale/lc.rs @@ -7,6 +7,7 @@ include_locales!(LOCALES_PAGETOP); use fluent_templates::Loader; use fluent_templates::StaticLoader as Locales; +use fluent_templates::fluent_bundle::FluentValue; use std::collections::HashMap; @@ -34,18 +35,22 @@ enum LcKind { // `Text` resuelve a `FluentValue::String` para interpolar cualquier texto; pero no aplica el // selector de plural de Fluent (`{ $n -> [one] ... *[other] ... }`). Para eso está `Number`, que // resuelve a `FluentValue::Number` y es el único tipo con el que Fluent consulta las reglas de -// plural del idioma. +// plural del idioma. `Markup` es marcado HTML de confianza, que `using()` no escapa. #[derive(Clone, Debug)] enum LcArg { Text(CowStr), Number(u32), + Markup(String), } -impl<'a> From<&'a LcArg> for fluent_templates::fluent_bundle::FluentValue<'a> { - fn from(arg: &'a LcArg) -> Self { - match arg { +impl LcArg { + // Valor para Fluent. Con `escape`, el texto se escapa para insertarse en marcado HTML. + fn to_fluent(&self, escape: bool) -> FluentValue<'_> { + match self { + LcArg::Text(s) if escape => s.as_ref().render().into_string().into(), LcArg::Text(s) => s.as_ref().into(), LcArg::Number(n) => (*n).into(), + LcArg::Markup(s) => s.as_str().into(), } } } @@ -79,8 +84,8 @@ impl<'a> From<&'a LcArg> for fluent_templates::fluent_bundle::FluentValue<'a> { /// - [`using()`](Self::using) devuelve [`Markup`] para presentar al usuario, listo para insertarse /// en el contenido de una plantilla (`(x.using(cx))` dentro de [`html!`](crate::html::html)). /// Nunca devuelve `None`, por lo que una traducción no encontrada se convierte en marcado vacío. -/// Para `n()` se escapa el texto para evitar HTML no controlado. Para valores de atributo, usa -/// siempre [`lookup()`](Self::lookup). +/// Para `n()` se escapa el texto, y también los argumentos de texto de `l()`/`t()`, para evitar +/// HTML no controlado. Para valores de atributo, usa siempre [`lookup()`](Self::lookup). /// /// # Ejemplo /// @@ -169,9 +174,11 @@ impl Lc { /// Añade un argumento `{$arg}` => `value` a la traducción. /// - /// `value` se interpreta siempre como texto. Si se necesita un argumento numérico que además - /// deba seleccionar plural (`{ $n -> [one] ... *[other] ... }`), hay que utilizar en su lugar - /// [`with_number()`](Self::with_number). + /// `value` se interpreta siempre como texto: [`using()`](Self::using) lo escapa, así que puede + /// venir de datos de usuario sin riesgo de inyectar marcado. Para insertar marcado HTML de + /// confianza hay que utilizar [`with_markup()`](Self::with_markup). Si se necesita un argumento + /// numérico que además deba seleccionar plural (`{ $n -> [one] ... *[other] ... }`), hay que + /// utilizar [`with_number()`](Self::with_number). pub fn with_arg(mut self, arg: impl Into, value: impl Into) -> Self { self.args.push((arg.into(), LcArg::Text(value.into()))); self @@ -211,6 +218,30 @@ impl Lc { self } + /// Añade un argumento `{$arg}` => `markup` con marcado HTML de confianza, que + /// [`using()`](Self::using) inserta sin escapar. + /// + /// A diferencia de [`with_arg()`](Self::with_arg), sirve para incluir en la traducción un + /// fragmento HTML generado por la aplicación, como un enlace. No debe contener datos de usuario + /// sin escapar (construirlo con [`html!`](crate::html::html) los escapa): permitirían inyectar + /// marcado, p. ej. un enlace fraudulento en un correo legítimo de la aplicación. Con + /// [`get()`](Self::get) y [`lookup()`](Self::lookup) el marcado se interpola como texto. + /// + /// # Ejemplo + /// + /// ```rust,no_run + /// # use pagetop::prelude::*; + /// let link = html! { a href="https://pagetop.cillero.es" { "PageTop" } }; + /// let text = Lc::l("poweredby_pagetop") + /// .with_markup("pagetop_link", link) + /// .using(&Locale::resolve("es")); + /// ``` + pub fn with_markup(mut self, arg: impl Into, markup: Markup) -> Self { + self.args + .push((arg.into(), LcArg::Markup(markup.into_string()))); + self + } + // **< Lc GETTERS >***************************************************************************** /// Indica si la instancia está **sin contenido** ([`Lc::none()`]). @@ -267,22 +298,7 @@ impl Lc { /// let text = Lc::l("greeting").with_arg("name", "Usuario").lookup(&r); /// ``` pub fn lookup(&self, language: &impl LangId) -> Option { - match &self.op { - LcKind::None => None, - LcKind::Text(text) => Some(text.clone().into_owned()), - LcKind::Translate(key) => { - if self.args.is_empty() { - self.locales.try_lookup(language.langid(), key.as_ref()) - } else { - let mut args = HashMap::with_capacity(self.args.len()); - for (k, v) in self.args.iter() { - args.insert(k.clone(), v.into()); - } - self.locales - .try_lookup_with_args(language.langid(), key.as_ref(), &args) - } - } - } + self.resolve(language, false) } /// Traduce el texto y lo devuelve como [`Markup`] usando la fuente de idioma proporcionada. @@ -291,9 +307,11 @@ impl Lc { /// /// Las claves de traducción (`l()`/`t()`) son texto de confianza, con traducciones en ficheros /// `.ftl` que pueden incluir marcado HTML (p. ej. ``, enlaces, etc.) que se insertan - /// tal cual. El texto literal (`n()`), en cambio, suele venir de datos en tiempo de ejecución - /// que no debe interpretarse como marcado, por lo que se escapa igual que cualquier otro valor - /// interpolado con [`html!`](crate::html::html). + /// tal cual. El texto literal (`n()`) y los argumentos de texto + /// ([`with_arg()`](Self::with_arg)), en cambio, suelen venir de datos en tiempo de ejecución + /// que no deben interpretarse como marcado, por lo que se escapan igual que cualquier otro + /// valor interpolado con [`html!`](crate::html::html). El marcado de confianza que se pasa como + /// argumento con [`with_markup()`](Self::with_markup) se inserta sin escapar. /// /// No debe usarse para un valor de atributo (`attr=[...]` en [`html!`](crate::html::html)): el /// marcado de confianza que se aplica en `l()`/`t()` no tiene sentido ahí, y podría romper el @@ -309,7 +327,27 @@ impl Lc { pub fn using(&self, language: &impl LangId) -> Markup { match &self.op { LcKind::Text(text) => text.render(), - _ => PreEscaped(self.lookup(language).unwrap_or_default()), + _ => PreEscaped(self.resolve(language, true).unwrap_or_default()), + } + } + + // Resuelve la traducción. Con `escape`, los argumentos de texto se escapan para `using()`. + fn resolve(&self, language: &impl LangId, escape: bool) -> Option { + match &self.op { + LcKind::None => None, + LcKind::Text(text) => Some(text.clone().into_owned()), + LcKind::Translate(key) => { + if self.args.is_empty() { + self.locales.try_lookup(language.langid(), key.as_ref()) + } else { + let mut args = HashMap::with_capacity(self.args.len()); + for (k, v) in self.args.iter() { + args.insert(k.clone(), v.to_fluent(escape)); + } + self.locales + .try_lookup_with_args(language.langid(), key.as_ref(), &args) + } + } } } diff --git a/tests/locale.rs b/tests/locale.rs index ca55fd92..5dd93524 100644 --- a/tests/locale.rs +++ b/tests/locale.rs @@ -30,6 +30,42 @@ async fn translation_with_args() { assert_eq!(translation, Some("¡Hola, Manuel!".to_string())); } +// Text arguments may come from user data: `using()` must not let them inject markup. +#[pagetop::test] +async fn using_escapes_text_args() { + setup().await; + + let lc = Lc::l("test_hello_user").with_arg("userName", r#"Ana & "Luis""#); + assert_eq!( + lc.using(&Locale::resolve("es-ES")).into_string(), + "¡Hola, <a href="x">Ana & "Luis"</a>!" + ); +} + +// `lookup()` returns plain text, escaped later where it is used (e.g. in an attribute). +#[pagetop::test] +async fn lookup_does_not_escape_text_args() { + setup().await; + + let lc = Lc::l("test_hello_user").with_arg("userName", "Ana & "); + assert_eq!( + lc.lookup(&Locale::resolve("es-ES")), + Some("¡Hola, Ana & !".to_string()) + ); +} + +#[pagetop::test] +async fn using_keeps_markup_args() { + setup().await; + + let name = "Ana & Luis"; + let lc = Lc::l("test_hello_user").with_markup("userName", html! { strong { (name) } }); + assert_eq!( + lc.using(&Locale::resolve("es-ES")).into_string(), + "¡Hola, Ana & Luis!" + ); +} + #[pagetop::test] async fn translation_with_plural_and_select() { setup().await;