improved documentation and refactored naming to be more self-explanatory

packages/cli/src/builder.rs

@@ -67,19 +67,21 @@ pub fn build(config: &CrateConfig, quiet: bool) -> Result<BuildResult> {
         cmd.arg("--quiet")
     };
 
-    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.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 features_str = config.features.as_ref().unwrap().join(" ");
-        cmd.arg("--features").arg(features_str)
-    } else {
-        cmd
-    };
+    let cmd =
+        if config.features.is_some() {
+            let features_str = config.features.as_ref().unwrap().join(" ");
+            cmd.arg("--features").arg(features_str)
+        } else {
+            cmd
+        };
 
     let cmd = match executable {
         ExecutableType::Binary(name) => cmd.arg("--bin").arg(name),
@@ -92,13 +94,14 @@ 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() {
-        config.custom_profile.as_ref().unwrap()
-    } else if config.release {
-        "release"
-    } else {
-        "debug"
-    };
+    let build_profile =
+        if config.custom_profile.is_some() {
+            config.custom_profile.as_ref().unwrap()
+        } else if config.release {
+            "release"
+        } else {
+            "debug"
+        };
 
     let input_path = match executable {
         ExecutableType::Binary(name) | ExecutableType::Lib(name) => target_dir
@@ -207,14 +210,15 @@ 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 {
-        overwrite: true,
-        skip_exist: false,
-        buffer_size: 64000,
-        copy_inside: false,
-        content_only: false,
-        depth: 0,
-    };
+    let copy_options =
+        fs_extra::dir::CopyOptions {
+            overwrite: true,
+            skip_exist: false,
+            buffer_size: 64000,
+            copy_inside: false,
+            content_only: false,
+            depth: 0,
+        };
     if asset_dir.is_dir() {
         for entry in std::fs::read_dir(asset_dir)? {
             let path = entry?.path();
@@ -287,20 +291,21 @@ pub fn build_desktop(config: &CrateConfig, _is_serve: bool) -> Result<BuildResul
     };
 
     let file_name: String;
-    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)
-        }
-        crate::ExecutableType::Example(name) => {
-            file_name = name.clone();
-            config
-                .target_dir
-                .join(release_type)
-                .join("examples")
-                .join(name)
-        }
-    };
+    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)
+            }
+            crate::ExecutableType::Example(name) => {
+                file_name = name.clone();
+                config
+                    .target_dir
+                    .join(release_type)
+                    .join("examples")
+                    .join(name)
+            }
+        };
 
     let target_file = if cfg!(windows) {
         res_path.set_extension("exe");
@@ -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
-                                .rendered
-                                .unwrap_or("Unknown".into())))
+                            Err(anyhow::anyhow!(message.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 src=\"{}\"></script>\n",
-            &script.to_str().unwrap(),
-        ))
+        script_str.push_str(&format!("<script src=\"{}\"></script>\n", &script.to_str().unwrap(),))
     }
 
     replace_or_insert_before("{script_include}", &script_str, "</body", &mut html);
@@ -502,10 +502,11 @@ 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(
-            "</body",
-            &format!(
-                r#"<script type="module">
+        html =
+            html.replace(
+                "</body",
+                &format!(
+                    r#"<script type="module">
     import init from "/{base_path}/assets/dioxus/{app_name}.js";
     init("/{base_path}/assets/dioxus/{app_name}_bg.wasm").then(wasm => {{
       if (wasm.__wbindgen_start == undefined) {{
@@ -514,8 +515,8 @@ pub fn gen_page(config: &DioxusConfig, serve: bool) -> String {
     }});
     </script>
     </body"#
-            ),
-        );
+                ),
+            );
     }
 
     let title = config

packages/cli/src/cargo.rs

@@ -34,9 +34,9 @@ pub fn crate_root() -> Result<PathBuf> {
             }
             None
         })
