improved documentation and refactored naming to be more self-explanatory

examples/all_events.rs

@@ -43,7 +43,8 @@ const RECT_STYLE: &str = r#"
 fn app(cx: Scope) -> Element {
     let events = use_ref(cx, std::collections::VecDeque::new);
 
-    let log_event = move |event: Event| {
+    let log_event =
+        move |event: Event| {
             let mut events = events.write();
 
             if events.len() >= MAX_EVENTS {

examples/callback.rs

@@ -5,7 +5,8 @@ fn main() {
 }
 
 fn app(cx: Scope) -> Element {
-    let login = use_callback!(cx, move |_| async move {
+    let login =
+        use_callback!(cx, move |_| async move {
             let res = reqwest::get("https://dog.ceo/api/breeds/list/all")
                 .await
                 .unwrap()

examples/compose.rs

@@ -12,7 +12,8 @@ fn app(cx: Scope) -> Element {
     let window = use_window(cx);
     let emails_sent = use_ref(cx, Vec::new);
 
-    let tx = use_coroutine(cx, |mut rx: UnboundedReceiver<String>| {
+    let tx =
+        use_coroutine(cx, |mut rx: UnboundedReceiver<String>| {
             to_owned![emails_sent];
             async move {
                 while let Some(message) = rx.next().await {

examples/error_handle.rs

@@ -8,7 +8,8 @@ fn main() {
 fn App(cx: Scope) -> Element {
     let val = use_state(cx, || "0.0001");
 
-    let num = match val.parse::<f32>() {
+    let num =
+        match val.parse::<f32>() {
             Err(_) => return cx.render(rsx!("Parsing failed")),
             Ok(num) => num,
         };

examples/eval.rs

@@ -7,7 +7,8 @@ fn main() {
 fn app(cx: Scope) -> Element {
     let eval_provider = use_eval(cx);
 
-    let future = use_future(cx, (), |_| {
+    let future =
+        use_future(cx, (), |_| {
             to_owned![eval_provider];
             async move {
                 let eval = eval_provider(

examples/file_explorer.rs

@@ -73,7 +73,8 @@ struct Files {
 
 impl Files {
     fn new() -> Self {
-        let mut files = Self {
+        let mut files =
+            Self {
                 path_stack: vec!["./".to_string()],
                 path_names: vec![],
                 err: None,

examples/framework_benchmark.rs

@@ -112,7 +112,8 @@ fn ActionButton<'a>(cx: Scope<'a, ActionButtonProps<'a>>) -> Element {
     })
 }
 
-static ADJECTIVES: &[&str] = &[
+static ADJECTIVES: &[&str] =
+    &[
         "pretty",
         "large",
         "big",

examples/login_form.rs

@@ -8,9 +8,11 @@ fn main() {
 }
 
 fn app(cx: Scope) -> Element {
-    let onsubmit = move |evt: FormEvent| {
+    let onsubmit =
+        move |evt: FormEvent| {
             cx.spawn(async move {
-            let resp = reqwest::Client::new()
+                let resp =
+                    reqwest::Client::new()
                         .post("http://localhost:8080/login")
                         .form(&[
                             ("username", &evt.values["username"]),
@@ -25,7 +27,9 @@ fn app(cx: Scope) -> Element {
 
                     //Handle any errors from the fetch here
                     Err(_err) => {
-                    println!("Login failed - you need a login server running on localhost:8080.")
+                        println!(
+                            "Login failed - you need a login server running on localhost:8080."
+                        )
                     }
                 }
             });

examples/openid_connect_demo/src/oidc.rs

@@ -112,7 +112,8 @@ pub async fn exchange_refresh_token(
 
 pub async fn log_out_url(id_token_hint: CoreIdToken) -> Result<Url, crate::errors::Error> {
     let provider_metadata = init_provider_metadata().await?;
-    let end_session_url = provider_metadata
+    let end_session_url =
+        provider_metadata
             .additional_metadata()
             .clone()
             .end_session_endpoint

examples/openid_connect_demo/src/views/header.rs

@@ -22,7 +22,8 @@ pub fn LogOut(cx: Scope<ClientProps>) -> Element {
         Some(fermi_auth_token_read) => match fermi_auth_token_read.id_token.clone() {
             Some(id_token) => match log_out_url_state.get() {
                 Some(log_out_url_result) => match log_out_url_result {
-                    Some(uri) => match uri {
+                    Some(uri) => {
+                        match uri {
                             Ok(uri) => {
                                 rsx! {
                                     Link {
@@ -44,7 +45,8 @@ pub fn LogOut(cx: Scope<ClientProps>) -> Element {
                                     div { format!{"Failed to load disconnection url: {:?}", error} }
                                 }
                             }
-                    },
+                        }
+                    }
                     None => {
                         rsx! { div { "Loading... Please wait" } }
                     }

examples/rsx_compile_fail.rs

@@ -13,14 +13,16 @@ fn main() {
 }
 
 fn example(cx: Scope) -> Element {
-    let items = use_state(cx, || {
+    let items =
+        use_state(cx, || {
             vec![Thing {
                 a: "asd".to_string(),
                 b: 10,
             }]
         });
 
-    let things = use_ref(cx, || {
+    let things =
+        use_ref(cx, || {
             vec![Thing {
                 a: "asd".to_string(),
                 b: 10,

examples/svg.rs

@@ -63,8 +63,8 @@ pub fn Die<'a>(cx: Scope<'a, DieProps<'a>>) -> Element {
 
     let active_dots = &DOTS_FOR_VALUE[(value - 1) as usize];
     let fill = if keep { HELD_COLOR } else { UNHELD_COLOR };
-    let dots = DOTS
+    let dots =
-        .iter()
+        DOTS.iter()
             .zip(active_dots.iter())
             .filter(|(_, &active)| active)
             .map(|((x, y), _)| {

examples/todomvc.rs

@@ -202,7 +202,8 @@ pub fn ListFooter<'a>(cx: Scope<'a, ListFooterProps<'a>>) -> Element {
     let active_todo_count = cx.props.active_todo_count;
     let active_todo_text = cx.props.active_todo_text;
 
-    let selected = |state| {
+    let selected =
+        |state| {
             if *cx.props.filter == state {
                 "selected"
             } else {

packages/autofmt/src/expr.rs

@@ -34,7 +34,8 @@ impl Writer<'_> {
         for (id, line) in self.src[start.line..end.line].iter().enumerate() {
             writeln!(self.out)?;
             // check if this is the last line
-            let line = {
+            let line =
+                {
                     if id == (end.line - start.line) - 1 {
                         &line[..end.column]
                     } else {

packages/cli/src/builder.rs

@@ -67,14 +67,16 @@ pub fn build(config: &CrateConfig, quiet: bool) -> Result<BuildResult> {
         cmd.arg("--quiet")
     };
 
-    let cmd = if config.custom_profile.is_some() {
+    let cmd =
+        if config.custom_profile.is_some() {
             let custom_profile = config.custom_profile.as_ref().unwrap();
             cmd.arg("--profile").arg(custom_profile)
         } else {
             cmd
         };
 
-    let cmd = if config.features.is_some() {
+    let cmd =
+        if config.features.is_some() {
             let features_str = config.features.as_ref().unwrap().join(" ");
             cmd.arg("--features").arg(features_str)
         } else {
@@ -92,7 +94,8 @@ pub fn build(config: &CrateConfig, quiet: bool) -> Result<BuildResult> {
     // [2] Establish the output directory structure
     let bindgen_outdir = out_dir.join("assets").join("dioxus");
 
-    let build_profile = if config.custom_profile.is_some() {
+    let build_profile =
+        if config.custom_profile.is_some() {
             config.custom_profile.as_ref().unwrap()
         } else if config.release {
             "release"
@@ -207,7 +210,8 @@ pub fn build(config: &CrateConfig, quiet: bool) -> Result<BuildResult> {
     }
 
     // this code will copy all public file to the output dir
-    let copy_options = fs_extra::dir::CopyOptions {
+    let copy_options =
+        fs_extra::dir::CopyOptions {
             overwrite: true,
             skip_exist: false,
             buffer_size: 64000,
@@ -287,7 +291,8 @@ pub fn build_desktop(config: &CrateConfig, _is_serve: bool) -> Result<BuildResul
     };
 
     let file_name: String;
-    let mut res_path = match &config.executable {
+    let mut res_path =
+        match &config.executable {
             crate::ExecutableType::Binary(name) | crate::ExecutableType::Lib(name) => {
                 file_name = name.clone();
                 config.target_dir.join(release_type).join(name)
@@ -396,9 +401,7 @@ fn prettier_build(cmd: subprocess::Exec) -> anyhow::Result<Vec<Diagnostic>> {
                 match message.level {
                     cargo_metadata::diagnostic::DiagnosticLevel::Error => {
                         return {
-                            Err(anyhow::anyhow!(message
+                            Err(anyhow::anyhow!(message.rendered.unwrap_or("Unknown".into())))
-                                .rendered
-                                .unwrap_or("Unknown".into())))
                         };
                     }
                     cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
@@ -475,10 +478,7 @@ pub fn gen_page(config: &DioxusConfig, serve: bool) -> String {
 
     let mut script_str = String::new();
     for script in script_list {
-        script_str.push_str(&format!(
+        script_str.push_str(&format!("<script src=\"{}\"></script>\n", &script.to_str().unwrap(),))
-            "<script src=\"{}\"></script>\n",
-            &script.to_str().unwrap(),
-        ))
     }
 
     replace_or_insert_before("{script_include}", &script_str, "</body", &mut html);
@@ -502,7 +502,8 @@ pub fn gen_page(config: &DioxusConfig, serve: bool) -> String {
         html = html.replace("{base_path}", base_path);
     } else {
         // If not, insert the script
-        html = html.replace(
+        html =
+            html.replace(
                 "</body",
                 &format!(
                     r#"<script type="module">

packages/cli/src/cargo.rs

@@ -34,9 +34,9 @@ pub fn crate_root() -> Result<PathBuf> {
             }
             None
         })
-        .ok_or_else(|| {
+        .ok_or_else(
-            Error::CargoError("Failed to find directory containing Cargo.toml".to_string())
+            || Error::CargoError("Failed to find directory containing Cargo.toml".to_string())
-        })
+        )
 }
 
 /// Checks if the directory contains `Cargo.toml`

packages/cli/src/cli/autoformat.rs

@@ -93,7 +93,8 @@ async fn autoformat_project(check: bool) -> Result<()> {
     let mut files_to_format = vec![];
     collect_rs_files(&crate_config.crate_dir, &mut files_to_format);
 
-    let counts = files_to_format
+    let counts =
+        files_to_format
             .into_iter()
             .filter(|file| {
                 if file.components().any(|f| f.as_os_str() == "target") {

packages/cli/src/cli/create.rs

@@ -35,7 +35,8 @@ impl Create {
         let toml_paths = [path.join("Cargo.toml"), path.join("Dioxus.toml")];
         for toml_path in &toml_paths {
             let toml = std::fs::read_to_string(toml_path)?;
-            let mut toml = toml.parse::<toml_edit::Document>().map_err(|e| {
+            let mut toml =
+                toml.parse::<toml_edit::Document>().map_err(|e| {
                     anyhow::anyhow!(
                         "failed to parse toml at {}: {}",
                         toml_path.display(),

packages/cli/src/plugin/interface/fs.rs

@@ -67,7 +67,8 @@ impl UserData for PluginFileSystem {
             let file = PathBuf::from(args.0);
             let target = PathBuf::from(args.1);
 
-            let tar_gz = if let Ok(v) = File::open(file) {
+            let tar_gz =
+                if let Ok(v) = File::open(file) {
                     v
                 } else {
                     return Ok(false);

packages/cli/src/plugin/mod.rs

@@ -317,7 +317,8 @@ impl PluginManager {
                 let name = i.get::<_, String>("name").unwrap();
                 let loader = i.get::<_, bool>("loader").unwrap();
 
-                let text = if loader {
+                let text =
+                    if loader {
                         format!("{name} [:loader]")
                     } else {
                         name

packages/cli/src/server/output.rs

@@ -22,7 +22,8 @@ pub fn print_console_info(
     options: PrettierOptions,
     web_info: Option<WebServerInfo>,
 ) {
-    if let Ok(native_clearseq) = Command::new(if cfg!(target_os = "windows") {
+    if let Ok(native_clearseq) =
+        Command::new(if cfg!(target_os = "windows") {
             "cls"
         } else {
             "clear"
@@ -46,7 +47,8 @@ pub fn print_console_info(
     } else {
         "Default"
     };
-    let url_rewrite = if config
+    let url_rewrite =
+        if config
             .dioxus_config
             .web
             .watcher

packages/cli/src/server/web/mod.rs

@@ -165,9 +165,7 @@ async fn get_rustls(config: &CrateConfig) -> Result<Option<RustlsConfig>> {
         get_rustls_without_mkcert(web_config)?
     };
 
-    Ok(Some(
+    Ok(Some(RustlsConfig::from_pem_file(cert_path, key_path).await?))
-        RustlsConfig::from_pem_file(cert_path, key_path).await?,
-    ))
 }
 
 fn get_rustls_with_mkcert(web_config: &WebHttpsConfig) -> Result<(String, String)> {
@@ -314,7 +312,8 @@ async fn setup_router(
     ));
 
     // Setup routes
-    router = router
+    router =
+        router
             .route("/_dioxus/hot_reload", get(hot_reload_handler))
             .layer(cors)
             .layer(Extension(ws_reload));

packages/cli/src/tools.rs

@@ -162,7 +162,8 @@ impl Tool {
                 )
             }
             Self::Tailwind => {
-                let windows_extension = match self.target_platform() {
+                let windows_extension =
+                    match self.target_platform() {
                         "windows" => ".exe",
                         _ => "",
                     };
@@ -280,7 +281,8 @@ impl Tool {
     pub fn call(&self, command: &str, args: Vec<&str>) -> anyhow::Result<Vec<u8>> {
         let bin_path = tools_path().join(self.name()).join(self.bin_path());
 
-        let command_file = match self {
+        let command_file =
+            match self {
                 Tool::Binaryen => {
                     if cfg!(target_os = "windows") {
                         format!("{}.exe", command)

packages/core-macro/src/component_body_deserializers/inline_props.rs

@@ -67,7 +67,8 @@ fn get_props_struct(component_body: &ComponentBody) -> ItemStruct {
 
     let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
 
-    let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
+    let first_lifetime =
+        if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
             Some(lt)
         } else {
             None
@@ -250,12 +251,14 @@ fn get_function(component_body: &ComponentBody) -> ItemFn {
     let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
 
     // Skip first arg since that's the context
-    let struct_field_names = inputs.iter().skip(1).filter_map(|f| match f {
+    let struct_field_names =
+        inputs.iter().skip(1).filter_map(|f| match f {
             FnArg::Receiver(_) => unreachable!(), // ComponentBody prohibits receiver parameters.
             FnArg::Typed(pt) => Some(&pt.pat),
         });
 
-    let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
+    let first_lifetime =
+        if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
             Some(lt)
         } else {
             None

packages/core-macro/src/props/mod.rs

@@ -41,16 +41,10 @@ pub fn impl_my_derive(ast: &syn::DeriveInput) -> Result<TokenStream, Error> {
                 }
             }
             syn::Fields::Unnamed(_) => {
-                return Err(Error::new(
+                return Err(Error::new(ast.span(), "Props is not supported for tuple structs"))
-                    ast.span(),
-                    "Props is not supported for tuple structs",
-                ))
             }
             syn::Fields::Unit => {
-                return Err(Error::new(
+                return Err(Error::new(ast.span(), "Props is not supported for unit structs"))
-                    ast.span(),
-                    "Props is not supported for unit structs",
-                ))
             }
         },
         syn::Data::Enum(_) => {
@@ -334,10 +328,9 @@ mod field_info {
                             }
                             Ok(())
                         }
-                        _ => Err(Error::new_spanned(
+                        _ => {
-                            &assign,
+                            Err(Error::new_spanned(&assign, format!("Unknown parameter {name:?}")))
-                            format!("Unknown parameter {name:?}"),
+                        }
-                        )),
                     }
                 }
 
@@ -452,8 +445,9 @@ fn type_from_inside_option(ty: &syn::Type, check_option_name: bool) -> Option<&s
     if check_option_name && segment.ident != "Option" {
         return None;
     }
-    let generic_params =
+    let generic_params = if let syn::PathArguments::AngleBracketed(generic_params) =
-        if let syn::PathArguments::AngleBracketed(generic_params) = &segment.arguments {
+        &segment.arguments
+    {
         generic_params
     } else {
         return None;
@@ -562,7 +556,8 @@ mod struct_info {
                 }
                 syn::GenericParam::Const(_cnst) => None,
             });
-            let builder_method_doc = match self.builder_attr.builder_method_doc {
+            let builder_method_doc =
+                match self.builder_attr.builder_method_doc {
                     Some(ref doc) => quote!(#doc),
                     None => {
                         let doc = format!(
@@ -623,7 +618,8 @@ Finally, call `.build()` to create the instance of `{name}`.
                 false => quote! { self == other },
             };
 
-            let is_static = match are_there_generics {
+            let is_static =
+                match are_there_generics {
                     true => quote! { false  },
                     false => quote! { true },
                 };
@@ -711,7 +707,8 @@ Finally, call `.build()` to create the instance of `{name}`.
                 ref builder_name, ..
             } = *self;
 
-            let descructuring = self.included_fields().map(|f| {
+            let descructuring =
+                self.included_fields().map(|f| {
                     if f.ordinal == field.ordinal {
                         quote!(_)
                     } else {
@@ -785,7 +782,8 @@ Finally, call `.build()` to create the instance of `{name}`.
 
             // NOTE: both auto_into and strip_option affect `arg_type` and `arg_expr`, but the order of
             // nesting is different so we have to do this little dance.
-            let arg_type = if field.builder_attr.strip_option {
+            let arg_type =
+                if field.builder_attr.strip_option {
                     field.type_from_inside_option(false).ok_or_else(|| {
                         Error::new_spanned(
                             field_type,
@@ -880,7 +878,8 @@ Finally, call `.build()` to create the instance of `{name}`.
                 })
                 .collect();
             let mut builder_generics_tuple = empty_type_tuple();
-            let generics = self.modify_generics(|g| {
+            let generics =
+                self.modify_generics(|g| {
                     let index_after_lifetime_in_generics = g
                         .params
                         .iter()
@@ -1139,10 +1138,9 @@ Finally, call `.build()` to create the instance of `{name}`.
                             self.doc = true;
                             Ok(())
                         }
-                        _ => Err(Error::new_spanned(
+                        _ => {
-                            &assign,
+                            Err(Error::new_spanned(&assign, format!("Unknown parameter {name:?}")))
-                            format!("Unknown parameter {name:?}"),
+                        }
-                        )),
                     }
                 }
                 syn::Expr::Path(path) => {
@@ -1153,10 +1151,9 @@ Finally, call `.build()` to create the instance of `{name}`.
                             self.doc = true;
                             Ok(())
                         }
-                        _ => Err(Error::new_spanned(
+                        _ => {
-                            &path,
+                            Err(Error::new_spanned(&path, format!("Unknown parameter {name:?}")))
-                            format!("Unknown parameter {name:?}"),
+                        }
-                        )),
                     }
                 }
                 syn::Expr::Call(call) => {

packages/core-macro/src/utils.rs

@@ -31,9 +31,9 @@ pub fn format_type_string(ty: &Type) -> String {
 
     // This should always be valid syntax.
     // Not Rust code, but syntax, which is the only thing that `syn` cares about.
-    let Ok(file_unformatted) = syn::parse_file(&format!(
+    let Ok(file_unformatted) =
-        "{FORMATTED_TYPE_START}{ty_unformatted}{FORMATTED_TYPE_END}"
+        syn::parse_file(&format!("{FORMATTED_TYPE_START}{ty_unformatted}{FORMATTED_TYPE_END}"))
-    )) else {
+    else {
         return ty_unformatted.to_string();
     };
 
@@ -60,10 +60,7 @@ impl DeprecatedAttribute {
     /// Returns `None` if the given attribute was not a valid form of the `#[deprecated]` attribute.
     pub fn from_meta(meta: &Meta) -> syn::Result<Self> {
         if meta.path() != &parse_quote!(deprecated) {
-            return Err(syn::Error::new(
+            return Err(syn::Error::new(meta.span(), "attribute path is not `deprecated`"));
-                meta.span(),
-                "attribute path is not `deprecated`",
-            ));
         }
 
         match &meta {

packages/core/src/create.rs

@@ -36,7 +36,8 @@ fn sort_bfs(paths: &[&'static [u8]]) -> Vec<(usize, &'static [u8])> {
 #[test]
 #[cfg(debug_assertions)]
 fn sorting() {
-    let r: [(usize, &[u8]); 5] = [
+    let r: [(usize, &[u8]); 5] =
+        [
             (0, &[0, 1]),
             (1, &[0, 2]),
             (2, &[1, 0]),

packages/core/src/nodes.rs

@@ -531,9 +531,9 @@ impl<'a> From<&'a AttributeValue<'a>> for BorrowedAttributeValue<'a> {
             }
             AttributeValue::Any(value) => {
                 let value = value.borrow();
-                BorrowedAttributeValue::Any(std::cell::Ref::map(value, |value| {
+                BorrowedAttributeValue::Any(
-                    &**value.as_ref().unwrap()
+                    std::cell::Ref::map(value, |value| &**value.as_ref().unwrap())
-                }))
+                )
             }
             AttributeValue::None => BorrowedAttributeValue::None,
         }

packages/core/src/virtual_dom.rs

@@ -267,7 +267,8 @@ impl VirtualDom {
             suspended_scopes: Default::default(),
         };
 
-        let root = dom.new_scope(
+        let root =
+            dom.new_scope(
                 Box::new(VProps::new(root, |_, _| unreachable!(), root_props)),
                 "app",
             );

packages/core/tests/attr_cleanup.rs

@@ -9,12 +9,15 @@ use dioxus_core::BorrowedAttributeValue;
 
 #[test]
 fn attrs_cycle() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             let id = cx.generation();
             match cx.generation() % 2 {
-            0 => cx.render(rsx! {
+                0 => {
+                    cx.render(rsx! {
                         div {}
-            }),
+                    })
+                }
                 1 => cx.render(rsx! {
                     div {
                         h1 { class: "{id}", id: "{id}" }

packages/core/tests/bubble_error.rs

@@ -3,7 +3,8 @@
 use dioxus::prelude::*;
 
 fn app(cx: Scope) -> Element {
-    let raw = match cx.generation() % 2 {
+    let raw =
+        match cx.generation() % 2 {
             0 => "123.123",
             1 => "123.123.123",
             _ => unreachable!(),

packages/core/tests/create_dom.rs

@@ -11,7 +11,8 @@ use dioxus_core::ElementId;
 
 #[test]
 fn test_original_diff() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             cx.render(rsx! {
                 div {
                     div {
@@ -82,7 +83,8 @@ fn create() {
 
 #[test]
 fn create_list() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             cx.render(rsx! {
                 (0..3).map(|f| rsx!( div { "hello" } ))
             })
@@ -160,7 +162,8 @@ fn create_components() {
 
 #[test]
 fn anchors() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             cx.render(rsx! {
                 if true {
                     rsx!( div { "hello" } )

packages/core/tests/create_fragments.rs

@@ -24,7 +24,8 @@ fn empty_fragment_creates_nothing() {
 
 #[test]
 fn root_fragments_work() {
-    let mut vdom = VirtualDom::new(|cx| {
+    let mut vdom =
+        VirtualDom::new(|cx| {
             cx.render(rsx!(
                 div { "hello" }
                 div { "goodbye" }

packages/core/tests/diff_unkeyed_list.rs

@@ -4,7 +4,8 @@ use pretty_assertions::assert_eq;
 
 #[test]
 fn list_creates_one_by_one() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             let gen = cx.generation();
 
             cx.render(rsx! {
@@ -73,7 +74,8 @@ fn list_creates_one_by_one() {
 
 #[test]
 fn removes_one_by_one() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             let gen = 3 - cx.generation() % 4;
 
             cx.render(rsx! {
@@ -150,7 +152,8 @@ fn removes_one_by_one() {
 
 #[test]
 fn list_shrink_multiroot() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             cx.render(rsx! {
                 div {
                     (0..cx.generation()).map(|i| rsx! {

packages/core/tests/fuzzing.rs

@@ -8,9 +8,7 @@ fn random_ns() -> Option<&'static str> {
     let namespace = rand::random::<u8>() % 2;
     match namespace {
         0 => None,
-        1 => Some(Box::leak(
+        1 => Some(Box::leak(format!("ns{}", rand::random::<usize>()).into_boxed_str())),
-            format!("ns{}", rand::random::<usize>()).into_boxed_str(),
-        )),
         _ => unreachable!(),
     }
 }
@@ -22,13 +20,15 @@ fn create_random_attribute(attr_idx: &mut usize) -> TemplateAttribute<'static> {
             value: Box::leak(format!("value{}", rand::random::<usize>()).into_boxed_str()),
             namespace: random_ns(),
         },
-        1 => TemplateAttribute::Dynamic {
+        1 => {
+            TemplateAttribute::Dynamic {
                 id: {
                     let old_idx = *attr_idx;
                     *attr_idx += 1;
                     old_idx
                 },
-        },
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -73,22 +73,26 @@ fn create_random_template_node(
         1 => TemplateNode::Text {
             text: Box::leak(format!("{}", rand::random::<usize>()).into_boxed_str()),
         },
-        2 => TemplateNode::DynamicText {
+        2 => {
+            TemplateNode::DynamicText {
                 id: {
                     let old_idx = *template_idx;
                     *template_idx += 1;
                     dynamic_node_types.push(DynamicNodeType::Text);
                     old_idx
                 },
-        },
+            }
-        3 => TemplateNode::Dynamic {
+        }
+        3 => {
+            TemplateNode::Dynamic {
                 id: {
                     let old_idx = *template_idx;
                     *template_idx += 1;
                     dynamic_node_types.push(DynamicNodeType::Other);
                     old_idx
                 },
-        },
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -207,9 +211,9 @@ fn create_random_dynamic_node(cx: &ScopeState, depth: usize) -> DynamicNode {
 
 fn create_random_dynamic_attr(cx: &ScopeState) -> Attribute {
     let value = match rand::random::<u8>() % 7 {
-        0 => AttributeValue::Text(Box::leak(
+        0 => {
-            format!("{}", rand::random::<usize>()).into_boxed_str(),
+            AttributeValue::Text(Box::leak(format!("{}", rand::random::<usize>()).into_boxed_str()))
-        )),
+        }
         1 => AttributeValue::Float(rand::random()),
         2 => AttributeValue::Int(rand::random()),
         3 => AttributeValue::Bool(rand::random()),
@@ -272,7 +276,8 @@ fn create_random_element(cx: Scope<DepthProps>) -> Element {
                 .into_boxed_str(),
             ));
             // println!("{template:#?}");
-            let node = VNode {
+            let node =
+                VNode {
                     key: None,
                     parent: None,
                     template: Cell::new(template),

packages/desktop/headless_tests/rendering.rs

@@ -34,7 +34,8 @@ fn use_inner_html(cx: &ScopeState, id: &'static str) -> Option<String> {
         to_owned![value, eval_provider];
         async move {
             tokio::time::sleep(std::time::Duration::from_millis(100)).await;
-            let html = eval_provider(&format!(
+            let html =
+                eval_provider(&format!(
                     r#"let element = document.getElementById('{}');
                     return element.innerHTML"#,
                     id

packages/desktop/src/cfg.rs

@@ -36,7 +36,7 @@ pub struct Config {
     pub(crate) root_name: String,
     pub(crate) background_color: Option<(u8, u8, u8, u8)>,
     pub(crate) last_window_close_behaviour: WindowCloseBehaviour,
-    pub(crate) disable_default_menu_bar: bool,
+    pub(crate) enable_default_menu_bar: bool,
 }
 
 type DropHandler = Box<dyn Fn(&Window, FileDropEvent) -> bool>;
@@ -66,13 +66,15 @@ impl Config {
             root_name: "main".to_string(),
             background_color: None,
             last_window_close_behaviour: WindowCloseBehaviour::LastWindowExitsApp,
-            disable_default_menu_bar: false,
+            enable_default_menu_bar: true,
         }
     }
 
-    /// Set whether the default menu bar should be disabled.
+    /// Set whether the default menu bar should be enabled.
-    pub fn with_disable_default_menu_bar(mut self, disable: bool) -> Self {
+    ///
-        self.disable_default_menu_bar = disable;
+    /// > Note: `enable` is `true` by default. To disable the default menu bar pass `false`.
+    pub fn with_default_menu_bar(mut self, enable: bool) -> Self {
+        self.enable_default_menu_bar = enable;
         self
     }
 

packages/desktop/src/lib.rs

@@ -240,7 +240,8 @@ pub fn launch_with_props<P: 'static>(root: Component<P>, props: P, cfg: Config)
 
             Event::UserEvent(event) => match event.0 {
                 #[cfg(all(feature = "hot-reload", debug_assertions))]
-                EventData::HotReloadEvent(msg) => match msg {
+                EventData::HotReloadEvent(msg) => {
+                    match msg {
                         dioxus_hot_reload::HotReloadMsg::UpdateTemplate(template) => {
                             for webview in webviews.values_mut() {
                                 webview.dom.replace_template(template);
@@ -251,7 +252,8 @@ pub fn launch_with_props<P: 'static>(root: Component<P>, props: P, cfg: Config)
                         dioxus_hot_reload::HotReloadMsg::Shutdown => {
                             *control_flow = ControlFlow::Exit;
                         }
-                },
+                    }
+                }
 
                 EventData::CloseWindow => {
                     webviews.remove(&event.1);

packages/desktop/src/webview.rs

@@ -19,8 +19,8 @@ pub fn build(
     let index_file = cfg.custom_index.clone();
     let root_name = cfg.root_name.clone();
 
-    if !cfg.disable_default_menu_bar {
+    if cfg.enable_default_menu_bar {
-        builder = builder.with_menu(create_default_menu_bar());
+        builder = builder.with_menu(build_default_menu_bar());
     }
 
     let window = builder.with_visible(false).build(event_loop).unwrap();
@@ -103,8 +103,12 @@ pub fn build(
     (webview.build().unwrap(), web_context)
 }
 
-/// Creates a standard menu bar depending on the platform
+/// Builds a standard menu bar depending on the users platform. It may be used as a starting point
-fn create_default_menu_bar() -> MenuBar {
+/// to further customize the menu bar and pass it to a [`WindowBuilder`](tao::window::WindowBuilder).
+/// > Note: The default menu bar enables macOS shortcuts like cut/copy/paste.
+/// > The menu bar differs per platform because of constraints introduced
+/// > by [`MenuItem`](tao::menu::MenuItem).
+pub fn build_default_menu_bar() -> MenuBar {
     let mut menu_bar = MenuBar::new();
 
     // since it is uncommon on windows to have an "application menu"

packages/dioxus-tui/examples/all_terminal_events.rs

@@ -40,7 +40,8 @@ fn app(cx: Scope) -> Element {
         rsx!(p { "{trimmed}" })
     });
 
-    let log_event = move |event: Event| {
+    let log_event =
+        move |event: Event| {
             events.write().push(event);
         };
 

packages/dioxus/benches/jsframework.rs

@@ -87,7 +87,8 @@ impl Label {
     }
 }
 
-static ADJECTIVES: &[&str] = &[
+static ADJECTIVES: &[&str] =
+    &[
         "pretty",
         "large",
         "big",

packages/dioxus/examples/stress.rs

@@ -62,7 +62,8 @@ impl Label {
     }
 }
 
-static ADJECTIVES: &[&str] = &[
+static ADJECTIVES: &[&str] =
+    &[
         "pretty",
         "large",
         "big",

packages/fullstack/examples/axum-auth/src/main.rs

@@ -37,7 +37,8 @@ fn main() {
                 //To enable Private cookies for integrity, and authenticity please check the next Example.
                 let session_config = SessionConfig::default().with_table_name("test_table");
                 let auth_config = AuthConfig::<i64>::default().with_anonymous_user_id(Some(1));
-                let session_store = SessionStore::<SessionSqlitePool>::new(
+                let session_store =
+                    SessionStore::<SessionSqlitePool>::new(
                         Some(pool.clone().into()),
                         session_config,
                     )

packages/fullstack/examples/static-hydrated/src/main.rs

@@ -16,9 +16,9 @@ use serde::{Deserialize, Serialize};
 #[tokio::main]
 async fn main() {
     pre_cache_static_routes_with_props(
-        &ServeConfigBuilder::new_with_router(dioxus_fullstack::router::FullstackRouterConfig::<
+        &ServeConfigBuilder::new_with_router(
-            Route,
+            dioxus_fullstack::router::FullstackRouterConfig::<Route>::default()
-        >::default())
+        )
         .assets_path("docs")
         .incremental(IncrementalRendererConfig::default().static_dir("docs"))
         .build(),

packages/fullstack/src/adapters/axum_adapter.rs

@@ -280,7 +280,8 @@ where
         let assets_path = assets_path.into();
 
         // Serve all files in dist folder except index.html
-        let dir = std::fs::read_dir(&assets_path).unwrap_or_else(|e| {
+        let dir =
+            std::fs::read_dir(&assets_path).unwrap_or_else(|e| {
                 panic!(
                     "Couldn't read assets directory at {:?}: {}",
                     &assets_path, e
@@ -297,9 +298,9 @@ where
                 .unwrap()
                 .iter()
                 .map(|segment| {
-                    segment.to_str().unwrap_or_else(|| {
+                    segment.to_str().unwrap_or_else(
-                        panic!("Failed to convert path segment {:?} to string", segment)
+                        || panic!("Failed to convert path segment {:?} to string", segment)
-                    })
+                    )
                 })
                 .collect::<Vec<_>>()
                 .join("/");

packages/fullstack/src/adapters/salvo_adapter.rs

@@ -244,7 +244,8 @@ impl DioxusRouterExt for Router {
         let assets_path = assets_path.into();
 
         // Serve all files in dist folder except index.html
-        let dir = std::fs::read_dir(&assets_path).unwrap_or_else(|e| {
+        let dir =
+            std::fs::read_dir(&assets_path).unwrap_or_else(|e| {
                 panic!(
                     "Couldn't read assets directory at {:?}: {}",
                     &assets_path, e
@@ -261,9 +262,9 @@ impl DioxusRouterExt for Router {
                 .unwrap()
                 .iter()
                 .map(|segment| {
-                    segment.to_str().unwrap_or_else(|| {
+                    segment.to_str().unwrap_or_else(
-                        panic!("Failed to convert path segment {:?} to string", segment)
+                        || panic!("Failed to convert path segment {:?} to string", segment)
-                    })
+                    )
                 })
                 .collect::<Vec<_>>()
                 .join("/");

packages/fullstack/src/html_storage/deserialize.rs

@@ -7,7 +7,8 @@ use super::HTMLDataCursor;
 
 #[allow(unused)]
 pub(crate) fn serde_from_bytes<T: DeserializeOwned>(string: &[u8]) -> Option<T> {
-    let decompressed = match STANDARD.decode(string) {
+    let decompressed =
+        match STANDARD.decode(string) {
             Ok(bytes) => bytes,
             Err(err) => {
                 tracing::error!("Failed to decode base64: {}", err);

packages/fullstack/src/layer.rs

@@ -46,11 +46,9 @@ where
                 > + Send,
         >,
     > {
-        let fut = self.call(req).instrument(tracing::trace_span!(
+        let fut = self.call(req).instrument(
-            "service",
+            tracing::trace_span!("service", "{}", std::any::type_name::<S>())
-            "{}",
+        );
-            std::any::type_name::<S>()
-        ));
         Box::pin(async move { fut.await.map_err(|err| err.into()) })
     }
 }

packages/fullstack/src/render.rs

@@ -91,10 +91,11 @@ impl SsrRendererPool {
                 Ok((freshness, html))
             }
             Self::Incremental(pool) => {
-                let mut renderer =
+                let mut renderer = pool
-                    pool.write().unwrap().pop().unwrap_or_else(|| {
+                    .write()
-                        incremental_pre_renderer(cfg.incremental.as_ref().unwrap())
+                    .unwrap()
-                    });
+                    .pop()
+                    .unwrap_or_else(|| incremental_pre_renderer(cfg.incremental.as_ref().unwrap()));
 
                 let (tx, rx) = tokio::sync::oneshot::channel();
 

packages/fullstack/src/serve_config.rs

@@ -122,11 +122,13 @@ fn load_index_html(path: PathBuf, root_id: &'static str) -> IndexHtml {
 
     let (pre_main, post_main) = contents.split_once(&format!("id=\"{root_id}\"")).unwrap_or_else(|| panic!("Failed to find id=\"{root_id}\" in index.html. The id is used to inject the application into the page."));
 
-    let post_main = post_main.split_once('>').unwrap_or_else(|| {
+    let post_main =
-        panic!("Failed to find closing > after id=\"{root_id}\" in index.html.")
+        post_main.split_once('>').unwrap_or_else(
-    });
+            || panic!("Failed to find closing > after id=\"{root_id}\" in index.html.")
+        );
 
-    let (pre_main, post_main) = (
+    let (pre_main, post_main) =
+        (
             pre_main.to_string() + &format!("id=\"{root_id}\"") + post_main.0 + ">",
             post_main.1.to_string(),
         );

packages/fullstack/src/server_context.rs

@@ -22,9 +22,9 @@ impl Default for DioxusServerContext {
     fn default() -> Self {
         Self {
             shared_context: std::sync::Arc::new(std::sync::RwLock::new(anymap::Map::new())),
-            response_parts: std::sync::Arc::new(RwLock::new(
+            response_parts: std::sync::Arc::new(
-                http::response::Response::new(()).into_parts().0,
+                RwLock::new(http::response::Response::new(()).into_parts().0)
-            )),
+            ),
             parts: std::sync::Arc::new(RwLock::new(http::request::Request::new(()).into_parts().0)),
             html_data: Arc::new(RwLock::new(HTMLData::default())),
         }
@@ -45,9 +45,9 @@ mod server_fn_impl {
             Self {
                 parts: parts.into(),
                 shared_context: Arc::new(RwLock::new(SendSyncAnyMap::new())),
-                response_parts: std::sync::Arc::new(RwLock::new(
+                response_parts: std::sync::Arc::new(
-                    http::response::Response::new(()).into_parts().0,
+                    RwLock::new(http::response::Response::new(()).into_parts().0)
-                )),
+                ),
                 html_data: Arc::new(RwLock::new(HTMLData::default())),
             }
         }
@@ -221,9 +221,9 @@ impl<T: Send + Sync + Clone + 'static> FromServerContext for FromContext<T> {
     type Rejection = NotFoundInServerContext<T>;
 
     async fn from_request(req: &DioxusServerContext) -> Result<Self, Self::Rejection> {
-        Ok(Self(req.clone().get::<T>().ok_or_else(|| {
+        Ok(Self(req.clone().get::<T>().ok_or_else(
-            NotFoundInServerContext::<T>(std::marker::PhantomData::<T>)
+            || NotFoundInServerContext::<T>(std::marker::PhantomData::<T>)
-        })?))
+        )?))
     }
 }
 

packages/hooks/src/use_coroutine.rs

@@ -129,7 +129,8 @@ mod tests {
     use futures_util::StreamExt;
 
     fn app(cx: Scope, name: String) -> Element {
-        let task = use_coroutine(cx, |mut rx: UnboundedReceiver<i32>| async move {
+        let task =
+            use_coroutine(cx, |mut rx: UnboundedReceiver<i32>| async move {
                 while let Some(msg) = rx.next().await {
                     println!("got message: {msg}");
                 }

packages/hooks/src/use_shared_state.rs

@@ -226,10 +226,12 @@ impl<T> UseSharedState<T> {
     pub fn read(&self) -> Ref<'_, T> {
         match self.try_read() {
             Ok(value) => value,
-            Err(message) => panic!(
+            Err(message) => {
+                panic!(
                     "Reading the shared state failed: {}\n({:?})",
                     message, message
-            ),
+                )
+            }
         }
     }
 
@@ -258,10 +260,12 @@ impl<T> UseSharedState<T> {
     pub fn write(&self) -> RefMut<'_, T> {
         match self.try_write() {
             Ok(value) => value,
-            Err(message) => panic!(
+            Err(message) => {
+                panic!(
                     "Writing to shared state failed: {}\n({:?})",
                     message, message
-            ),
+                )
+            }
         }
     }
 
@@ -284,10 +288,12 @@ impl<T> UseSharedState<T> {
     pub fn write_silent(&self) -> RefMut<'_, T> {
         match self.try_write_silent() {
             Ok(value) => value,
-            Err(message) => panic!(
+            Err(message) => {
+                panic!(
                     "Writing to shared state silently failed: {}\n({:?})",
                     message, message
-            ),
+                )
+            }
         }
     }
 
@@ -363,7 +369,8 @@ impl<T> PartialEq for UseSharedState<T> {
 /// ```
 pub fn use_shared_state_provider<T: 'static>(cx: &ScopeState, f: impl FnOnce() -> T) {
     cx.use_hook(|| {
-        let state: ProvidedState<T> = Rc::new(RefCell::new(ProvidedStateInner {
+        let state: ProvidedState<T> =
+            Rc::new(RefCell::new(ProvidedStateInner {
                 value: f(),
                 notify_any: cx.schedule_update_any(),
                 consumers: HashSet::new(),

packages/hooks/src/use_state.rs

@@ -35,7 +35,8 @@ pub fn use_state<T: 'static>(
     cx: &ScopeState,
     initial_state_fn: impl FnOnce() -> T,
 ) -> &UseState<T> {
-    let hook = cx.use_hook(move || {
+    let hook =
+        cx.use_hook(move || {
             let current_val = Rc::new(initial_state_fn());
             let update_callback = cx.schedule_update();
             let slot = Rc::new(RefCell::new(current_val.clone()));

packages/liveview/examples/axum.rs

@@ -37,9 +37,9 @@ async fn main() {
             .route(
                 "/",
                 get(move || async move {
-                    index_page_with_glue(&dioxus_liveview::interpreter_glue(&format!(
+                    index_page_with_glue(
-                        "ws://{addr}/ws"
+                        &dioxus_liveview::interpreter_glue(&format!("ws://{addr}/ws"))
-                    )))
+                    )
                 }),
             )
             .route(

packages/liveview/src/pool.rs

@@ -112,7 +112,8 @@ impl<S> LiveViewSocket for S where
 /// You might need to transform the error types of the web backend into the LiveView error type.
 pub async fn run(mut vdom: VirtualDom, ws: impl LiveViewSocket) -> Result<(), LiveViewError> {
     #[cfg(all(feature = "hot-reload", debug_assertions))]
-    let mut hot_reload_rx = {
+    let mut hot_reload_rx =
+        {
             let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
             dioxus_hot_reload::connect(move |template| {
                 let _ = tx.send(template);

packages/native-core-macro/src/lib.rs

@@ -66,7 +66,8 @@ pub fn partial_derive_state(_: TokenStream, input: TokenStream) -> TokenStream {
         Some(tuple) => {
             let mut parent_dependencies = Vec::new();
             for type_ in &tuple.elems {
-                let mut type_ = extract_type_path(type_).unwrap_or_else(|| {
+                let mut type_ =
+                    extract_type_path(type_).unwrap_or_else(|| {
                         panic!(
                             "ParentDependencies must be a tuple of type paths, found {}",
                             quote!(#type_)
@@ -80,16 +81,19 @@ pub fn partial_derive_state(_: TokenStream, input: TokenStream) -> TokenStream {
             }
             parent_dependencies
         }
-        _ => panic!(
+        _ => {
+            panic!(
                 "ParentDependencies must be a tuple, found {}",
                 quote!(#parent_dependencies)
-        ),
+            )
+        }
     };
     let child_dependencies = match extract_tuple(child_dependencies) {
         Some(tuple) => {
             let mut child_dependencies = Vec::new();
             for type_ in &tuple.elems {
-                let mut type_ = extract_type_path(type_).unwrap_or_else(|| {
+                let mut type_ =
+                    extract_type_path(type_).unwrap_or_else(|| {
                         panic!(
                             "ChildDependencies must be a tuple of type paths, found {}",
                             quote!(#type_)
@@ -103,12 +107,15 @@ pub fn partial_derive_state(_: TokenStream, input: TokenStream) -> TokenStream {
             }
             child_dependencies
         }
-        _ => panic!(
+        _ => {
+            panic!(
                 "ChildDependencies must be a tuple, found {}",
                 quote!(#child_dependencies)
-        ),
+            )
+        }
     };
-    let node_dependencies = match extract_tuple(node_dependencies) {
+    let node_dependencies =
+        match extract_tuple(node_dependencies) {
             Some(tuple) => {
                 let mut node_dependencies = Vec::new();
                 for type_ in &tuple.elems {
@@ -126,10 +133,12 @@ pub fn partial_derive_state(_: TokenStream, input: TokenStream) -> TokenStream {
                 }
                 node_dependencies
             }
-        _ => panic!(
+            _ => {
+                panic!(
                     "NodeDependencies must be a tuple, found {}",
                     quote!(#node_dependencies)
-        ),
+                )
+            }
         };
     combined_dependencies.insert(this_type.clone());
 

packages/native-core/examples/custom_attr.rs

@@ -160,7 +160,8 @@ impl State<X> for Border {
         _context: &SendAnyMap,
     ) -> bool {
         // check if the node contians a border attribute
-        let new = Self(
+        let new =
+            Self(
                 node_view
                     .attributes()
                     .and_then(|mut attrs| attrs.next().map(|a| a.attribute.name == "border"))

packages/native-core/examples/simple.rs

@@ -151,7 +151,8 @@ impl State for Border {
         _context: &SendAnyMap,
     ) -> bool {
         // check if the node contians a border attribute
-        let new = Self(
+        let new =
+            Self(
                 node_view
                     .attributes()
                     .and_then(|mut attrs| attrs.next().map(|a| a.attribute.name == "border"))

packages/native-core/examples/simple_dioxus.rs

@@ -152,7 +152,8 @@ impl State for Border {
         _context: &SendAnyMap,
     ) -> bool {
         // check if the node contians a border attribute
-        let new = Self(
+        let new =
+            Self(
                 node_view
                     .attributes()
                     .and_then(|mut attrs| attrs.next().map(|a| a.attribute.name == "border"))

packages/native-core/src/layout_attributes.rs

@@ -340,7 +340,8 @@ pub fn apply_layout_attributes_cfg(
             }
             Property::JustifyContent(justify, _) => {
                 use AlignContent::*;
-                style.justify_content = match justify {
+                style.justify_content =
+                    match justify {
                         align::JustifyContent::ContentDistribution(distribution) => {
                             match distribution {
                                 align::ContentDistribution::SpaceBetween => Some(SpaceBetween),
@@ -585,11 +586,13 @@ fn convert_grid_track_size(input: grid::TrackSize) -> NonRepeatedTrackSizingFunc
             convert_track_breadth_min(&min),
             convert_track_breadth_max(&max),
         ),
-        grid::TrackSize::FitContent(limit) => match limit {
+        grid::TrackSize::FitContent(limit) => {
+            match limit {
                 DimensionPercentage::Dimension(LengthValue::Px(len)) => minmax(auto(), points(len)),
                 DimensionPercentage::Percentage(Percentage(pct)) => minmax(auto(), percent(pct)),
                 _ => unimplemented!(),
-        },
+            }
+        }
     }
 }
 

packages/native-core/src/utils/persistant_iterator.rs

@@ -488,8 +488,5 @@ fn persist_instertions_after() {
     ));
     let text = "hello world".to_string();
     let idx = iter.next(&rdom).id();
-    assert!(matches!(
+    assert!(matches!(&*rdom.get(idx).unwrap().node_type(), NodeType::Text(text)));
-        &*rdom.get(idx).unwrap().node_type(),
-        NodeType::Text(text)
-    ));
 }

packages/native-core/tests/fuzzing.rs

@@ -9,9 +9,7 @@ fn random_ns() -> Option<&'static str> {
     let namespace = rand::random::<u8>() % 2;
     match namespace {
         0 => None,
-        1 => Some(Box::leak(
+        1 => Some(Box::leak(format!("ns{}", rand::random::<usize>()).into_boxed_str())),
-            format!("ns{}", rand::random::<usize>()).into_boxed_str(),
-        )),
         _ => unreachable!(),
     }
 }
@@ -23,13 +21,15 @@ fn create_random_attribute(attr_idx: &mut usize) -> TemplateAttribute<'static> {
             value: Box::leak(format!("value{}", rand::random::<usize>()).into_boxed_str()),
             namespace: random_ns(),
         },
-        1 => TemplateAttribute::Dynamic {
+        1 => {
+            TemplateAttribute::Dynamic {
                 id: {
                     let old_idx = *attr_idx;
                     *attr_idx += 1;
                     old_idx
                 },
-        },
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -74,22 +74,26 @@ fn create_random_template_node(
         1 => TemplateNode::Text {
             text: Box::leak(format!("{}", rand::random::<usize>()).into_boxed_str()),
         },
-        2 => TemplateNode::DynamicText {
+        2 => {
+            TemplateNode::DynamicText {
                 id: {
                     let old_idx = *template_idx;
                     *template_idx += 1;
                     dynamic_node_types.push(DynamicNodeType::Text);
                     old_idx
                 },
-        },
+            }
-        3 => TemplateNode::Dynamic {
+        }
+        3 => {
+            TemplateNode::Dynamic {
                 id: {
                     let old_idx = *template_idx;
                     *template_idx += 1;
                     dynamic_node_types.push(DynamicNodeType::Other);
                     old_idx
                 },
-        },
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -206,9 +210,9 @@ fn create_random_dynamic_node(cx: &ScopeState, depth: usize) -> DynamicNode {
 
 fn create_random_dynamic_attr(cx: &ScopeState) -> Attribute {
     let value = match rand::random::<u8>() % 6 {
-        0 => AttributeValue::Text(Box::leak(
+        0 => {
-            format!("{}", rand::random::<usize>()).into_boxed_str(),
+            AttributeValue::Text(Box::leak(format!("{}", rand::random::<usize>()).into_boxed_str()))
-        )),
+        }
         1 => AttributeValue::Float(rand::random()),
         2 => AttributeValue::Int(rand::random()),
         3 => AttributeValue::Bool(rand::random()),

packages/rink/src/focus.rs

@@ -83,7 +83,8 @@ impl State for Focus {
         _: &SendAnyMap,
     ) -> bool {
         let new = Focus {
-            level: if let Some(a) = node_view
+            level:
+                if let Some(a) = node_view
                     .attributes()
                     .and_then(|mut a| a.find(|a| a.attribute.name == "tabindex"))
                 {
@@ -104,9 +105,9 @@ impl State for Focus {
                     }
                 } else if node_view
                     .listeners()
-                .and_then(|mut listeners| {
+                    .and_then(
-                    listeners.any(|l| FOCUS_EVENTS.contains(&l)).then_some(())
+                        |mut listeners| listeners.any(|l| FOCUS_EVENTS.contains(&l)).then_some(())
-                })
+                    )
                     .is_some()
                 {
                     FocusLevel::Focusable

packages/rink/src/hooks.rs

@@ -585,7 +585,8 @@ impl RinkInputHandler {
         let queued_events = Rc::new(RefCell::new(Vec::new()));
         let queued_events2 = Rc::downgrade(&queued_events);
 
-        let regester_event = move |evt: crossterm::event::Event| {
+        let regester_event =
+            move |evt: crossterm::event::Event| {
                 if let Some(evt) = get_event(evt) {
                     if let Some(v) = queued_events2.upgrade() {
                         (*v).borrow_mut().push(evt);
@@ -680,7 +681,8 @@ fn get_event(evt: TermEvent) -> Option<(&'static str, EventData)> {
             let ctrl = m.modifiers.contains(KeyModifiers::CONTROL);
             let meta = false;
 
-            let get_mouse_data = |crossterm_button: Option<MouseButton>| {
+            let get_mouse_data =
+                |crossterm_button: Option<MouseButton>| {
                     let button = crossterm_button.map(|b| match b {
                         MouseButton::Left => DioxusMouseButton::Primary,
                         MouseButton::Right => DioxusMouseButton::Secondary,

packages/rink/src/layout.rs

@@ -195,7 +195,8 @@ impl State for TaffyLayout {
                     taffy.set_children(n, &child_layout).unwrap();
                 }
             } else {
-                self.node = PossiblyUninitalized::Initialized(
+                self.node =
+                    PossiblyUninitalized::Initialized(
                         taffy
                             .new_with_children(scaled_style, &child_layout)
                             .unwrap(),

packages/rink/src/prevent_default.rs

@@ -43,7 +43,8 @@ impl State for PreventDefault {
         _: Vec<<Self::ChildDependencies as Dependancy>::ElementBorrowed<'a>>,
         _: &SendAnyMap,
     ) -> bool {
-        let new = match node_view.attributes().and_then(|mut attrs| {
+        let new =
+            match node_view.attributes().and_then(|mut attrs| {
                 attrs
                     .find(|a| a.attribute.name == "dioxus-prevent-default")
                     .and_then(|a| a.value.as_text())

packages/rink/src/style.rs

@@ -350,7 +350,8 @@ pub fn convert(mode: RenderingMode, c: Color) -> Color {
                 let rgb = to_rgb(c);
                 Color::Rgb(rgb[0], rgb[1], rgb[2])
             }
-            crate::RenderingMode::Ansi => match c {
+            crate::RenderingMode::Ansi => {
+                match c {
                     Color::Indexed(_) => c,
                     _ => {
                         let rgb = to_rgb(c);
@@ -367,7 +368,8 @@ pub fn convert(mode: RenderingMode, c: Color) -> Color {
                             Color::Indexed(idx as u8)
                         }
                     }
-            },
+                }
+            }
         }
     }
 }

packages/rink/src/widgets/button.rs

@@ -90,7 +90,8 @@ impl Button {
     }
 
     fn switch(&mut self, ctx: &WidgetContext, node: NodeMut) {
-        let data = FormData {
+        let data =
+            FormData {
                 value: self.value.to_string(),
                 values: HashMap::new(),
                 files: None,

packages/rink/src/widgets/slider.rs

@@ -236,7 +236,8 @@ impl Slider {
             let id = root.id();
             let rdom = root.real_dom_mut();
             let world = rdom.raw_world_mut();
-            let taffy = {
+            let taffy =
+                {
                     let query: UniqueView<Query> = world.borrow().unwrap();
                     query.stretch.clone()
                 };
@@ -267,7 +268,8 @@ impl CustomElement for Slider {
             panic!("input must be an element")
         };
 
-        let value = el.attributes.get(&OwnedAttributeDiscription {
+        let value =
+            el.attributes.get(&OwnedAttributeDiscription {
                 name: "value".to_string(),
                 namespace: None,
             });
@@ -301,7 +303,8 @@ impl CustomElement for Slider {
 
         let cursor_text = rdom.create_node("|".to_string());
         let cursor_text_id = cursor_text.id();
-        let mut cursor_span = rdom.create_node(NodeType::Element(ElementNode {
+        let mut cursor_span =
+            rdom.create_node(NodeType::Element(ElementNode {
                 tag: "div".to_string(),
                 attributes: [].into_iter().collect(),
                 ..Default::default()

packages/router-macro/src/route.rs

@@ -144,7 +144,8 @@ impl Route {
             _ => Vec::new(),
         };
 
-        let (route_segments, query) = {
+        let (route_segments, query) =
+            {
                 parse_route_segments(
                     variant.ident.span(),
                     fields.iter().map(|f| (&f.0, &f.1)),
@@ -323,7 +324,8 @@ impl Route {
 
     pub fn error_type(&self) -> TokenStream2 {
         let error_name = self.error_ident();
-        let child_type = match &self.ty {
+        let child_type =
+            match &self.ty {
                 RouteType::Child(field) => Some(&field.ty),
                 RouteType::Leaf { .. } => None,
             };

packages/router-macro/src/segment.rs

@@ -135,7 +135,8 @@ pub fn parse_route_segments<'a>(
 ) -> syn::Result<(Vec<RouteSegment>, Option<QuerySegment>)> {
     let mut route_segments = Vec::new();
 
-    let (route_string, query) = match route.rsplit_once('?') {
+    let (route_string, query) =
+        match route.rsplit_once('?') {
             Some((route, query)) => (route, Some(query)),
             None => (route, None),
         };
@@ -157,7 +158,8 @@ pub fn parse_route_segments<'a>(
         if let Some(segment) = segment.strip_prefix(':') {
             let spread = segment.starts_with("..");
 
-            let ident = if spread {
+            let ident =
+                if spread {
                     segment[2..].to_string()
                 } else {
                     segment.to_string()
@@ -205,7 +207,8 @@ pub fn parse_route_segments<'a>(
                 let query_ident = Ident::new(query, Span::call_site());
                 let field = fields.find(|(name, _)| *name == &query_ident);
 
-                let ty = if let Some((_, ty)) = field {
+                let ty =
+                    if let Some((_, ty)) = field {
                         ty.clone()
                     } else {
                         return Err(syn::Error::new(

packages/router/src/history/liveview.rs

@@ -77,7 +77,8 @@ where
                 self.routes.retain(|&lhs, _| lhs <= last_visited);
             }
         };
-        let state = match state {
+        let state =
+            match state {
                 Some(state) => {
                     self.current_index = state.index;
                     state

packages/router/src/history/web.rs

@@ -302,7 +302,8 @@ where
         let s = self.listener_animation_frame.clone();
         let d = self.do_scroll_restoration;
 
-        self.listener_navigation = Some(EventListener::new(&self.window, "popstate", move |_| {
+        self.listener_navigation =
+            Some(EventListener::new(&self.window, "popstate", move |_| {
                 (*callback)();
                 if d {
                     let mut s = s.lock().expect("unpoisoned scroll mutex");
@@ -377,7 +378,8 @@ where
         let s = self.listener_animation_frame.clone();
         let d = self.do_scroll_restoration;
 
-        self.listener_navigation = Some(EventListener::new(&self.window, "popstate", move |_| {
+        self.listener_navigation =
+            Some(EventListener::new(&self.window, "popstate", move |_| {
                 (*callback)();
                 if d {
                     let mut s = s.lock().expect("unpoisoned scroll mutex");

packages/router/src/navigation.rs

@@ -114,11 +114,9 @@ impl<R: Routable> FromStr for NavigationTarget<R> {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match Url::parse(s) {
             Ok(_) => Ok(Self::External(s.to_string())),
-            Err(ParseError::RelativeUrlWithoutBase) => {
+            Err(ParseError::RelativeUrlWithoutBase) => Ok(Self::Internal(
-                Ok(Self::Internal(R::from_str(s).map_err(|e| {
+                R::from_str(s).map_err(|e| NavigationTargetParseError::InvalidInternalURL(e))?,
-                    NavigationTargetParseError::InvalidInternalURL(e)
+            )),
-                })?))
-            }
             Err(e) => Err(NavigationTargetParseError::InvalidUrl(e)),
         }
     }

packages/router/src/routable.rs

@@ -134,7 +134,8 @@ impl<I: std::iter::FromIterator<String>> FromRouteSegments for I {
 
 /// A flattened version of [`Routable::SITE_MAP`].
 /// This essentially represents a `Vec<Vec<SegmentType>>`, which you can collect it into.
-type SiteMapFlattened<'a> = FlatMap<
+type SiteMapFlattened<'a> =
+    FlatMap<
         Iter<'a, SiteMapSegment>,
         Vec<Vec<SegmentType>>,
         fn(&SiteMapSegment) -> Vec<Vec<SegmentType>>,

packages/router/src/utils/use_router_internal.rs

@@ -11,7 +11,8 @@ use crate::prelude::*;
 /// - [`None`], when the current component isn't a descendant of a [`Link`] component.
 /// - Otherwise [`Some`].
 pub(crate) fn use_router_internal(cx: &ScopeState) -> &Option<RouterContext> {
-    let inner = cx.use_hook(|| {
+    let inner =
+        cx.use_hook(|| {
             let router = cx.consume_context::<RouterContext>()?;
 
             let id = cx.scope_id();

packages/rsx-rosetta/tests/simple.rs

@@ -36,7 +36,8 @@ fn simple_elements() {
 
 #[test]
 fn deeply_nested() {
-    let html = r#"
+    let html =
+        r#"
     <div>
         <div class="asd">
             <div class="asd">

packages/rsx/src/component.rs

@@ -162,7 +162,8 @@ impl ToTokens for Component {
                 }
 
                 if !self.children.is_empty() {
-                    let renderer: TemplateRenderer = TemplateRenderer {
+                    let renderer: TemplateRenderer =
+                        TemplateRenderer {
                             roots: &self.children,
                             location: None,
                         };
@@ -183,7 +184,8 @@ impl ToTokens for Component {
 
         let fn_name = self.name.segments.last().unwrap().ident.to_string();
 
-        let gen_name = match &self.prop_gen_args {
+        let gen_name =
+            match &self.prop_gen_args {
                 Some(gen) => quote! { #name #gen },
                 None => quote! { #name },
             };

packages/rsx/src/element.rs

@@ -332,7 +332,8 @@ impl ToTokens for ElementAttrNamed {
             }
         };
 
-        let attribute = match attr {
+        let attribute =
+            match attr {
                 ElementAttr::AttrText { name, value } => {
                     let ns = ns(name);
                     let volitile = volitile(name);

packages/rsx/src/hot_reload/hot_reloading_file_map.rs

@@ -77,7 +77,8 @@ impl<Ctx: HotReloadingContext> FileMap<Ctx> {
         }
 
         let FileMapSearchResult { map, errors } = find_rs_files(path, &mut filter)?;
-        let result = Self {
+        let result =
+            Self {
                 map,
                 in_workspace: HashMap::new(),
                 phantom: std::marker::PhantomData,

packages/rsx/src/ifmt.rs

@@ -99,10 +99,9 @@ impl FromStr for IfmtInput {
                         current_literal.push(c);
                         continue;
                     } else {
-                        return Err(Error::new(
+                        return Err(
-                            Span::call_site(),
+                            Error::new(Span::call_site(), "unmatched closing '}' in format string")
-                            "unmatched closing '}' in format string",
+                        );
-                        ));
                     }
                 }
                 current_literal.push(c);
@@ -147,7 +146,8 @@ impl ToTokens for IfmtInput {
             }
         }
 
-        let positional_args = self.segments.iter().filter_map(|seg| {
+        let positional_args =
+            self.segments.iter().filter_map(|seg| {
                 if let Segment::Formatted(FormattedSegment {
                     segment: FormattedSegmentType::Expr(expr),
                     ..
@@ -228,10 +228,7 @@ impl FormattedSegmentType {
         if let Ok(expr) = parse_str(input) {
             Ok(Self::Expr(Box::new(expr)))
         } else {
-            Err(Error::new(
+            Err(Error::new(Span::call_site(), "Expected Ident or Expression"))
-                Span::call_site(),
-                "Expected Ident or Expression",
-            ))
         }
     }
 }

packages/rsx/src/lib.rs

@@ -199,7 +199,8 @@ impl<'a> ToTokens for TemplateRenderer<'a> {
             _ => None,
         };
 
-        let key_tokens = match key {
+        let key_tokens =
+            match key {
                 Some(tok) => quote! { Some( __cx.raw_text(#tok) ) },
                 None => quote! { None },
             };
@@ -518,7 +519,8 @@ impl<'a> DynamicContext<'a> {
 
                 let attrs = quote! { #(#static_attrs),*};
 
-                let children = el.children.iter().enumerate().map(|(idx, root)| {
+                let children =
+                    el.children.iter().enumerate().map(|(idx, root)| {
                         self.current_path.push(idx as u8);
                         let out = self.render_static_node(root);
                         self.current_path.pop();

packages/server-macro/src/lib.rs

@@ -65,7 +65,8 @@ use syn::{
 #[proc_macro_attribute]
 pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
     // before we pass this off to the server function macro, we apply extractors and middleware
-    let mut function: syn::ItemFn = match syn::parse(s).map_err(|e| e.to_compile_error()) {
+    let mut function: syn::ItemFn =
+        match syn::parse(s).map_err(|e| e.to_compile_error()) {
             Ok(f) => f,
             Err(e) => return e.into(),
         };

packages/signals/src/effect.rs

@@ -87,7 +87,8 @@ impl Effect {
     ///
     /// The signal will be owned by the current component and will be dropped when the component is dropped.
     pub fn new(callback: impl FnMut() + 'static) -> Self {
-        let myself = Self {
+        let myself =
+            Self {
                 source: current_scope_id().expect("in a virtual dom"),
                 callback: CopyValue::new(Box::new(callback)),
                 effect_stack: get_effect_stack(),

packages/signals/src/selector.rs

@@ -72,7 +72,8 @@ where
 ///
 /// Selectors can be used to efficiently compute derived data from signals.
 pub fn selector<R: PartialEq>(mut f: impl FnMut() -> R + 'static) -> ReadOnlySignal<R> {
-    let state = Signal::<R> {
+    let state =
+        Signal::<R> {
             inner: CopyValue::invalid(),
         };
     let effect = Effect {

packages/signals/tests/create.rs

@@ -6,7 +6,8 @@ use dioxus_signals::*;
 
 #[test]
 fn create_signals_global() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             render! {
                 for _ in 0..10 {
                     Child {}
@@ -31,7 +32,8 @@ fn create_signals_global() {
 
 #[test]
 fn deref_signal() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             render! {
                 for _ in 0..10 {
                     Child {}
@@ -55,7 +57,8 @@ fn deref_signal() {
 
 #[test]
 fn drop_signals() {
-    let mut dom = VirtualDom::new(|cx| {
+    let mut dom =
+        VirtualDom::new(|cx| {
             let generation = cx.generation();
 
             let count = if generation % 2 == 0 { 10 } else { 0 };

packages/signals/tests/selector.rs

@@ -100,7 +100,8 @@ fn memos_prevents_component_rerun() {
         let signal = cx.props.signal;
         counter.borrow_mut().component += 1;
 
-        let memo = cx.use_hook(move || {
+        let memo =
+            cx.use_hook(move || {
                 to_owned![counter];
                 selector(move || {
                     counter.borrow_mut().effect += 1;

packages/web/src/cache.rs

@@ -1,4 +1,5 @@
-pub static BUILTIN_INTERNED_STRINGS: &[&str] = &[
+pub static BUILTIN_INTERNED_STRINGS: &[&str] =
+    &[
         // Important tags to dioxus
         "dioxus-id",
         "dioxus",

packages/web/src/dom.rs

@@ -80,7 +80,8 @@ impl WebsysDom {
                     }
 
                     let data = virtual_event_from_websys_event(event.clone(), target);
-                    let _ = event_channel.unbounded_send(UiEvent {
+                    let _ =
+                        event_channel.unbounded_send(UiEvent {
                             name,
                             bubbles,
                             element,

packages/web/src/eval.rs

@@ -62,24 +62,18 @@ impl WebEvaluator {
                 if let Ok(stringified) = js_sys::JSON::stringify(&result) {
                     if !stringified.is_undefined() && stringified.is_valid_utf16() {
                         let string: String = stringified.into();
-                        Value::from_str(&string).map_err(|e| {
+                        Value::from_str(&string).map_err(
-                            EvalError::Communication(format!("Failed to parse result - {}", e))
+                            |e| EvalError::Communication(format!("Failed to parse result - {}", e))
-                        })?
+                        )?
                     } else {
-                        return Err(EvalError::Communication(
+                        return Err(EvalError::Communication("Failed to stringify result".into()));
-                            "Failed to stringify result".into(),
-                        ));
                     }
                 } else {
-                    return Err(EvalError::Communication(
+                    return Err(EvalError::Communication("Failed to stringify result".into()));
-                        "Failed to stringify result".into(),
-                    ));
                 }
             }
             Err(err) => {
-                return Err(EvalError::InvalidJs(
+                return Err(EvalError::InvalidJs(err.as_string().unwrap_or("unknown".to_string())));
-                    err.as_string().unwrap_or("unknown".to_string()),
-                ));
             }
         };