Fix Header::filename() method;

TODO: fix other related methods, fix Archive::get() method.

src/tar/header.rs

@@ -117,11 +117,21 @@ impl Default for Header {
 }
 
 impl Header {
+    /// Get the filename of this archive member
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use hpk_package::tar::Header;
+    ///
+    /// let header = Header::new("test/1.txt").unwrap();
+    /// assert_eq!(header.filename().unwrap(), "test/1.txt");
+    /// ```
     pub fn filename(&self) -> Result<String, fmt::Error> {
         let mut s = String::new();
         for c in self.fname {
-            if c != b'\0' {
+            if c != 0 {
-                write!(s, "{c}")?;
+                write!(s, "{}", char::from(c))?;
             } else {
                 break;
             }
@@ -217,6 +227,12 @@ impl Header {
         Ok(s)
     }
 
+    pub fn path(&self) -> Result<PathBuf, fmt::Error> {
+        let mut p = PathBuf::from(&self.prefix()?);
+        p.push(&self.filename()?);
+        Ok(p)
+    }
+
     pub fn new(filename: &str) -> Result<Self, Error> {
         let mut header = Header::default();
         let meta = fs::symlink_metadata(filename)?;

src/tar/mod.rs

@@ -3,6 +3,8 @@ use std::{
     io::{self, BufReader, Write},
 };
 
+use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
+
 mod error;
 mod header;
 mod node;
@@ -27,7 +29,8 @@ impl Archive {
         Ok(buf)
     }
 
-    /// Write out a vector of `TarNodes` to a file or something that implements ``std::io::Write`` and ``std::io::Copy``.
+    /// Write out a vector of `TarNodes` to a file or something that implements
+    /// ``std::io::Write`` and ``std::io::Copy``.
     ///
     /// # Example
     ///
@@ -55,8 +58,8 @@ impl Archive {
         Ok(written)
     }
 
-    /// Create a new `TarFile` struct and initialize it with a `filename` file. This will read in the file to
+    /// Create a new `TarFile` struct and initialize it with a `filename` file.
-    /// the `TarFile` struct as a `TarNode`.
+    /// This will read in the file to the `TarFile` struct as a `TarNode`.
     ///
     /// # Example
     ///
@@ -71,7 +74,8 @@ impl Archive {
         })
     }
 
-    /// Append another file to the `TarFile.file` vector. This adds a file to the internal representation of the tar file.
+    /// Append another file to the `TarFile.file` vector. This adds a file to the
+    /// internal representation of the tar file.
     ///
     /// # Example
     ///
@@ -87,27 +91,41 @@ impl Archive {
         Ok(())
     }
 
-    /// Open and load an external tar file into the internal `TarFile` struct. This parses and loads up all the files
+    /// Open and load an external tar file into the internal `TarFile` struct. This
-    /// contained within the external tar file.
+    /// parses and loads up all the files contained within the external tar file.
     ///
     /// # Example
     ///
     /// ```
     /// use hpk_package::tar::Archive;
     ///
-    /// Archive::open("test/1.tar".to_string()).unwrap();
+    /// Archive::open("test/1.tar").unwrap();
     /// ```
-    pub fn open(filename: String) -> Result<Self, Error> {
+    pub fn open(filename: &str) -> Result<Self, Error> {
-        let file = File::open(&filename)?;
+        let file = File::open(filename)?;
         let mut reader = BufReader::new(file);
+        Self::read(&mut reader)
+    }
+
+    /// Read a tar archive from anything which implements `io::Read`.
+    ///
+    /// # Example
+    /// 
+    /// ```
+    /// use hpk_package::tar::Archive;
+    /// use std::{fs::File, io::BufReader};
+    ///
+    /// let file = File::open("test/1.tar").unwrap();
+    /// let mut reader = BufReader::new(file);
+    /// Archive::read(&mut reader).unwrap();
+    /// ```
+    pub fn read<T: io::Read>(mut input: T) -> Result<Self, Error> {
         let mut out = Self {
             nodes: Vec::<Node>::new(),
         };
-
+        while let Ok(t) = Node::read(&mut input) {
-        while let Ok(t) = Node::read(&mut reader) {
             out.nodes.push(t);
         }
-
         Ok(out)
     }
 
@@ -119,9 +137,9 @@ impl Archive {
     /// use hpk_package::tar::Archive;
     ///
     /// let mut data = Archive::new("test/1.tar").unwrap();
-    /// data.remove("test/1.tar".to_string()).unwrap();
+    /// data.remove("test/1.tar").unwrap();
     /// ```
-    pub fn remove(&mut self, filename: String) -> Result<bool, Error> {
+    pub fn remove(&mut self, filename: &str) -> Result<bool, Error> {
         let mut name = [0u8; 100];
         name[..filename.len()].copy_from_slice(filename.as_bytes());
         if let Some(i) = &self.nodes.iter().position(|x| x.header.fname == name) {
@@ -131,4 +149,25 @@ impl Archive {
 
         Ok(false)
     }
+
+    /// Get the first node from the archive that matches the given filename.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use hpk_package::tar::Archive;
+    /// let archive = Archive::new("test/1.tar").unwrap();
+    /// let node = archive.get("1.txt");
+    /// assert!(node.is_some());
+    /// ```
+    pub fn get(&self, filename: &str) -> Option<Node> {
+        self.nodes.par_iter().find_any(|x| {
+            if let Ok(name) = x.header.filename() {
+                if &name == filename {
+                    return true;
+                }
+            }
+            false
+        }).cloned()
+    }
 }

src/tar/node.rs

@@ -21,7 +21,8 @@ impl Node {
         Ok(buf)
     }
 
-    /// Write out a single file within the tar to a file or something with a ``std::io::Write`` trait.
+    /// Write out a single file within the tar to a file or something with a
+    /// ``std::io::Write`` trait.
     pub fn write<T: io::Write>(self, mut input: T) -> Result<usize, Error> {
         input.write_all(&self.header.to_bytes()?)?;
         let mut written = 512;