Ran through and fixed clippy lints

src/file.rs

@@ -69,7 +69,7 @@ impl File {
                     Err(Error::InvalidChecksum)
                 }
             }
-            _ => Ok(Self {
+            Checksum::Skip => Ok(Self {
                 len,
                 checksum,
                 data,

src/filetype.rs

@@ -50,8 +50,8 @@ impl From<&FileType> for Flag {
 }
 
 impl Flag {
-    pub(crate) fn append_mode(&self, mode: u16) -> u16 {
+    pub(crate) fn append_mode(self, mode: u16) -> u16 {
-        let mask: u16 = u16::from(*self as u8) << 13;
+        let mask: u16 = u16::from(self as u8) << 13;
         mode | mask
     }
 
@@ -130,7 +130,7 @@ impl FileType {
         match self {
             Self::Normal(f) => f.write(writer)?,
             Self::HardLink(s) | Self::SoftLink(s) => {
-                let len = s.len() as u16;
+                let len = u16::try_from(s.len())?;
                 writer.write_all(&len.to_le_bytes())?;
                 writer.write_all(s.as_bytes())?;
             }

src/lib.rs

@@ -1,3 +1,4 @@
+#![warn(clippy::all, clippy::pedantic)]
 #![doc = include_str!("../README.md")]
 use std::{
     collections::HashMap,
@@ -8,7 +9,7 @@ use std::{
 #[cfg(feature = "parallel")]
 use {
     rayon::prelude::{IntoParallelRefIterator, ParallelIterator},
-    std::{ops::DerefMut, sync::mpsc::Sender},
+    std::sync::mpsc::Sender,
 };
 
 mod checksum;
@@ -36,7 +37,9 @@ pub use stream::Message as StreamMessage;
 pub static MAGIC: [u8; 7] = [0x89, b'h', b'a', b'g', b'g', b'i', b's'];
 
 /// Creates a haggis archive from a list of files
-pub fn create_archive(path: &str, files: Vec<String>, algorithm: Algorithm) -> Result<(), Error> {
+/// # Errors
+/// Returns `crate::Error` if io fails or several other error conditions
+pub fn create_archive(path: &str, files: &[String], algorithm: Algorithm) -> Result<(), Error> {
     let fd = fs::OpenOptions::new()
         .create(true)
         .truncate(true)
@@ -47,16 +50,18 @@ pub fn create_archive(path: &str, files: Vec<String>, algorithm: Algorithm) -> R
 }
 
 /// Streams a haggis archive over something which implements `Write`
+/// # Errors
+/// Returns `crate::Error` if io fails or several other error conditions
 pub fn stream_archive<W: Write>(
     mut writer: W,
-    files: Vec<String>,
+    files: &[String],
     algorithm: Algorithm,
 ) -> Result<(), Error> {
     writer.write_all(&MAGIC)?;
     let len = u32::try_from(files.len())?;
     writer.write_all(&len.to_le_bytes())?;
     let links = Mutex::new(HashMap::new());
-    for f in &files {
+    for f in files {
         let node = Node::from_path(f, algorithm, &links)?;
         node.write(&mut writer)?;
     }
@@ -74,10 +79,12 @@ pub enum Message {
 }
 
 /// Creates a Haggis archive from a list of files, processing each file in parallel
+/// # Errors
+/// Returns `crate::Error` if io fails or several other error conditions
 #[cfg(feature = "parallel")]
 pub fn par_create_archive(
     path: &str,
-    files: Vec<String>,
+    files: &[String],
     algorithm: Algorithm,
     sender: &Sender<Message>,
 ) -> Result<(), Error> {
@@ -88,10 +95,12 @@ pub fn par_create_archive(
 }
 
 /// Streams a Haggis archive from a list of files, processing each file in parallel
+/// # Errors
+/// Returns `crate::Error` if io fails or several other error conditions
 #[cfg(feature = "parallel")]
 pub fn par_stream_archive<W: Write + Send>(
     mut writer: W,
-    files: Vec<String>,
+    files: &[String],
     algorithm: Algorithm,
     sender: &Sender<Message>,
 ) -> Result<(), Error> {
@@ -110,7 +119,7 @@ pub fn par_stream_archive<W: Write + Send>(
             }
         };
         if let Ok(mut writer) = writer.lock() {
-            let mut writer = writer.deref_mut();
+            let mut writer = &mut *writer;
             if let Err(e) = node.write(&mut writer) {
                 s.send(Message::Err(e)).map_err(|_| Error::SenderError)?;
             }

src/nix/mod.rs

@@ -10,6 +10,7 @@ pub fn geteuid() -> u32 {
     unsafe { libc::geteuid() }
 }
 
+#[allow(clippy::similar_names)]
 pub fn chown(path: &str, uid: u32, gid: u32) -> Result<(), Error> {
     let ret = unsafe { libc::chown(CString::new(path)?.as_ptr(), uid, gid) };
     if ret == 0 {

src/node.rs

@@ -26,13 +26,13 @@ impl From<u32> for Kind {
     fn from(value: u32) -> Self {
         if value & 0o40000 != 0 {
             Self::Dir
-        } else if value & 0o20000 != 0 {
+        } else if value & 0o20_000 != 0 {
             Self::Char
-        } else if value & 0o60000 != 0 {
+        } else if value & 0o60_000 != 0 {
             Self::Block
-        } else if value & 0o10000 != 0 {
+        } else if value & 0o10_000 != 0 {
             Self::Pipe
-        } else if value & 0o100000 != 0 {
+        } else if value & 0o100_000 != 0 {
             Self::Normal
         } else {
             unreachable!();
@@ -58,16 +58,19 @@ pub struct Node {
 }
 
 impl Node {
+    #[allow(clippy::similar_names)]
     /// Reads a `Node` from an archive file or stream of Nodes.
     /// > Note: this function reads an already created node. To create a new node
     /// > from a file, use the `from_path` method.
+    /// # Errors
+    /// Returns `crate::Error` if io fails or certain other circumstances
     pub fn read<T: Read>(reader: &mut T) -> Result<Self, Error> {
         let mut len = [0; 2];
         reader.read_exact(&mut len)?;
         let len = u16::from_le_bytes(len);
         if len == 0 {
             return Ok(Self {
-                name: "".to_string(),
+                name: String::new(),
                 mode: 0,
                 uid: 0,
                 gid: 0,
@@ -101,6 +104,8 @@ impl Node {
     /// > Note: this function saves the data to the archive format's on-disk
     /// > representation. To extract the contents of a `Node` and write out the
     /// > file it represents, use the `extract` method instead.
+    /// # Errors
+    /// Returns `crate::Error` if io fails or certain other circumstances
     pub fn write<T: Write>(&self, writer: &mut T) -> Result<(), Error> {
         let len: u16 = self.name.len().try_into()?;
         writer.write_all(&len.to_le_bytes())?;
@@ -114,6 +119,7 @@ impl Node {
         Ok(())
     }
 
+    #[allow(clippy::similar_names)]
     /// Creates a new node from a file which exists on the filesystem
     /// ### Parameters
     /// - path - the path to this file
@@ -122,6 +128,8 @@ impl Node {
     /// - links - this should be passed to each invocation of `from_path` used
     ///   during the creation of a single archive, to identify hard links and to
     ///   avoid writing their data out more than once.
+    /// # Errors
+    /// Returns `crate::Error` if io fails or certain other circumstances
     pub fn from_path(
         path: &str,
         algorithm: Algorithm,
@@ -150,9 +158,8 @@ impl Node {
                         let inode = meta.ino();
                         if let Some(target) = list.get(&inode).cloned() {
                             break 'blk FileType::HardLink(target);
-                        } else {
-                            list.insert(inode, name.clone());
                         }
+                        list.insert(inode, name.clone());
                     }
                 }
                 let kind = Kind::from(mode);
@@ -195,9 +202,8 @@ impl Node {
                         checksum,
                         data,
                     });
-                } else {
-                    return Err(Error::UnknownFileType);
                 }
+                return Err(Error::UnknownFileType);
             }
         };
         let mode = Flag::from(&filetype).append_mode(u16::try_from(mode & 0o7777)?);
@@ -212,15 +218,16 @@ impl Node {
     }
 
     /// Recreates the original file on disk which this node represents
+    /// # Errors
+    /// Returns `crate::Error` if io fails or certain other circumstances
     pub fn extract(&self, prefix: Option<&str>) -> Result<(), Error> {
         let euid = nix::geteuid();
         let path = 'blk: {
             if let Some(prefix) = prefix {
                 if self.name.starts_with('/') {
                     break 'blk format!("{prefix}{}", self.name);
-                } else {
-                    break 'blk format!("{prefix}/{}", self.name);
                 }
+                break 'blk format!("{prefix}/{}", self.name);
             }
             self.name.clone()
         };

src/special.rs

@@ -28,6 +28,7 @@ impl Special {
     }
 
     #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))]
+    #[allow(clippy::cast_possible_truncation)]
     pub(super) fn from_rdev(rdev: u64) -> Self {
         Self {
             major: ((rdev >> 8) & 0xff) as u32,
@@ -36,13 +37,14 @@ impl Special {
     }
 
     #[cfg(target_os = "linux")]
+    #[allow(clippy::cast_possible_truncation)]
     pub(super) fn from_rdev(rdev: u64) -> Self {
         let mut major = 0;
-        major |= (rdev & 0x00000000000fff00) >> 8;
+        major |= (rdev & 0x0000_0000_000f_ff00) >> 8;
-        major |= (rdev & 0xfffff00000000000) >> 32;
+        major |= (rdev & 0xffff_f000_0000_0000) >> 32;
         let mut minor = 0;
-        minor |= rdev & 0x00000000000000ff;
+        minor |= rdev & 0x0000_0000_0000_00ff;
-        minor |= (rdev & 0x00000ffffff00000) >> 12;
+        minor |= (rdev & 0x0000_0fff_fff0_0000) >> 12;
         Self {
             major: major as u32,
             minor: minor as u32,

src/stream.rs

@@ -49,6 +49,9 @@ pub enum Message {
 }
 
 impl<R: Read + Send> Stream<R> {
+    /// Creates a new archive
+    /// # Errors
+    /// Returns `crate::Error` if io fails or several other error conditions
     pub fn new(mut reader: R) -> Result<Self, Error> {
         let mut buf = [0; 11];
         reader.read_exact(&mut buf)?;
@@ -60,6 +63,9 @@ impl<R: Read + Send> Stream<R> {
         }
     }
 
+    /// Extracts and archive
+    /// # Errors
+    /// Returns `crate::Error` if io fails or several other error conditions
     pub fn extract(&mut self, prefix: Option<&str>) -> Result<(), Error> {
         for node in self {
             node?.extract(prefix)?;
@@ -68,6 +74,9 @@ impl<R: Read + Send> Stream<R> {
     }
 
     #[cfg(feature = "parallel")]
+    /// Extracts and archive in parallel
+    /// # Errors
+    /// Returns `crate::Error` if io fails or several other error conditions
     pub fn par_extract(
         &mut self,
         prefix: Option<&str>,