chore: fix clippy lints

Author: nik-rev

flake.lock

@@ -1,2 +1,2 @@
-toolchain.channel = "stable"
+toolchain.channel = "1.86"
 toolchain.components = ["rust-analyzer"]

rust-toolchain.toml

@@ -73,7 +73,7 @@ impl SubCommand for BranchFetch {
                         return Err(CliParseError::EmptyArgument(format!(
                             "commit is empty for {arg}"
                         )));
-                    };
+                    }
                     (branch_name, Some(commit))
                 },
                 None => (arg.as_str(), None),

src/cli/branch_fetch.rs

@@ -80,7 +80,7 @@ impl SubCommand for PrFetch {
                     }
                     if custom_repo_name.is_empty() {
                         return Err(CliParseError::EmptyArgument(arg.clone()));
-                    };
+                    }
                     repo_name = Some(custom_repo_name);
                 },
                 Some(LocalFlag::BranchName(custom_branch_name)) => {
@@ -104,7 +104,7 @@ impl SubCommand for PrFetch {
                         Some((pr_number, commit)) => {
                             if commit.is_empty() {
                                 return Err(CliParseError::EmptyCommitHash(arg.clone()));
-                            };
+                            }
                             (parse_pr(pr_number)?, Some(commit))
                         },
                         None => (parse_pr(&arg)?, None),

src/cli/pr_fetch.rs

@@ -45,9 +45,8 @@ pub async fn branch_fetch(args: BranchFetch) -> anyhow::Result<()> {
             },
             Err(err) => {
                 fail!("{err}");
-                continue;
             },
-        };
+        }
     }
 
     Ok(())

src/commands/branch_fetch.rs

@@ -51,7 +51,7 @@ pub fn gen_patch(args: GenPatch) -> anyhow::Result<()> {
         ]) {
             fail!("Could not get patch output for patch {}\n{err}", commit);
             continue;
-        };
+        }
 
         success!(
             "Created patch file at {}",

src/commands/gen_patch.rs

@@ -26,7 +26,7 @@ pub async fn pr_fetch(mut args: PrFetch) -> anyhow::Result<()> {
             let start = GITHUB_REMOTE_PREFIX.len();
             let end = remote.len() - GITHUB_REMOTE_SUFFIX.len();
             args.remote_name = remote.get(start..end).map(Into::into);
-        };
+        }
     }
     let remote_name = args
         .remote_name
@@ -93,9 +93,8 @@ pub async fn pr_fetch(mut args: PrFetch) -> anyhow::Result<()> {
             },
             Err(err) => {
                 fail!("{err}");
-                continue;
             },
-        };
+        }
     }
 
     Ok(())

src/commands/pr_fetch.rs

@@ -59,7 +59,7 @@ pub async fn run(args: Run) -> anyhow::Result<()> {
             if let Err(err) = commands::init() {
                 fail!("{err}");
                 process::exit(1);
-            };
+            }
         } else if args.yes {
             eprintln!(
                 "You can create it with {} {}",
@@ -170,13 +170,11 @@ pub async fn run(args: Run) -> anyhow::Result<()> {
                         },
                         Err(err) => {
                             fail!("{err}");
-                            continue;
                         },
-                    };
+                    }
                 },
                 Err(err) => {
                     fail!("Could not fetch branch from remote\n{err}");
-                    continue;
                 },
             }
         }
@@ -194,7 +192,7 @@ pub async fn run(args: Run) -> anyhow::Result<()> {
             "Could not create directory {}\n{err}",
             CONFIG_ROOT.as_str()
         ));
-    };
+    }
 
     for (file_name, _file, contents) in &backed_up_files {
         restore(file_name, contents).map_err(|err| anyhow!("Could not restore backups:\n{err}"))?;
@@ -213,7 +211,7 @@ pub async fn run(args: Run) -> anyhow::Result<()> {
         if let Err(err) = GIT(&["am", "--keep-cr", "--signoff", &file_name.to_string_lossy()]) {
             GIT(&["am", "--abort"])?;
             return Err(anyhow!("Could not apply patch {patch}, skipping\n{err}"));
-        };
+        }
 
         let last_commit_message = GIT(&["log", "-1", "--format=%B"])?;
         success!(

src/commands/run.rs

@@ -10,6 +10,7 @@
 )]
 use std::path::{Path, PathBuf};
 use std::process::{self, Output};
+use std::sync::LazyLock;
 use std::{env, io};
 
 use anyhow::{Result, anyhow};
