📝 Quita cursivas de algunos anglicismos en docs

src/auth.rs

@@ -17,7 +17,7 @@ use crate::{UniqueId, Weight};
 ///
 /// Se almacena automáticamente en el [`Context`] a partir de la petición HTTP (ver
 /// [`Context::new()`](crate::core::component::Context::new)). La identidad se extrae de las
-/// extensiones de la petición, que una extensión de autenticación inyecta mediante su *middleware*.
+/// extensiones de la petición, que una extensión de autenticación inyecta mediante su middleware.
 ///
 /// Se accede con [`Contextual::current_user()`](crate::core::component::Contextual::current_user).
 ///
@@ -72,9 +72,9 @@ impl CurrentUser {
 /// Se invoca con:
 ///
 /// - `cx`: el contexto de renderizado desde el que se puede acceder a la petición HTTP y a
-///   cualquier dato inyectado por el *middleware* de autenticación.
+///   cualquier dato inyectado por el middleware de autenticación.
 /// - `key`: clave del permiso a comprobar (p. ej. `"myapp.edit_posts"`).
-/// - `granted`: referencia mutable; el *handler* debe asignarla a `true` si concede el permiso.
+/// - `granted`: referencia mutable; el handler debe asignarla a `true` si concede el permiso.
 pub type FnCheckPermission = fn(cx: &Context, key: &str, granted: &mut bool);
 
 /// Acción para comprobar si el usuario actual tiene un permiso concreto.
@@ -148,7 +148,7 @@ impl CheckPermission {
 /// Comprueba si el usuario actual tiene el permiso indicado.
 ///
 /// Despacha la acción [`CheckPermission`]: cualquier extensión registrada puede conceder el permiso
-/// asignando `granted = true` en su *handler*. Si no hay extensiones de autenticación activas,
+/// asignando `granted = true` en su handler. Si no hay extensiones de autenticación activas,
 /// devuelve `false` para cualquier usuario, incluido el anónimo.
 ///
 /// La decisión de conceder o denegar permisos al usuario anónimo también es responsabilidad de cada

src/core/component/context.rs

@@ -357,7 +357,7 @@ impl Context {
         }
     }
 
-    // Extrae el `CurrentUser` inyectado por *middleware* en las extensiones de la petición, o
+    // Extrae el `CurrentUser` inyectado por middleware en las extensiones de la petición, o
     // `CurrentUser::Anonymous` si no hay petición o ninguna extensión de autenticación está activa.
     fn resolve_current_user(request: Option<&HttpRequest>) -> CurrentUser {
         request

src/core/extension/all.rs

@@ -102,7 +102,7 @@ pub fn configure_routes(router: Router) -> Router {
 
 // **< CONFIGURA EL MIDDLEWARE GLOBAL >*************************************************************
 
-/// Aplica las capas de *middleware* globales de todas las extensiones sobre el router ya enrutado.
+/// Aplica las capas de middleware globales de todas las extensiones sobre el router ya enrutado.
 ///
 /// Se llama después de [`configure_routes`] para garantizar que las capas envuelven todas las
 /// rutas de la aplicación, independientemente del orden de las extensiones.

src/core/extension/definition.rs

@@ -192,12 +192,12 @@ pub trait Extension: AnyInfo + Send + Sync {
     /// }
     /// ```
     ///
-    /// ## Rutas con *middleware* acotado a esta extensión
+    /// ## Rutas con middleware acotado a esta extensión
     ///
-    /// Cada `Router` mantiene su propia pila de *middleware* independiente. Cuando se crea un
+    /// Cada `Router` mantiene su propia pila de middleware independiente. Cuando se crea un
     /// `Router::new()` separado y se llama a `.layer()` sobre él, esa capa sólo se aplica a las
-    /// rutas de ese *router* concreto. Al fusionarlo con `.merge()` en el `router` principal, cada
+    /// rutas de ese router concreto. Al fusionarlo con `.merge()` en el `router` principal, cada
-    /// ruta se añade con su *middleware* asociado, sin tocar las demás.
+    /// ruta se añade con su middleware asociado, sin tocar las demás.
     ///
     /// Otra cosa es llamar a `.layer()` directamente sobre el `router` principal que se recibe como
     /// parámetro, porque ese objeto ya contiene todas las rutas acumuladas por extensiones
@@ -218,7 +218,7 @@ pub trait Extension: AnyInfo + Send + Sync {
     /// }
     /// ```
     ///
-    /// Para *middleware* que deba cubrir **todas** las rutas, usar
+    /// Para middleware que deba cubrir **todas** las rutas, usar
     /// [`configure_middleware`](Self::configure_middleware).
     ///
     /// ## Archivos estáticos
@@ -242,13 +242,13 @@ pub trait Extension: AnyInfo + Send + Sync {
         router
     }
 
-    /// Añade capas de *middleware* globales al *router* ya completamente preparado.
+    /// Añade capas de middleware globales al router ya completamente preparado.
     ///
     /// Se invoca **después** de que todas las extensiones hayan registrado sus rutas con
     /// [`configure_router`](Self::configure_router), de modo que las capas añadidas aquí se aplican
     /// a **todas** las rutas de la aplicación, independientemente del orden de las extensiones.
     ///
-    /// Usar este método cuando el *middleware* deba interceptar cualquier petición entrante (p. ej.
+    /// Usar este método cuando el middleware deba interceptar cualquier petición entrante (p. ej.
     /// resolución de sesión, autenticación, cabeceras de seguridad, ...).
     ///
     /// # Ejemplo

src/html/assets/javascript.rs

@@ -15,7 +15,7 @@ use crate::{AutoDefault, CowStr, Weight, util};
 ///   ejecuta en cuanto esté listo, **sin garantizar** el orden relativo respecto a otros scripts.
 /// - [`Inline`] - Inserta el código directamente en la etiqueta `<script>`.
 /// - [`OnLoad`] - Inserta el código JavaScript y lo ejecuta tras el evento `DOMContentLoaded`.
-/// - [`OnLoadAsync`] - Igual que [`OnLoad`], pero con *handler* asíncrono (`async`), útil si dentro
+/// - [`OnLoadAsync`] - Igual que [`OnLoad`], pero con handler asíncrono (`async`), útil si dentro
 ///   del código JavaScript se utiliza `await`.
 #[derive(AutoDefault)]
 enum Source {
@@ -27,7 +27,7 @@ enum Source {
     Inline(CowStr, Box<dyn Fn(&mut Context) -> String + Send + Sync>),
     /// `name`, `closure(&mut Context) -> String` (se ejecuta tras `DOMContentLoaded`).
     OnLoad(CowStr, Box<dyn Fn(&mut Context) -> String + Send + Sync>),
-    /// `name`, `closure(&mut Context) -> String` (*handler* `async` tras `DOMContentLoaded`).
+    /// `name`, `closure(&mut Context) -> String` (handler `async` tras `DOMContentLoaded`).
     OnLoadAsync(CowStr, Box<dyn Fn(&mut Context) -> String + Send + Sync>),
 }
 
@@ -58,7 +58,7 @@ enum Source {
 ///     }
 /// "#.to_string());
 ///
-/// // Script embebido con *handler* asíncrono (`async`) que puede usar `await`.
+/// // Script embebido con handler asíncrono (`async`) que puede usar `await`.
 /// let mut cx = Context::new(None).with_param("user_id", 7u32);
 ///
 /// let js = JavaScript::on_load_async("hydrate", |cx| {
@@ -150,7 +150,7 @@ impl JavaScript {
         }
     }
 
-    /// Crea un **script embebido** con un ***handler* asíncrono**.
+    /// Crea un **script embebido** con un **handler asíncrono**.
     ///
     /// El código se envuelve en un `addEventListener('DOMContentLoaded',async()=>{...})`, que
     /// emplea una función `async` para que el cuerpo devuelto por la función *closure* pueda usar

src/response/page.rs

@@ -98,8 +98,8 @@ impl Page {
     /// Crea una nueva instancia de página.
     ///
     /// La petición HTTP se guarda en el contexto de renderizado, que extrae automáticamente el
-    /// [`CurrentUser`] inyectado por *middleware* en sus extensiones (ver
+    /// [`CurrentUser`] inyectado por middleware en sus extensiones (ver
-    /// [`Context::new`](crate::core::component::Context::new)). Cualquier *handler* tiene acceso al
+    /// [`Context::new`](crate::core::component::Context::new)). Cualquier handler tiene acceso al
     /// usuario actual desde el momento en que se crea la página, sin llamadas adicionales.
     #[rustfmt::skip]
     pub fn new(request: HttpRequest) -> Self {

src/web.rs

@@ -39,9 +39,9 @@ use std::task::{Context, Poll};
 ///
 /// Almacena los datos necesarios para negociar el idioma y renderizar las páginas de error,
 /// incluyendo la URI completa, las cabeceras de la petición original y las extensiones de tipo que
-/// los *middlewares* pueden inyectar antes de que el *handler* se ejecute.
+/// los *middlewares* pueden inyectar antes de que el handler se ejecute.
 ///
-/// Puede declararse directamente como parámetro en un *handler* para pasarlo al
+/// Puede declararse directamente como parámetro en un handler para pasarlo al
 /// [`Context`](crate::core::component::Context) de renderizado y a las variantes de
 /// [`ErrorPage`](crate::response::page::ErrorPage):
 ///
@@ -53,8 +53,8 @@ use std::task::{Context, Poll};
 /// }
 /// ```
 ///
-/// Las extensiones inyectadas por *middleware* son accesibles vía [`extension`](Self::extension).
+/// Las extensiones inyectadas por middleware son accesibles vía [`extension`](Self::extension). Por
-/// Por ejemplo, desde un *handler*, tras añadir `MyData` en un *middleware*:
+/// ejemplo, desde un handler, tras añadir `MyData` en un middleware:
 ///
 /// ```rust,ignore
 /// if let Some(data) = request.extension::<MyData>() {
@@ -62,11 +62,11 @@ use std::task::{Context, Poll};
 /// }
 /// ```
 ///
-/// # Orden de parámetros en el *handler*
+/// # Orden de parámetros en el handler
 ///
 /// `HttpRequest` toma las extensiones de la petición al extraerse. Los extractores que leen de ahí
 /// (como `Path<T>` o `Extension<T>`) deben aparecer **antes** en la lista de parámetros del
-/// *handler*:
+/// handler:
 ///
 /// ```rust,no_run
 /// # use pagetop::prelude::*;
@@ -114,10 +114,10 @@ impl HttpRequest {
         &self.headers
     }
 
-    /// Accede a un valor inyectado por *middleware* en las extensiones de la petición.
+    /// Accede a un valor inyectado por middleware en las extensiones de la petición.
     ///
-    /// Devuelve una referencia al tipo `T` si algún *middleware* lo insertó antes de que el
+    /// Devuelve una referencia al tipo `T` si algún middleware lo insertó antes de que el handler
-    /// *handler* recibiera la petición, o `None` en caso contrario.
+    /// recibiera la petición, o `None` en caso contrario.
     ///
     /// El tipo debe implementar `Send + Sync + 'static` (requisito de [`http::Extensions`]).
     pub fn extension<T: Send + Sync + 'static>(&self) -> Option<&T> {
@@ -128,11 +128,11 @@ impl HttpRequest {
 impl<S: Send + Sync> FromRequestParts<S> for HttpRequest {
     type Rejection = Infallible;
 
-    // Extrae la petición y toma las extensiones que han sido inyectadas por *middleware*. Las
+    // Extrae la petición y toma las extensiones que han sido inyectadas por middleware. Las
     // extensiones se mueven a un `Arc` compartido para que `HttpRequest` sea `Clone`.
     //
     // Nota: tras este extractor `parts.extensions` queda vacío; otros extractores que dependan de
-    //       `Extension<T>` deben registrarse antes en la cadena del *handler*.
+    //       `Extension<T>` deben registrarse antes en la cadena del handler.
     async fn from_request_parts(
         parts: &mut http::request::Parts,
         _state: &S,
@@ -388,7 +388,7 @@ pub mod test {
 
         /// Inserta un valor en las extensiones de la petición.
         ///
-        /// Útil para simular lo que un *middleware* haría en producción antes de que el *handler*
+        /// Útil para simular lo que un middleware haría en producción antes de que el handler
         /// reciba la petición. El tipo debe implementar `Clone + Send + Sync + 'static`.
         pub fn with_extension<T: Clone + Send + Sync + 'static>(mut self, value: T) -> Self {
             self.extensions.insert(value);