feat: add strict clippy lints rules (#10)

I renamed `_spawn_and_stream` to `spawn_and_stream()` as an underscore in front
of a method name typically indicates that a variable or function is not used.
However, this is not the case here.

For more info, see this clippy lint documentation:
https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_items

Author: mre

Cargo.toml

@@ -22,3 +22,38 @@ serde = { version = "1.0", features = ["derive"], optional = true }
 [features]
 default = []
 serde = ["dep:serde"]
+
+[lints.clippy]
+all = "deny"
+pedantic = "deny"
+nursery = "deny"
+match_same_arms = { level = "allow", priority = 1 }
+
+[lints.rust]
+# Groups
+warnings = "deny"
+future-incompatible = "deny"
+nonstandard-style = "deny"
+rust-2018-idioms = "deny"
+rust-2021-compatibility = "deny"
+rust-2024-compatibility = "deny"
+unused = "deny"
+
+# Individual lints that deserve special attention
+invalid-html-tags = "deny"
+absolute-paths-not-starting-with-crate = "deny"
+anonymous-parameters = "deny"
+macro-use-extern-crate = "deny"
+missing-copy-implementations = "deny"
+missing-debug-implementations = "deny"
+missing-docs = "deny"
+semicolon-in-expressions-from-macros = "deny"
+unreachable-pub = "deny"
+variant-size-differences = "deny"
+unsafe-code = "deny"
+invalid-value = "deny"
+missing-abi = "deny"
+large-assignments = "deny"
+explicit-outlives-requirements = "deny"
+trivial-casts = "deny"
+trivial-numeric-casts = "deny"

src/item.rs

@@ -17,9 +17,9 @@ impl Deref for ProcessItem {
 
     fn deref(&self) -> &Self::Target {
         match self {
-            ProcessItem::Output(s) => s,
-            ProcessItem::Error(s) => s,
-            ProcessItem::Exit(s) => s,
+            Self::Output(s) => s,
+            Self::Error(s) => s,
+            Self::Exit(s) => s,
         }
     }
 }
@@ -54,23 +54,23 @@ impl ProcessItem {
     ///
     /// [`Output`]: ProcessItem::Output
     #[must_use]
-    pub fn is_output(&self) -> bool {
+    pub const fn is_output(&self) -> bool {
         matches!(self, Self::Output(..))
     }
 
     /// Returns `true` if the process item is [`Error`].
     ///
     /// [`Error`]: ProcessItem::Error
     #[must_use]
-    pub fn is_error(&self) -> bool {
+    pub const fn is_error(&self) -> bool {
         matches!(self, Self::Error(..))
     }
 
     /// Returns `true` if the process item is [`Exit`].
     ///
     /// [`Exit`]: ProcessItem::Exit
     #[must_use]
-    pub fn is_exit(&self) -> bool {
+    pub const fn is_exit(&self) -> bool {
         matches!(self, Self::Exit(..))
     }
 
@@ -83,7 +83,8 @@ impl ProcessItem {
     }
 
     /// Return exit code if [`ProcessItem`] is [`ProcessItem::Exit`]
-    pub fn as_exit(&self) -> Option<&String> {
+    #[must_use]
+    pub const fn as_exit(&self) -> Option<&String> {
         if let Self::Exit(v) = self {
             Some(v)
         } else {
@@ -92,7 +93,8 @@ impl ProcessItem {
     }
 
     /// Return inner reference [`String`] value if [`ProcessItem`] is [`ProcessItem::Error`]
-    pub fn as_error(&self) -> Option<&String> {
+    #[must_use]
+    pub const fn as_error(&self) -> Option<&String> {
         if let Self::Error(v) = self {
             Some(v)
         } else {
@@ -101,7 +103,8 @@ impl ProcessItem {
     }
 
     /// Return inner reference [`String`] value if [`ProcessItem`] is [`ProcessItem::Output`]
-    pub fn as_output(&self) -> Option<&String> {
+    #[must_use]
+    pub const fn as_output(&self) -> Option<&String> {
         if let Self::Output(v) = self {
             Some(v)
         } else {

src/lib.rs

@@ -36,7 +36,7 @@ pub use futures::TryStreamExt;
 pub use item::ProcessItem;
 pub use tokio_stream;
 
-/// ProcessExt trait that needs to be implemented to make something streamable
+/// `ProcessExt` trait that needs to be implemented to make something streamable
 pub trait ProcessExt {
     /// Get command that will be used to create a child process from
     fn get_command(&mut self) -> &mut Command;
@@ -58,12 +58,25 @@ pub trait ProcessExt {
     }
 
     /// Spawn and stream process
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the process fails to spawn
     fn spawn_and_stream(&mut self) -> Result<ProcessStream> {
-        self._spawn_and_stream()
+        self.spawn_and_stream_inner()
     }
 
-    /// Spawn and stream process (avoid custom implementation, use spawn_and_stream instead)
-    fn _spawn_and_stream(&mut self) -> Result<ProcessStream> {
+    /// # Errors
+    ///
+    /// Will return an error if the process fails to spawn.
+    ///
+    /// # Panics
+    ///
+    /// Panics if:
+    /// - `stdout` or `stderr` is not available in the spawned child process (should not happen if
+    ///   proper pipes are set up with `get_stdout()` and `get_stderr()`)
+    #[allow(tail_expr_drop_order)]
+    fn spawn_and_stream_inner(&mut self) -> Result<ProcessStream> {
         let abort = Arc::new(Notify::new());
 
         let mut child = self.command().spawn()?;
@@ -79,7 +92,7 @@ pub trait ProcessExt {
         let mut std_stream = tokio_stream::StreamExt::merge(stdout_stream, stderr_stream);
         let stream = stream! {
             loop {
-                use ProcessItem::*;
+                use ProcessItem::{Error, Exit};
                 tokio::select! {
                     Some(output) = std_stream.next() => yield output,
                     status = child.wait() => {
@@ -98,11 +111,11 @@ pub trait ProcessExt {
                         }
                         break;
                     },
-                    _ = abort.notified() => {
+                    () = abort.notified() => {
                         match child.start_kill() {
                             Ok(()) => yield Exit("0".into()),
                             Err(err) => yield Error(format!("abort Process Error: {err}")),
-                        };
+                        }
                         break;
                     }
                 }
@@ -136,6 +149,7 @@ pub trait ProcessExt {
 }
 
 /// Thin Wrapper around [`Command`] to make it streamable
+#[derive(Debug)]
 pub struct Process {
     inner: Command,
     stdin: Option<ChildStdin>,
@@ -155,7 +169,7 @@ impl ProcessExt for Process {
     }
 
     fn set_aborter(&mut self, aborter: Option<Arc<Notify>>) {
-        self.abort = aborter
+        self.abort = aborter;
     }
 
     fn take_stdin(&mut self) -> Option<ChildStdin> {
@@ -273,7 +287,7 @@ impl From<&PathBuf> for Process {
     }
 }
 
-/// Convert std_stream to a stream of T
+/// Convert `std_stream` to a stream of T
 pub fn into_stream<T, R>(std: R, is_stdout: bool) -> impl Stream<Item = T>
 where
     T: From<(bool, Result<String>)>,