@@ -88,13 +89,14 @@ pub fn get_git_root() -> anyhow::Result<PathBuf> {
     get_git_output(&root, &args).map(Into::into)
 }
 
-pub static GIT_ROOT: Lazy<PathBuf> = Lazy::new(|| match get_git_root() {
-    Ok(root) => root,
-    Err(err) => {
-        fail!("Failed to determine Git root directory.\n{err}");
-        process::exit(1)
-    },
-});
+pub static GIT_ROOT: std::sync::LazyLock<PathBuf> =
+    std::sync::LazyLock::new(|| match get_git_root() {
+        Ok(root) => root,
+        Err(err) => {
+            fail!("Failed to determine Git root directory.\n{err}");
+            process::exit(1)
+        },
+    });
 
 type Git = Lazy<Box<dyn Fn(&[&str]) -> Result<String> + Send + Sync>>;
 
@@ -105,7 +107,7 @@ pub static GIT: Git = Lazy::new(|| {
     })
 });
 
-pub static CLIENT: Lazy<Client> = Lazy::new(|| *Box::new(reqwest::Client::new()));
+pub static CLIENT: LazyLock<Client> = LazyLock::new(|| *Box::new(reqwest::Client::new()));
 
 /// Fetches a branch of a remote into local. Optionally accepts a commit hash
 /// for versioning.
@@ -167,7 +169,7 @@ pub fn add_remote_branch(
         })?;
 
         log::trace!("...and did a hard reset to commit {}", commit_hash.as_ref());
-    };
+    }
 
     Ok(())
 }
@@ -195,7 +197,7 @@ pub fn checkout_from_remote(branch: &str, remote: &str) -> anyhow::Result<String
         return Err(anyhow!(
             "Could not checkout branch: {branch}, which belongs to remote {remote}\n{err}"
         ));
-    };
+    }
 
     Ok(current_branch)
 }
@@ -210,7 +212,7 @@ pub fn merge_into_main(
         // nukes the worktree
         GIT(&["reset", "--hard"])?;
         return Err(anyhow!("Could not merge {remote_branch}\n{err}"));
-    };
+    }
 
     // --squash will NOT commit anything. So we need to make it manually
     GIT(&[

src/git_commands.rs

@@ -1,10 +1,9 @@
 #![cfg_attr(doc, doc = include_str!("../docs/README.md"))]
 use core::fmt;
-use std::env;
+use std::{env, sync::LazyLock};
 
 use cli::CliParseError;
 use colored::Colorize as _;
-use once_cell::sync::Lazy;
 
 pub mod backup;
 pub mod cli;
@@ -33,7 +32,7 @@ impl fmt::Display for PatchyError {
 
 impl std::error::Error for PatchyError {}
 
-pub static CONFIG_ROOT: Lazy<String> =
-    Lazy::new(|| env::var("PATCHY_CONFIG_ROOT").unwrap_or_else(|_| ".patchy".into()));
+pub static CONFIG_ROOT: LazyLock<String> =
+    LazyLock::new(|| env::var("PATCHY_CONFIG_ROOT").unwrap_or_else(|_| ".patchy".into()));
 pub const CONFIG_FILE: &str = "config.toml";
 pub const APP_NAME: &str = "patchy";

src/lib.rs

@@ -1,5 +1,6 @@
 use core::error;
 use std::env;
+use std::process::ExitCode;
 
 use patchy::cli::flags::HelpOrVersion;
 use patchy::cli::{Cli, Subcommand};
@@ -15,7 +16,12 @@ async fn main_impl() -> Result<Option<String>, Box<dyn error::Error>> {
         HelpOrVersion::Version => {
             return Ok(Some(env!("CARGO_PKG_VERSION").to_owned()));
         },
-        HelpOrVersion::None => args.subcommand.unwrap(),
+        HelpOrVersion::None if args.subcommand.is_none() => {
+            return Ok(Some(commands::help(args.subcommand)));
+        },
+        HelpOrVersion::None => args
+            .subcommand
+            .expect("checked that we DO have a subcommand in an earlier branch"),
     };
 
     match subcommand {
@@ -32,15 +38,15 @@ async fn main_impl() -> Result<Option<String>, Box<dyn error::Error>> {
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> ExitCode {
     match main_impl().await {
-        Ok(ok) => {
-            println!("{}", ok.unwrap_or_default());
-            std::process::exit(0);
+        Ok(msg) => {
+            println!("{}", msg.unwrap_or_default());
+            ExitCode::SUCCESS
         },
         Err(err) => {
             eprintln!("{err}");
-            std::process::exit(1);
+            ExitCode::FAILURE
         },
     }
 }