style: fixed all clippy errors

arctic-hen7 · arctic-hen7 · commit f9ce9e0e15f5 · 2023-04-09T11:20:16.000+10:00
This excludes `perseus-rocket`, for now.
diff --git a/examples/core/idb_freezing/src/templates/index.rs b/examples/core/idb_freezing/src/templates/index.rs
@@ -34,7 +34,7 @@ fn index_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a IndexPropsRx) ->
             // The IndexedDB API is asynchronous, so we'll spawn a future
             #[cfg(client)] // The freezing types are only available in the browser
             spawn_local_scoped(cx, async {
-                use perseus::state::{IdbFrozenStateStore, Freeze, PageThawPrefs, ThawPrefs};
+                use perseus::state::{IdbFrozenStateStore, Freeze};
                 // We do this here (rather than when we get the reactor) so that it's updated whenever we press the button
                 let frozen_state = reactor.freeze();
                 let idb_store = match IdbFrozenStateStore::new().await {
@@ -56,7 +56,7 @@ fn index_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a IndexPropsRx) ->
             // The IndexedDB API is asynchronous, so we'll spawn a future
             #[cfg(client)] // The freezing types are only available in the browser
             spawn_local_scoped(cx, async move {
-                use perseus::state::{IdbFrozenStateStore, Freeze, PageThawPrefs, ThawPrefs};
+                use perseus::state::{IdbFrozenStateStore, PageThawPrefs, ThawPrefs};
                 let idb_store = match IdbFrozenStateStore::new().await {
                     Ok(idb_store) => idb_store,
                     Err(_) => {
diff --git a/examples/demos/auth/src/global_state.rs b/examples/demos/auth/src/global_state.rs
@@ -75,7 +75,7 @@ impl AuthDataRx {
         let auth_token = storage.get("username").unwrap(); // This is a `Result<Option<T>, E>`
 
         if let Some(username) = auth_token {
-            self.username.set(username.to_string());
+            self.username.set(username);
             self.state.set(LoginState::Yes);
         } else {
             self.username.set(String::new());
diff --git a/examples/website/state_generation/src/main.rs b/examples/website/state_generation/src/main.rs
@@ -86,9 +86,11 @@ async fn get_build_paths() -> BuildPaths {
 #[derive(thiserror::Error, Debug)]
 #[error(transparent)]
 struct MyError(io::Error);
+#[cfg(engine)]
 fn get_post_for_path(_path: String) -> Result<Post, io::Error> {
     unimplemented!()
 }
+#[cfg(engine)]
 fn parse_markdown(_content: String) -> String {
     unimplemented!()
 }
diff --git a/packages/perseus-cli/src/bin/main.rs b/packages/perseus-cli/src/bin/main.rs
@@ -236,7 +236,7 @@ async fn core(dir: PathBuf) -> Result<i32, Error> {
                 // To allow exclusions to work sanely, we have to manually resolve the file tree
                 if entry.is_dir() {
                     // The `notify` crate internally follows symlinks, so we do here too
-                    for entry in WalkDir::new(&entry).follow_links(true) {
+                    for entry in WalkDir::new(entry).follow_links(true) {
                         let entry = entry
                             .map_err(|err| WatchError::ReadCustomDirEntryFailed { source: err })?;
                         let entry = entry.path();
@@ -296,16 +296,14 @@ async fn core(dir: PathBuf) -> Result<i32, Error> {
                                 })?;
                         }
                     }
-                } else {
-                    if !file_watch_excludes.contains(&entry) {
-                        watcher
-                            // The recursivity flag here will be irrelevant in all cases
-                            .watch(&entry, RecursiveMode::Recursive)
-                            .map_err(|err| WatchError::WatchFileFailed {
-                                filename: entry.to_string_lossy().to_string(),
-                                source: err,
-                            })?;
-                    }
+                } else if !file_watch_excludes.contains(&entry) {
+                    watcher
+                        // The recursivity flag here will be irrelevant in all cases
+                        .watch(&entry, RecursiveMode::Recursive)
+                        .map_err(|err| WatchError::WatchFileFailed {
+                            filename: entry.to_string_lossy().to_string(),
+                            source: err,
+                        })?;
                 }
             }
             // Watch any other files/directories the user has nominated (pre-canonicalized
@@ -314,7 +312,7 @@ async fn core(dir: PathBuf) -> Result<i32, Error> {
                 // To allow exclusions to work sanely, we have to manually resolve the file tree
                 if entry.is_dir() {
                     // The `notify` crate internally follows symlinks, so we do here too
-                    for entry in WalkDir::new(&entry).follow_links(true) {
+                    for entry in WalkDir::new(entry).follow_links(true) {
                         let entry = entry
                             .map_err(|err| WatchError::ReadCustomDirEntryFailed { source: err })?;
                         if entry.path().is_dir() {
@@ -337,16 +335,14 @@ async fn core(dir: PathBuf) -> Result<i32, Error> {
                                 })?;
                         }
                     }
-                } else {
-                    if !file_watch_excludes.contains(&entry) {
-                        watcher
-                            // The recursivity flag here will be irrelevant in all cases
-                            .watch(&entry, RecursiveMode::Recursive)
-                            .map_err(|err| WatchError::WatchFileFailed {
-                                filename: entry.to_string_lossy().to_string(),
-                                source: err,
-                            })?;
-                    }
+                } else if !file_watch_excludes.contains(entry) {
+                    watcher
+                        // The recursivity flag here will be irrelevant in all cases
+                        .watch(entry, RecursiveMode::Recursive)
+                        .map_err(|err| WatchError::WatchFileFailed {
+                            filename: entry.to_string_lossy().to_string(),
+                            source: err,
+                        })?;
                 }
             }
 
@@ -462,8 +458,7 @@ async fn core_watch(dir: PathBuf, opts: Opts) -> Result<i32, Error> {
                 delete_artifacts(dir.clone(), "static")?;
                 delete_artifacts(dir.clone(), "mutable")?;
             }
-            let exit_code = test(dir, &test_opts, &tools, &opts)?;
-            exit_code
+            test(dir, test_opts, &tools, &opts)?
         }
         Subcommand::Clean => {
             delete_dist(dir)?;
diff --git a/packages/perseus-cli/src/deploy.rs b/packages/perseus-cli/src/deploy.rs
@@ -306,7 +306,7 @@ fn minify_js(from: &Path, to: &Path) -> Result<(), DeployError> {
     .map_err(|err| DeployError::MinifyError { source: err })?;
     let minified =
         String::from_utf8(minified).map_err(|err| DeployError::MinifyNotUtf8 { source: err })?;
-    fs::write(to, &minified).map_err(|err| DeployError::WriteMinifiedJsFailed { source: err })?;
+    fs::write(to, minified).map_err(|err| DeployError::WriteMinifiedJsFailed { source: err })?;
 
     Ok(())
 }
diff --git a/packages/perseus-cli/src/serve.rs b/packages/perseus-cli/src/serve.rs
@@ -239,7 +239,7 @@ pub fn serve(
     // rest of the build stage yet
     let sb_thread = build_server(
         dir.clone(),
-        &spinners,
+        spinners,
         num_steps,
         Arc::clone(&exec),
         opts.release,
@@ -250,7 +250,7 @@ pub fn serve(
     if did_build {
         let (sg_thread, wb_thread) = build_internal(
             dir.clone(),
-            &spinners,
+            spinners,
             num_steps,
             opts.release,
             tools,
diff --git a/packages/perseus-cli/src/test.rs b/packages/perseus-cli/src/test.rs
@@ -145,6 +145,6 @@ pub fn test(
         // We've handled errors in the component threads, so the exit code is now zero
         Ok(0)
     } else {
-        Err(ExecutionError::GetServerExecutableFailedSimple.into())
+        Err(ExecutionError::GetServerExecutableFailedSimple)
     }
 }
diff --git a/packages/perseus/src/client.rs b/packages/perseus/src/client.rs
@@ -89,7 +89,9 @@ pub fn run_client<M: MutableStore, T: TranslationsManager>(
     let mut running = true;
     // === IF THIS DISPOSER IS CALLED, PERSEUS WILL TERMINATE! ===
     let app_disposer = create_scope(|cx| {
-        let core = move || {
+        // NOTE: To anyone who ever thinks it might be a good idea to put this whole
+        // thing in a `with_hydration_cx()`, it's not, it's really not.
+        running = {
             // Create the reactor
             match Reactor::try_from(app) {
                 Ok(reactor) => {
@@ -108,10 +110,6 @@ pub fn run_client<M: MutableStore, T: TranslationsManager>(
                 }
             }
         };
-
-        // NOTE: To anyone who ever thinks it might be a good idea to put this whole
-        // thing in a `with_hydration_cx()`, it's not, it's really not.
-        running = core();
     });
 
     dispatch_loaded(running, false);
diff --git a/packages/perseus/src/error_views.rs b/packages/perseus/src/error_views.rs
@@ -50,6 +50,7 @@ pub struct ErrorViews<G: Html> {
     /// place where it can be safely extracted. The replacement function
     /// will panic if called, so this should **never** be manually executed.
     #[cfg(any(client, doc))]
+    #[allow(clippy::type_complexity)]
     panic_handler: Arc<
         dyn Fn(Scope, ClientError, ErrorContext, ErrorPosition) -> (View<SsrNode>, View<G>)
             + Send
@@ -408,6 +409,7 @@ impl<G: Html> ErrorViews<G> {
     /// Extracts the panic handler from within the error views. This should
     /// generally only be called by `PerseusApp`'s error views instantiation
     /// system.
+    #[allow(clippy::type_complexity)]
     pub(crate) fn take_panic_handler(
         &mut self,
     ) -> Arc<
diff --git a/packages/perseus/src/i18n/locale_detector.rs b/packages/perseus/src/i18n/locale_detector.rs
@@ -112,7 +112,7 @@ fn compare_locale<S: Into<String> + std::fmt::Display>(cmp: &str, locales: &[S])
             // Any exact match voids anything after it (it'll be further down the list or
             // only a partial match from here on)
             break;
-        } else if cmp_parts.get(0) == parts.get(0) {
+        } else if cmp_parts.first() == parts.first() {
             // If we've already had a partial match higher up the chain, this is void
             // But we shouldn't break in case there's an exact match coming up
             if !matches!(outcome, LocaleMatch::Language(_)) {
diff --git a/packages/perseus/src/init.rs b/packages/perseus/src/init.rs
@@ -161,13 +161,15 @@ pub struct PerseusAppBase<G: Html, M: MutableStore, T: TranslationsManager> {
     pub(crate) static_dir: String,
     /// A handler for panics on the browser-side.
     #[cfg(any(client, doc))]
+    #[allow(clippy::type_complexity)] // TODO Really?
     pub(crate) panic_handler: Option<Box<dyn Fn(&PanicInfo) + Send + Sync + 'static>>,
     /// A duplicate of the app's error handling function intended for panic
     /// handling. This must be extracted as an owned value and provided in a
     /// thread-safe manner to the panic hook system.
     ///
     /// This is in an `Arc` because panic hooks are `Fn`s, not `FnOnce`s.
     #[cfg(any(client, doc))]
+    #[allow(clippy::type_complexity)]
     pub(crate) panic_handler_view: Arc<
         dyn Fn(Scope, ClientError, ErrorContext, ErrorPosition) -> (View<SsrNode>, View<G>)
             + Send
@@ -1040,6 +1042,7 @@ impl<G: Html, M: MutableStore, T: TranslationsManager> PerseusAppBase<G, M, T> {
     /// If this is called more than once, the view panic handler will panic when
     /// called.
     #[cfg(any(client, doc))]
+    #[allow(clippy::type_complexity)]
     pub fn take_panic_handlers(
         &mut self,
     ) -> (
diff --git a/packages/perseus/src/reactor/error.rs b/packages/perseus/src/reactor/error.rs
@@ -119,6 +119,7 @@ impl Reactor<BrowserNodeType> {
     /// Under absolutely no circumstances should this function **ever** be
     /// called outside a Perseus panic handler set in the entrypoint! It is
     /// exposed for custom entrypoints only.
+    #[allow(clippy::type_complexity)]
     pub fn handle_panic(
         panic_info: &PanicInfo,
         handler: Arc<
diff --git a/packages/perseus/src/reactor/global_state.rs b/packages/perseus/src/reactor/global_state.rs
@@ -183,7 +183,7 @@ impl<G: Html> Reactor<G> {
             match &frozen_app.global_state {
                 FrozenGlobalState::Some(state_str) => {
                     // Deserialize into the unreactive version
-                    let unrx = match serde_json::from_str::<S>(&state_str) {
+                    let unrx = match serde_json::from_str::<S>(state_str) {
                         Ok(unrx) => unrx,
                         // A corrupted frozen state should explicitly bubble up to be an error,
                         // *unless* this is HSR, in which case the data model has just been changed,
diff --git a/packages/perseus/src/reactor/initial_load.rs b/packages/perseus/src/reactor/initial_load.rs
@@ -42,7 +42,7 @@ impl<G: Html> Reactor<G> {
         } else {
             &path
         };
-        let path = js_sys::decode_uri_component(&path)
+        let path = js_sys::decode_uri_component(path)
             .map_err(|_| ClientPlatformError::InitialPath)?
             .as_string()
             .ok_or(ClientPlatformError::InitialPath)?;
@@ -71,7 +71,7 @@ impl<G: Html> Reactor<G> {
                 // whether it's an incremental match or not
                 was_incremental_match: _,
             }) => {
-                let full_path = PathMaybeWithLocale::new(&path, &locale);
+                let full_path = PathMaybeWithLocale::new(path, locale);
                 // Update the router state as we try to load (since this is the initial
                 // view, this will be the first change since the server)
                 self.router_state.set_load_state(RouterLoadState::Loading {
@@ -98,7 +98,7 @@ impl<G: Html> Reactor<G> {
                 // accessed later through the`t!` macro etc.). This locale is guaranteed to
                 // be supported, because it came from a `match_route`.
                 self.translations_manager
-                    .set_translator_for_translations_str(&locale, &translations_str)?;
+                    .set_translator_for_translations_str(locale, &translations_str)?;
 
                 #[cfg(feature = "cache-initial-load")]
                 {
diff --git a/packages/perseus/src/reactor/start.rs b/packages/perseus/src/reactor/start.rs
@@ -148,21 +148,18 @@ impl Reactor<BrowserNodeType> {
             // a `Closure::wrap()` one bit
             let (live_reload_tx, live_reload_rx) = futures::channel::oneshot::channel();
             sycamore_futures::spawn_local_scoped(cx, async move {
-                match live_reload_rx.await {
-                    // This will trigger only once, and then can't be used again
-                    // That shouldn't be a problem, because we'll reload immediately
-                    Ok(_) => {
-                        #[cfg(feature = "hsr")]
-                        {
-                            let frozen_state = self.freeze();
-                            Self::hsr_freeze(frozen_state).await;
-                        }
-                        crate::state::force_reload();
-                        // We shouldn't ever get here unless there was an error,
-                        // the entire page will be fully
-                        // reloaded
+                // This will trigger only once, and then can't be used again
+                // That shouldn't be a problem, because we'll reload immediately
+                if live_reload_rx.await.is_ok() {
+                    #[cfg(feature = "hsr")]
+                    {
+                        let frozen_state = self.freeze();
+                        Self::hsr_freeze(frozen_state).await;
                     }
-                    _ => (),
+                    crate::state::force_reload();
+                    // We shouldn't ever get here unless there was an error,
+                    // the entire page will be fully
+                    // reloaded
                 }
             });
 
diff --git a/packages/perseus/src/reactor/state.rs b/packages/perseus/src/reactor/state.rs
@@ -413,7 +413,7 @@ impl<G: Html> Reactor<G> {
             }
 
             // Get the serialized and unreactive frozen state from the store
-            match frozen_app.state_store.get(&url) {
+            match frozen_app.state_store.get(url) {
                 Some(state_str) => {
                     // Deserialize into the unreactive version
                     let unrx = match serde_json::from_str::<S>(state_str) {
diff --git a/packages/perseus/src/reactor/subsequent_load.rs b/packages/perseus/src/reactor/subsequent_load.rs
@@ -46,7 +46,7 @@ impl<G: Html> Reactor<G> {
                 locale,
                 was_incremental_match,
             }) => {
-                let full_path = PathMaybeWithLocale::new(&path, &locale);
+                let full_path = PathMaybeWithLocale::new(path, locale);
                 // Update the router state
                 self.router_state.set_load_state(RouterLoadState::Loading {
                     template_name: entity.get_path(),
@@ -79,7 +79,7 @@ impl<G: Html> Reactor<G> {
                             Some(page_data_str) => {
                                 // All good, deserialize the page data
                                 let page_data =
-                                    serde_json::from_str::<PageDataPartial>(&page_data_str);
+                                    serde_json::from_str::<PageDataPartial>(page_data_str);
                                 match page_data {
                                     Ok(page_data) => {
                                         // Add the head to the PSS for future use (we make
@@ -147,7 +147,7 @@ impl<G: Html> Reactor<G> {
                 // that means we'll probably get a popup, which is much better UX than an error
                 // page on `/fr-FR/foo` in Spanish.
                 self.translations_manager
-                    .set_translator_for_locale(&locale)
+                    .set_translator_for_locale(locale)
                     .await?;
 
                 let template_name = entity.get_path();
diff --git a/packages/perseus/src/reactor/widget_state.rs b/packages/perseus/src/reactor/widget_state.rs
@@ -33,6 +33,8 @@ impl<G: Html> Reactor<G> {
     /// `.get_unreactive_widget_view()` for widgets that use unreactive
     /// state.
     // HRTB explanation: 'a = 'app, but the compiler hates that.
+    #[allow(clippy::type_complexity)]
+    #[allow(clippy::too_many_arguments)] // Internal function
     pub(crate) fn get_widget_view<'a, S, F, P: Clone + 'static>(
         &'a self,
         app_cx: Scope<'a>,
@@ -157,6 +159,8 @@ impl<G: Html> Reactor<G> {
     ///
     /// This is intended for use with widgets that use unreactive state. See
     /// `.get_widget_view()` for widgets that use reactive state.
+    #[allow(clippy::type_complexity)]
+    #[allow(clippy::too_many_arguments)] // Internal function
     pub(crate) fn get_unreactive_widget_view<'a, F, S, P: Clone + 'static>(
         &'a self,
         app_cx: Scope<'a>,
diff --git a/packages/perseus/src/server/html_shell.rs b/packages/perseus/src/server/html_shell.rs
@@ -350,7 +350,7 @@ impl HtmlShell {
         translations_str: Option<&str>,
     ) -> Self {
         if let Some(locale) = locale {
-            self.locale = locale.to_string();
+            self.locale = locale;
         }
 
         let error = serde_json::to_string(error_page_data).unwrap();
diff --git a/packages/perseus/src/state/rx_result.rs b/packages/perseus/src/state/rx_result.rs
@@ -77,7 +77,7 @@ where
     // very much not okay! (We would have multiple handlers operating on the
     // same fields, which is not a pattern I want to encourage.)
     #[cfg(any(client, doc))]
-    fn compute_suspense<'a>(&self, _cx: Scope<'a>) {}
+    fn compute_suspense(&self, _cx: Scope<'_>) {}
 }
 impl<T, E> Freeze for RxResultRx<T, E>
 where
diff --git a/packages/perseus/src/state/rx_state.rs b/packages/perseus/src/state/rx_state.rs
@@ -82,7 +82,7 @@ pub trait MakeUnrx {
     /// body of this function empty unless you're using the suspended state
     /// system.
     #[cfg(any(client, doc))]
-    fn compute_suspense<'a>(&self, cx: Scope<'a>);
+    fn compute_suspense(&self, cx: Scope<'_>);
 }
 
 /// A trait for reactive `struct`s that can be made unreactive and serialized to
diff --git a/packages/perseus/src/template/core/entity.rs b/packages/perseus/src/template/core/entity.rs
@@ -57,7 +57,8 @@ impl<T: 'static> Deref for Forever<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         match &self {
-            Self::Owned(val) => &val,
+            // Bear in mind that this is implicitly a reference because we're working with `&self`
+            Self::Owned(val) => val,
             Self::StaticRef(val) => val,
         }
     }
diff --git a/packages/perseus/src/template/widget_component.rs b/packages/perseus/src/template/widget_component.rs
diff --git a/packages/perseus/src/turbine/build.rs b/packages/perseus/src/turbine/build.rs
diff --git a/website/src/templates/comparisons.rs b/website/src/templates/comparisons.rs
diff --git a/website/src/templates/docs/container.rs b/website/src/templates/docs/container.rs
diff --git a/website/src/templates/docs/generation.rs b/website/src/templates/docs/generation.rs
diff --git a/website/src/templates/docs/mod.rs b/website/src/templates/docs/mod.rs
diff --git a/website/src/templates/plugins.rs b/website/src/templates/plugins.rs

Original file line number	Diff line number	Diff line change
`@@ -86,9 +86,11 @@ async fn get_build_paths() -> BuildPaths {`
`86`	`86`	`#[derive(thiserror::Error, Debug)]`
`87`	`87`	`#[error(transparent)]`
`88`	`88`	`struct MyError(io::Error);`
	`89`	`+#[cfg(engine)]`
`89`	`90`	`fn get_post_for_path(_path: String) -> Result<Post, io::Error> {`
`90`	`91`	`unimplemented!()`
`91`	`92`	`}`
	`93`	`+#[cfg(engine)]`
`92`	`94`	`fn parse_markdown(_content: String) -> String {`
`93`	`95`	`unimplemented!()`
`94`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -306,7 +306,7 @@ fn minify_js(from: &Path, to: &Path) -> Result<(), DeployError> {`
`306`	`306`	`.map_err(\|err\| DeployError::MinifyError { source: err })?;`
`307`	`307`	`let minified =`
`308`	`308`	`String::from_utf8(minified).map_err(\|err\| DeployError::MinifyNotUtf8 { source: err })?;`
`309`		`- fs::write(to, &minified).map_err(\|err\| DeployError::WriteMinifiedJsFailed { source: err })?;`
	`309`	`+ fs::write(to, minified).map_err(\|err\| DeployError::WriteMinifiedJsFailed { source: err })?;`
`310`	`310`
`311`	`311`	`Ok(())`
`312`	`312`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,6 @@ pub fn test(`
`145`	`145`	`// We've handled errors in the component threads, so the exit code is now zero`
`146`	`146`	`Ok(0)`
`147`	`147`	`} else {`
`148`		`- Err(ExecutionError::GetServerExecutableFailedSimple.into())`
	`148`	`+ Err(ExecutionError::GetServerExecutableFailedSimple)`
`149`	`149`	`}`
`150`	`150`	`}`