fmt

leptos_dom/src/lib.rs

@@ -2,6 +2,8 @@
 #![forbid(unsafe_code)]
 #![cfg_attr(feature = "nightly", feature(fn_traits))]
 #![cfg_attr(feature = "nightly", feature(unboxed_closures))]
+// to prevent warnings from popping up when a nightly feature is stabilized
+#![allow(stable_features)]
 
 //! The DOM implementation for `leptos`.
 

leptos_macro/src/lib.rs

@@ -1,5 +1,7 @@
 #![cfg_attr(feature = "nightly", feature(proc_macro_span))]
 #![forbid(unsafe_code)]
+// to prevent warnings from popping up when a nightly feature is stabilized
+#![allow(stable_features)]
 
 #[macro_use]
 extern crate proc_macro_error;

leptos_macro/src/server.rs

@@ -34,8 +34,8 @@ pub fn server_impl(args: TokenStream, s: TokenStream) -> TokenStream {
     };
     args.docs = attrs
         .iter()
-        .cloned()
         .filter(|attr| attr.meta.path().is_ident("doc"))
+        .cloned()
         .collect();
     // default to PascalCase version of function name if no struct name given
     if args.struct_name.is_none() {

leptos_reactive/src/lib.rs

@@ -5,7 +5,7 @@
 #![cfg_attr(feature = "nightly", feature(type_name_of_val))]
 #![cfg_attr(feature = "nightly", feature(auto_traits))]
 #![cfg_attr(feature = "nightly", feature(negative_impls))]
-// to prevent warnings on new from popping up when one of those features is stabilized
+// to prevent warnings from popping up when a nightly feature is stabilized
 #![allow(stable_features)]
 
 //! The reactive system for the [Leptos](https://docs.rs/leptos/latest/leptos/) Web framework.

router/src/lib.rs

@@ -187,6 +187,8 @@
 #![cfg_attr(feature = "nightly", feature(auto_traits))]
 #![cfg_attr(feature = "nightly", feature(negative_impls))]
 #![cfg_attr(feature = "nightly", feature(type_name_of_val))]
+// to prevent warnings from popping up when a nightly feature is stabilized
+#![allow(stable_features)]
 
 mod animation;
 mod components;

server_fn/server_fn_macro_default/src/lib.rs

@@ -1,67 +1,69 @@
-#![cfg_attr(feature = "nightly", feature(proc_macro_span))]
-//! This crate contains the default implementation of the #[macro@crate::server] macro without a context from the server. See the [server_fn_macro] crate for more information.
-#![forbid(unsafe_code)]
-
-use proc_macro::TokenStream;
-use server_fn_macro::server_macro_impl;
-use syn::__private::ToTokens;
-
-/// Declares that a function is a [server function](https://docs.rs/server_fn/).
-/// This means that its body will only run on the server, i.e., when the `ssr`
-/// feature is enabled.
-///
-/// You can specify one, two, three, or four arguments to the server function:
-/// 1. **Required**: A type name that will be used to identify and register the server function
-///   (e.g., `MyServerFn`).
-/// 2. *Optional*: A URL prefix at which the function will be mounted when it’s registered
-///   (e.g., `"/api"`). Defaults to `"/"`.
-/// 3. *Optional*: The encoding for the server function (`"Url"`, `"Cbor"`, `"GetJson"`, or `"GetCbor`". See **Server Function Encodings** below.)
-/// 4. *Optional*: A specific endpoint path to be used in the URL. (By default, a unique path will be generated.)
-///
-/// ```rust,ignore
-/// // will generate a server function at `/api-prefix/hello`
-/// #[server(MyServerFnType, "/api-prefix", "Url", "hello")]
-/// ```
-///
-/// The server function itself can take any number of arguments, each of which should be serializable
-/// and deserializable with `serde`.
-///
-/// ```ignore
-/// # use server_fn::*; use serde::{Serialize, Deserialize};
-/// # #[derive(Serialize, Deserialize)]
-/// # pub struct Post { }
-/// #[server(ReadPosts, "/api")]
-/// pub async fn read_posts(how_many: u8, query: String) -> Result<Vec<Post>, ServerFnError> {
-///   // do some work on the server to access the database
-///   todo!()
-/// }
-/// ```
-///
-/// Note the following:
-/// - **Server functions must be `async`.** Even if the work being done inside the function body
-///   can run synchronously on the server, from the client’s perspective it involves an asynchronous
-///   function call.
-/// - **Server functions must return `Result<T, ServerFnError>`.** Even if the work being done
-///   inside the function body can’t fail, the processes of serialization/deserialization and the
-///   network call are fallible.
-/// - **Return types must implement [Serialize](https://docs.rs/serde/latest/serde/trait.Serialize.html).**
-///   This should be fairly obvious: we have to serialize arguments to send them to the server, and we
-///   need to deserialize the result to return it to the client.
-/// - **Arguments must be implement [`Serialize`](https://docs.rs/serde/latest/serde/trait.Serialize.html)
-///   and [`DeserializeOwned`](https://docs.rs/serde/latest/serde/de/trait.DeserializeOwned.html).**
-///   They are serialized as an `application/x-www-form-urlencoded`
-///   form data using [`serde_qs`](https://docs.rs/serde_qs/latest/serde_qs/) or as `application/cbor`
-///   using [`cbor`](https://docs.rs/cbor/latest/cbor/).
-#[proc_macro_attribute]
-pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
-    match server_macro_impl(
-        args.into(),
-        s.into(),
-        syn::parse_quote!(server_fn::default::DefaultServerFnTraitObj),
-        None,
-        Some(syn::parse_quote!(server_fn)),
-    ) {
-        Err(e) => e.to_compile_error().into(),
-        Ok(s) => s.to_token_stream().into(),
-    }
-}
+#![cfg_attr(feature = "nightly", feature(proc_macro_span))]
+//! This crate contains the default implementation of the #[macro@crate::server] macro without a context from the server. See the [server_fn_macro] crate for more information.
+#![forbid(unsafe_code)]
+// to prevent warnings from popping up when a nightly feature is stabilized
+#![allow(stable_features)]
+
+use proc_macro::TokenStream;
+use server_fn_macro::server_macro_impl;
+use syn::__private::ToTokens;
+
+/// Declares that a function is a [server function](https://docs.rs/server_fn/).
+/// This means that its body will only run on the server, i.e., when the `ssr`
+/// feature is enabled.
+///
+/// You can specify one, two, three, or four arguments to the server function:
+/// 1. **Required**: A type name that will be used to identify and register the server function
+///   (e.g., `MyServerFn`).
+/// 2. *Optional*: A URL prefix at which the function will be mounted when it’s registered
+///   (e.g., `"/api"`). Defaults to `"/"`.
+/// 3. *Optional*: The encoding for the server function (`"Url"`, `"Cbor"`, `"GetJson"`, or `"GetCbor`". See **Server Function Encodings** below.)
+/// 4. *Optional*: A specific endpoint path to be used in the URL. (By default, a unique path will be generated.)
+///
+/// ```rust,ignore
+/// // will generate a server function at `/api-prefix/hello`
+/// #[server(MyServerFnType, "/api-prefix", "Url", "hello")]
+/// ```
+///
+/// The server function itself can take any number of arguments, each of which should be serializable
+/// and deserializable with `serde`.
+///
+/// ```ignore
+/// # use server_fn::*; use serde::{Serialize, Deserialize};
+/// # #[derive(Serialize, Deserialize)]
+/// # pub struct Post { }
+/// #[server(ReadPosts, "/api")]
+/// pub async fn read_posts(how_many: u8, query: String) -> Result<Vec<Post>, ServerFnError> {
+///   // do some work on the server to access the database
+///   todo!()
+/// }
+/// ```
+///
+/// Note the following:
+/// - **Server functions must be `async`.** Even if the work being done inside the function body
+///   can run synchronously on the server, from the client’s perspective it involves an asynchronous
+///   function call.
+/// - **Server functions must return `Result<T, ServerFnError>`.** Even if the work being done
+///   inside the function body can’t fail, the processes of serialization/deserialization and the
+///   network call are fallible.
+/// - **Return types must implement [Serialize](https://docs.rs/serde/latest/serde/trait.Serialize.html).**
+///   This should be fairly obvious: we have to serialize arguments to send them to the server, and we
+///   need to deserialize the result to return it to the client.
+/// - **Arguments must be implement [`Serialize`](https://docs.rs/serde/latest/serde/trait.Serialize.html)
+///   and [`DeserializeOwned`](https://docs.rs/serde/latest/serde/de/trait.DeserializeOwned.html).**
+///   They are serialized as an `application/x-www-form-urlencoded`
+///   form data using [`serde_qs`](https://docs.rs/serde_qs/latest/serde_qs/) or as `application/cbor`
+///   using [`cbor`](https://docs.rs/cbor/latest/cbor/).
+#[proc_macro_attribute]
+pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
+    match server_macro_impl(
+        args.into(),
+        s.into(),
+        syn::parse_quote!(server_fn::default::DefaultServerFnTraitObj),
+        None,
+        Some(syn::parse_quote!(server_fn)),
+    ) {
+        Err(e) => e.to_compile_error().into(),
+        Ok(s) => s.to_token_stream().into(),
+    }
+}

server_fn_macro/src/lib.rs

@@ -1,6 +1,8 @@
 #![cfg_attr(feature = "nightly", feature(proc_macro_span))]
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
+// to prevent warnings from popping up when a nightly feature is stabilized
+#![allow(stable_features)]
 
 //! Implementation of the `server_fn` macro.
 //!