-        .ok_or_else(|| {
-            Error::CargoError("Failed to find directory containing Cargo.toml".to_string())
-        })
+        .ok_or_else(
+            || 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,47 +93,48 @@ 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
-        .into_iter()
-        .filter(|file| {
-            if file.components().any(|f| f.as_os_str() == "target") {
-                return false;
-            }
-
-            true
-        })
-        .map(|path| async {
-            let _path = path.clone();
-            let res = tokio::spawn(async move {
-                let contents = tokio::fs::read_to_string(&path).await?;
-
-                let edits = dioxus_autofmt::fmt_file(&contents);
-                let len = edits.len();
-
-                if !edits.is_empty() {
-                    let out = dioxus_autofmt::apply_formats(&contents, edits);
-                    tokio::fs::write(&path, out).await?;
+    let counts =
+        files_to_format
+            .into_iter()
+            .filter(|file| {
+                if file.components().any(|f| f.as_os_str() == "target") {
+                    return false;
                 }
 
-                Ok(len) as Result<usize, tokio::io::Error>
+                true
             })
-            .await;
+            .map(|path| async {
+                let _path = path.clone();
+                let res = tokio::spawn(async move {
+                    let contents = tokio::fs::read_to_string(&path).await?;
 
-            match res {
-                Err(err) => {
-                    eprintln!("error formatting file: {}\n{err}", _path.display());
-                    None
+                    let edits = dioxus_autofmt::fmt_file(&contents);
+                    let len = edits.len();
+
+                    if !edits.is_empty() {
+                        let out = dioxus_autofmt::apply_formats(&contents, edits);
+                        tokio::fs::write(&path, out).await?;
+                    }
+
+                    Ok(len) as Result<usize, tokio::io::Error>
+                })
+                .await;
+
+                match res {
+                    Err(err) => {
+                        eprintln!("error formatting file: {}\n{err}", _path.display());
+                        None
+                    }
+                    Ok(Err(err)) => {
+                        eprintln!("error formatting file: {}\n{err}", _path.display());
+                        None
+                    }
+                    Ok(Ok(res)) => Some(res),
                 }
-                Ok(Err(err)) => {
-                    eprintln!("error formatting file: {}\n{err}", _path.display());
-                    None
-                }
-                Ok(Ok(res)) => Some(res),
-            }
-        })
-        .collect::<FuturesUnordered<_>>()
-        .collect::<Vec<_>>()
-        .await;
+            })
+            .collect::<FuturesUnordered<_>>()
+            .collect::<Vec<_>>()
+            .await;
 
     let files_formatted: usize = counts
         .into_iter()

packages/cli/src/cli/create.rs

@@ -35,13 +35,14 @@ 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| {
-                anyhow::anyhow!(
-                    "failed to parse toml at {}: {}",
-                    toml_path.display(),
-                    e.to_string()
-                )
-            })?;
+            let mut toml =
+                toml.parse::<toml_edit::Document>().map_err(|e| {
+                    anyhow::anyhow!(
+                        "failed to parse toml at {}: {}",
+                        toml_path.display(),
+                        e.to_string()
+                    )
+                })?;
 
             toml.as_table_mut().fmt();
 

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

@@ -67,11 +67,12 @@ 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) {
-                v
-            } else {
-                return Ok(false);
-            };
+            let tar_gz =
+                if let Ok(v) = File::open(file) {
+                    v
+                } else {
+                    return Ok(false);
+                };
 
             let tar = GzDecoder::new(tar_gz);
             let mut archive = Archive::new(tar);

packages/cli/src/plugin/mod.rs

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

packages/cli/src/server/output.rs

@@ -22,12 +22,13 @@ pub fn print_console_info(
     options: PrettierOptions,
     web_info: Option<WebServerInfo>,
 ) {
-    if let Ok(native_clearseq) = Command::new(if cfg!(target_os = "windows") {
-        "cls"
-    } else {
-        "clear"
-    })
-    .output()
+    if let Ok(native_clearseq) =
+        Command::new(if cfg!(target_os = "windows") {
+            "cls"
+        } else {
+            "clear"
+        })
+        .output()
     {
         print!("{}", String::from_utf8_lossy(&native_clearseq.stdout));
     } else {
@@ -46,17 +47,18 @@ pub fn print_console_info(
     } else {
         "Default"
     };
-    let url_rewrite = if config
-        .dioxus_config
-        .web
-        .watcher
-        .index_on_404
-        .unwrap_or(false)
-    {
-        "True"
-    } else {
-        "False"
-    };
+    let url_rewrite =
+        if config
+            .dioxus_config
+            .web
+            .watcher
+            .index_on_404
+            .unwrap_or(false)
+        {
+            "True"
+        } else {
+            "False"
+        };
 
     let proxies = config.dioxus_config.web.proxy.as_ref();
 

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(
-        RustlsConfig::from_pem_file(cert_path, key_path).await?,
-    ))
+    Ok(Some(RustlsConfig::from_pem_file(cert_path, key_path).await?))
 }
 
 fn get_rustls_with_mkcert(web_config: &WebHttpsConfig) -> Result<(String, String)> {
@@ -314,10 +312,11 @@ async fn setup_router(
     ));
 
     // Setup routes
-    router = router
-        .route("/_dioxus/hot_reload", get(hot_reload_handler))
-        .layer(cors)
-        .layer(Extension(ws_reload));
+    router =
+        router
+            .route("/_dioxus/hot_reload", get(hot_reload_handler))
+            .layer(cors)
+            .layer(Extension(ws_reload));
 
     if let Some(hot_reload) = hot_reload {
         router = router.layer(Extension(hot_reload))

packages/cli/src/tools.rs

@@ -162,10 +162,11 @@ impl Tool {
                 )
             }
             Self::Tailwind => {
-                let windows_extension = match self.target_platform() {
-                    "windows" => ".exe",
-                    _ => "",
-                };
+                let windows_extension =
+                    match self.target_platform() {
+                        "windows" => ".exe",
+                        _ => "",
+                    };
                 format!(
                     "https://github.com/tailwindlabs/tailwindcss/releases/download/{version}/tailwindcss-{target}-x64{optional_ext}",
                     version = self.tool_version(),
@@ -280,29 +281,30 @@ 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 {
-            Tool::Binaryen => {
-                if cfg!(target_os = "windows") {
-                    format!("{}.exe", command)
-                } else {
-                    command.to_string()
+        let command_file =
+            match self {
+                Tool::Binaryen => {
+                    if cfg!(target_os = "windows") {
+                        format!("{}.exe", command)
+                    } else {
+                        command.to_string()
+                    }
                 }
-            }
-            Tool::Sass => {
-                if cfg!(target_os = "windows") {
-                    format!("{}.bat", command)
-                } else {
-                    command.to_string()
+                Tool::Sass => {
+                    if cfg!(target_os = "windows") {
+                        format!("{}.bat", command)
+                    } else {
+                        command.to_string()
+                    }
                 }
-            }
-            Tool::Tailwind => {
-                if cfg!(target_os = "windows") {
-                    format!("{}.exe", command)
-                } else {
-                    command.to_string()
+                Tool::Tailwind => {
+                    if cfg!(target_os = "windows") {
+                        format!("{}.exe", command)
+                    } else {
+                        command.to_string()
+                    }
                 }
-            }
-        };
+            };
 
         if !bin_path.join(&command_file).is_file() {
             return Err(anyhow::anyhow!("Command file not found."));