fix: clean up code and improve clippy lints and formatting consistency

Ozy-Viking · Ozy-Viking · commit 2e8cea350f8b · 2025-08-06T10:38:13.000+10:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -1,3 +1,3 @@
 {
-  "rust-analyzer.cargo.features": "all"
+  "rust-analyzer.cargo.features": []
 }
diff --git a/src/bin/cargo_uv.rs b/src/bin/cargo_uv.rs
@@ -10,7 +10,7 @@ fn main() -> Result<()> {
     setup_tracing(&cli_args)?;
 
     let packages = Packages::from(cli_args.get_metadata()?);
-    let mut tasks = Tasks::generate_tasks(&mut cli_args, packages)?;
+    let mut tasks = Tasks::generate_tasks(&cli_args, packages)?;
 
     tasks = tasks.run_all(&cli_args)?.join_all()?;
     tracing::info!("Completed run, starting cleanup");
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
@@ -1,4 +1,5 @@
 mod action;
+#[allow(clippy::module_inception)]
 mod cli;
 mod git_ops;
 mod manifest;
diff --git a/src/cli/workspace.rs b/src/cli/workspace.rs
@@ -5,7 +5,7 @@ use std::collections::HashSet;
 
 use tracing::{instrument, trace};
 
-use crate::{Package, PackageName, Packages, ReadToml, Result, cli::WORKSPACE_HEADER};
+use crate::{Package, PackageName, Packages, ReadToml, Result, SplitVec, cli::WORKSPACE_HEADER};
 
 /// Cargo flags for selecting crates in a workspace.
 #[derive(Default, Clone, Debug, PartialEq, Eq, clap::Args)]
@@ -43,7 +43,7 @@ impl Workspace {
     pub fn partition_packages<'m>(
         &self,
         packages: &'m Packages,
-    ) -> Result<(Vec<&'m Package<ReadToml>>, Vec<&'m Package<ReadToml>>)> {
+    ) -> Result<SplitVec<&'m Package<ReadToml>>> {
         let selection = PackagesCli::from_flags(
             self.workspace,
             self.default_members,
@@ -74,7 +74,7 @@ impl Workspace {
     pub fn partition_packages_owned(
         &self,
         packages: &Packages,
-    ) -> Result<(Vec<Package<ReadToml>>, Vec<Package<ReadToml>>)> {
+    ) -> Result<SplitVec<Package<ReadToml>>> {
         self.partition_packages(packages).map(|(i, e)| {
             (
                 i.into_iter().cloned().collect(),
@@ -86,10 +86,7 @@ impl Workspace {
     pub fn partition_packages_mut<'m>(
         &self,
         packages: &'m mut Packages,
-    ) -> Result<(
-        Vec<&'m mut Package<ReadToml>>,
-        Vec<&'m mut Package<ReadToml>>,
-    )> {
+    ) -> Result<SplitVec<&'m mut Package<ReadToml>>> {
         let packages_clone = packages.clone();
         let selection = PackagesCli::from_flags(
             self.workspace,
diff --git a/src/git/branch.rs b/src/git/branch.rs
@@ -58,7 +58,7 @@ impl Display for Branch {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let text = match self {
             Branch::Current => ".",
-            Branch::Named { local, .. } => &local,
+            Branch::Named { local, .. } => local,
         };
 
         write!(f, "{text}")
diff --git a/src/git/git.rs b/src/git/git.rs
@@ -6,15 +6,15 @@ use std::{
 };
 
 use indexmap::IndexSet;
-use miette::{Context, bail};
+use miette::bail;
 use semver::Version;
 use tracing::{debug, info, instrument, warn};
 
+#[cfg(feature = "unstable")]
+use miette::Context;
+
 use crate::{
-    Branch, Process, ProcessOutput, Result, Task,
-    cli::{Cli, Suppress},
-    current_span,
-    git::git_file::GitFiles,
+    Branch, Process, ProcessOutput, Result, cli::Suppress, current_span, git::git_file::GitFiles,
     process::OutputExt,
 };
 
@@ -172,7 +172,7 @@ impl Git<PathBuf> {
             git.arg("--dry-run");
         }
 
-        git.args(["--message", &message]);
+        git.args(["--message", message]);
         let cmd = Process::display_command(&git);
         let run = Process::Output.run(git)?;
         let output = run.as_output().unwrap();
diff --git a/src/git/git_file.rs b/src/git/git_file.rs
@@ -2,7 +2,6 @@ use std::{path::PathBuf, str::FromStr, vec::IntoIter};
 
 use tracing::instrument;
 
-#[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub struct GitFile {
     pub mode: String,
diff --git a/src/lib.rs b/src/lib.rs
@@ -32,6 +32,8 @@ use tracing_subscriber::util::SubscriberInitExt;
 /// Footer for the [miette::MietteHandler]
 pub static FOOTER: &str = "If the bug continues, raise an issue on github: https://github.com/Ozy-Viking/cargo_update_version/issues";
 
+pub type SplitVec<T> = (Vec<T>, Vec<T>);
+
 pub fn setup_tracing(args: &Cli) -> miette::Result<()> {
     let app_level = match args.tracing_level() {
         Some(l) => l,
diff --git a/src/manifest/error.rs b/src/manifest/error.rs
@@ -30,7 +30,6 @@ impl Display for CargoFileError {
     }
 }
 
-// #[allow(dead_code)]
 #[derive(Debug, thiserror::Error, miette::Diagnostic)]
 pub enum CargoFileErrorKind {
     #[error("No root package")]
diff --git a/src/manifest/toml_file.rs b/src/manifest/toml_file.rs
@@ -110,43 +110,46 @@ impl CargoFile<ReadToml> {
     }
     #[instrument(skip_all)]
     pub fn get_package_version(&self) -> Option<Version> {
-        VersionLocation::Package.get_version(&self).ok()
+        VersionLocation::Package.get_version(self).ok()
     }
     #[instrument(skip_all)]
     pub fn get_workspace_version(&self) -> Option<Version> {
-        VersionLocation::WorkspacePackage.get_version(&self).ok()
+        VersionLocation::WorkspacePackage.get_version(self).ok()
     }
 
     #[track_caller]
     #[instrument(skip(self))]
+    #[allow(clippy::result_large_err)]
     pub fn set_package_version(
         &mut self,
         new_version: &Version,
     ) -> miette::Result<(), CargoFileError> {
         VersionLocation::Package
             .set_version(self, new_version)
             .map_err(|e: VersionlocationError| {
-                let path = (&e).path().to_path_buf();
+                let path = e.path().to_path_buf();
                 CargoFileErrorKind::LocationError(e).to_error(path)
             })
     }
 
     #[track_caller]
     #[instrument(skip(self))]
+    #[allow(clippy::result_large_err)]
     pub fn set_workspace_version(
         &mut self,
         new_version: &Version,
     ) -> miette::Result<(), CargoFileError> {
         VersionLocation::WorkspacePackage
             .set_version(self, new_version)
             .map_err(|e: VersionlocationError| {
-                let path = (&e).path().to_path_buf();
+                let path = e.path().to_path_buf();
                 CargoFileErrorKind::LocationError(e).to_error(path)
             })
     }
 
     #[track_caller]
     #[instrument(skip(self))]
+    #[allow(clippy::result_large_err)]
     pub fn set_version(&mut self, new_version: Version) -> miette::Result<(), CargoFileError> {
         tracing::warn!("set version start");
         let cargo_path = self.path().to_path_buf();
diff --git a/src/manifest/version_location.rs b/src/manifest/version_location.rs
@@ -4,7 +4,7 @@ use semver::Version;
 use tracing::{info, instrument, trace};
 
 use crate::{
-    CargoFile, ReadToml, current_span,
+    CargoFile, ReadToml, current_span, display_path,
     manifest::error::{ItemType, VersionlocationError},
 };
 
@@ -127,15 +127,15 @@ impl VersionLocation {
         };
         let version = ret?;
         current_span!().record("path", path.as_os_str().to_str().unwrap_or_default());
-        current_span!().record("version", &version.to_string());
+        current_span!().record("version", version.to_string());
         info!("Version found");
 
         Ok(version)
     }
 
     #[track_caller]
     #[instrument(skip_all, fields(version, path))]
-    pub fn set_version<'a>(
+    pub fn set_version(
         &self,
         cargo_toml: &mut CargoFile<ReadToml>,
         version: &Version,
@@ -171,7 +171,10 @@ impl VersionLocation {
                     ErrKind::NotFound(*self),
                     Some("Package table located."),
                 ))? {
-                    toml_edit::Item::Value(value) => Ok(*value = version.to_string().into()),
+                    toml_edit::Item::Value(value) => {
+                        *value = version.to_string().into();
+                        Ok(())
+                    }
                     item => Err(set_err(
                         ErrKind::ItemInvalid(item.into()),
                         Some("Invalid itemtype for setting package version."),
@@ -186,7 +189,7 @@ impl VersionLocation {
                 let ws_kind = ItemType::from(&*workspace);
                 let workspace = workspace.as_table_mut().ok_or_else(|| {
                     set_err(
-                        ErrKind::ItemInvalid(ws_kind.into()),
+                        ErrKind::ItemInvalid(ws_kind),
                         Some("Tried to get package table"),
                     )
                 })?;
@@ -197,24 +200,27 @@ impl VersionLocation {
 
                 let package = package.as_table_mut().ok_or_else(|| {
                     set_err(
-                        ErrKind::ItemInvalid(pack_kind.into()),
+                        ErrKind::ItemInvalid(pack_kind),
                         Some("Tried to get package table"),
                     )
                 })?;
                 match package.get_mut("version").ok_or(set_err(
                     ErrKind::NotFound(*self),
                     Some("Package table located."),
                 ))? {
-                    toml_edit::Item::Value(value) => Ok(*value = version.to_string().into()),
+                    toml_edit::Item::Value(value) => {
+                        *value = version.to_string().into();
+                        Ok(())
+                    }
                     item => Err(set_err(
                         ErrKind::ItemInvalid(item.into()),
                         Some("Invalid itemtype for setting workspace version."),
                     )),
                 }
             }
         };
-        let _version = ret?;
-        current_span!().record("path", (&path).as_os_str().to_str().unwrap_or_default());
+        ret?;
+        current_span!().record("path", display_path!(path).to_string());
         info!("Version set: {version}");
         Ok(())
     }
diff --git a/src/packages/mod.rs b/src/packages/mod.rs
@@ -4,6 +4,7 @@ pub use package_name::PackageName;
 mod package;
 pub use package::Package;
 
+#[allow(clippy::module_inception)]
 mod packages;
 pub use packages::Packages;
 
diff --git a/src/packages/package.rs b/src/packages/package.rs
@@ -81,7 +81,7 @@ impl From<cargo_metadata::Package> for Package<ReadToml> {
             version: meta_package.version,
             version_type: Package::set_version_type(&cargo_file)
                 .expect("Cargo manifest run with no error"),
-            cargo_file: cargo_file,
+            cargo_file,
             manifest_path,
         }
     }
diff --git a/src/packages/packages.rs b/src/packages/packages.rs
@@ -12,7 +12,7 @@ use semver::Version;
 use tracing::{debug, instrument};
 
 use super::{Package, PackageError, PackageName};
-use crate::{ReadToml, Result, VersionLocation, VersionLocationErrorKind, display_path};
+use crate::{ReadToml, Result, VersionLocation, display_path};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Packages {
diff --git a/src/process.rs b/src/process.rs
@@ -4,7 +4,6 @@ use tracing::instrument;
 use crate::{Result, current_span};
 use std::process::{Child, Command, Output};
 
-#[allow(dead_code)]
 pub trait OutputExt {
     fn stderr(&self) -> String;
     fn stdout(&self) -> String;
diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs
@@ -1,5 +1,6 @@
 mod predict_tasks;
 pub use predict_tasks::DisplayTasks;
+#[allow(clippy::module_inception)]
 mod tasks;
 pub use tasks::Tasks;
 mod task;
diff --git a/src/tasks/predict_tasks.rs b/src/tasks/predict_tasks.rs
@@ -1,6 +1,6 @@
 use std::{env::current_dir, fmt::Display, path::PathBuf};
 
-use miette::{IntoDiagnostic, ensure, miette};
+use miette::{IntoDiagnostic, ensure};
 
 use crate::{Action, Bumpable, Cli, PackageName, Packages, Result, Task, Tasks, VersionType};
 #[cfg(feature = "unstable")]
@@ -19,7 +19,7 @@ impl Displayable for DisplayTasks<'_> {}
 
 impl<'a> DisplayTasks<'a> {
     pub fn new(tasks: &'a Tasks) -> Self {
-        Self { tasks: tasks }
+        Self { tasks }
     }
 
     pub fn display(&self) -> Result<()> {
@@ -65,7 +65,7 @@ impl Display for DisplayTasks<'_> {
         let tasks = self.tasks();
         let last = tasks.last().expect("No way to have 0 tasks");
         for (idx, task) in tasks.iter().enumerate() {
-            let s = if &task == &last {
+            let s = if task == last {
                 self.task_item_string_last(idx + 1, task)
             } else {
                 self.task_item_string(idx + 1, task)
@@ -78,23 +78,21 @@ impl Display for DisplayTasks<'_> {
 }
 
 impl<'a> Tasks {
-    #[allow(unused_variables)]
     /// Generate tasks from user defined [Cli] arguments.
     pub fn generate_tasks(cli_args: &'a Cli, packages: Packages) -> Result<Self> {
         cli_args.try_allow_dirty()?;
         let cwd = current_dir().into_diagnostic()?;
         let root_cargo_lock = packages.root_cargo_lock_path().to_path_buf();
-        let root_manifest_path = packages.root_manifest_path().to_path_buf();
-        let packages_clone = packages.clone();
         let mut tasks = Tasks::new(packages);
         let git = cli_args.git()?;
+        #[cfg(feature = "unstable")]
         let git_files = git.dirty_files()?;
-        let cargo = cli_args.cargo()?;
         let workspace = cli_args.workspace();
         let pre_release = cli_args.pre();
         let build = cli_args.build();
         let force_version = cli_args.force_version();
 
+        #[cfg(feature = "unstable")]
         let current_branch = git.current_branch()?;
         #[cfg(feature = "unstable")]
         let mut git_stash = None;
@@ -160,7 +158,10 @@ impl<'a> Tasks {
         }
 
         if change_workspace_package_version {
-            let workspace_package = tasks.packages_mut().workspace_package_mut().ok_or(miette::miette!("workspace.pa"))?;
+            let workspace_package = tasks
+                .packages_mut()
+                .workspace_package_mut()
+                .ok_or(miette::miette!("workspace.pa"))?;
             let ws_name = workspace_package.name().clone();
             let mut new_version = workspace_package.version_owned();
 
@@ -204,7 +205,7 @@ impl<'a> Tasks {
                 for remote in git.remotes()? {
                     tasks.insert(
                         Task::GitPush {
-                            remote: remote,
+                            remote,
                             #[cfg(feature = "unstable")]
                             branch: cli_args.git_branch(),
                             tag: new_version.to_string(),
@@ -233,12 +234,12 @@ impl<'a> Tasks {
         #[cfg(feature = "unstable")]
         if let Some(Task::GitStash {
             branch,
-            stash: state,
+            stash: _stash,
         }) = git_stash
         {
             tasks.insert(
                 Task::GitStash {
-                    branch: branch,
+                    branch,
                     stash: Stash::Unstash,
                 },
                 None,
diff --git a/src/tasks/task.rs b/src/tasks/task.rs
diff --git a/src/tasks/tasks.rs b/src/tasks/tasks.rs
diff --git a/src/version.rs b/src/version.rs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`{`
`2`		`- "rust-analyzer.cargo.features": "all"`
	`2`	`+ "rust-analyzer.cargo.features": []`
`3`	`3`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`mod action;`
	`2`	`+#[allow(clippy::module_inception)]`
`2`	`3`	`mod cli;`
`3`	`4`	`mod git_ops;`
`4`	`5`	`mod manifest;`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,6 @@ impl Display for CargoFileError {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`-// #[allow(dead_code)]`
`34`	`33`	`#[derive(Debug, thiserror::Error, miette::Diagnostic)]`
`35`	`34`	`pub enum CargoFileErrorKind {`
`36`	`35`	`#[error("No root package")]`