♻️ Simplify libpna code patterns

- Apply map+transpose to read_entry_slice for consistency
- Extract key_size() helper in write.rs to reduce duplication
- Extract new_link() helper for symlink/hardlink creation

Author: ChanTsune

lib/src/archive/read/slice.rs

@@ -90,11 +90,9 @@ impl<'d> Archive<&'d [u8]> {
     ///
     /// Returns an error if an I/O error occurs while reading from the archive.
     fn read_entry_slice(&mut self) -> io::Result<Option<ReadEntry<Cow<'d, [u8]>>>> {
-        let entry = self.next_raw_item_slice()?;
-        match entry {
-            Some(entry) => Ok(Some(entry.try_into()?)),
-            None => Ok(None),
-        }
+        self.next_raw_item_slice()?
+            .map(TryInto::try_into)
+            .transpose()
     }
 
     /// Returns an iterator over the entries in the archive.

lib/src/entry/builder.rs

@@ -214,6 +214,24 @@ impl EntryBuilder {
         })
     }
 
+    /// Internal helper for creating link entries (symlink or hard link).
+    fn new_link(header: EntryHeader, source: EntryReference) -> io::Result<Self> {
+        let option = WriteOptions::store();
+        let context = get_writer_context(option)?;
+        let mut writer = get_writer(FlattenWriter::new(), &context)?;
+        writer.write_all(source.as_bytes())?;
+        let (iv, phsf) = match context.cipher {
+            None => (None, None),
+            Some(WriteCipher { context: c, .. }) => (Some(c.iv), Some(c.phsf)),
+        };
+        Ok(Self {
+            data: Some(writer),
+            iv,
+            phsf,
+            ..Self::new(header)
+        })
+    }
+
     /// Creates a new symbolic link with the given name and link.
     ///
     /// # Arguments
@@ -242,20 +260,7 @@ impl EntryBuilder {
     /// ```
     #[inline]
     pub fn new_symlink(name: EntryName, source: EntryReference) -> io::Result<Self> {
-        let option = WriteOptions::store();
-        let context = get_writer_context(option)?;
-        let mut writer = get_writer(FlattenWriter::new(), &context)?;
-        writer.write_all(source.as_bytes())?;
-        let (iv, phsf) = match context.cipher {
-            None => (None, None),
-            Some(WriteCipher { context: c, .. }) => (Some(c.iv), Some(c.phsf)),
-        };
-        Ok(Self {
-            data: Some(writer),
-            iv,
-            phsf,
-            ..Self::new(EntryHeader::for_symlink(name))
-        })
+        Self::new_link(EntryHeader::for_symlink(name), source)
     }
 
     /// Creates a new symbolic link with the given name and link.
@@ -306,20 +311,7 @@ impl EntryBuilder {
     /// ```
     #[inline]
     pub fn new_hard_link(name: EntryName, source: EntryReference) -> io::Result<Self> {
-        let option = WriteOptions::store();
-        let context = get_writer_context(option)?;
-        let mut writer = get_writer(FlattenWriter::new(), &context)?;
-        writer.write_all(source.as_bytes())?;
-        let (iv, phsf) = match context.cipher {
-            None => (None, None),
-            Some(WriteCipher { context: c, .. }) => (Some(c.iv), Some(c.phsf)),
-        };
-        Ok(Self {
-            data: Some(writer),
-            iv,
-            phsf,
-            ..Self::new(EntryHeader::for_hard_link(name))
-        })
+        Self::new_link(EntryHeader::for_hard_link(name), source)
     }
 
     /// Sets the creation timestamp of the entry.

lib/src/entry/write.rs

@@ -64,50 +64,36 @@ pub(crate) fn get_writer_context(option: impl WriteOption) -> io::Result<EntryWr
     })
 }
 
+#[inline]
+fn key_size(cipher_algorithm: CipherAlgorithm) -> usize {
+    match cipher_algorithm {
+        CipherAlgorithm::Aes => Aes256::key_size(),
+        CipherAlgorithm::Camellia => Camellia256::key_size(),
+    }
+}
+
 #[inline]
 fn hash<'s, 'p: 's>(
     cipher_algorithm: CipherAlgorithm,
     hash_algorithm: HashAlgorithm,
     password: &'p [u8],
     salt: &'s SaltString,
 ) -> io::Result<(Output, String)> {
-    let mut password_hash = match (hash_algorithm.0, cipher_algorithm) {
-        (
-            HashAlgorithmParams::Argon2Id {
-                time_cost,
-                memory_cost,
-                parallelism_cost,
-            },
-            CipherAlgorithm::Aes,
-        ) => hash::argon2_with_salt(
-            password,
-            argon2::Algorithm::Argon2id,
+    let mut password_hash = match hash_algorithm.0 {
+        HashAlgorithmParams::Argon2Id {
             time_cost,
             memory_cost,
             parallelism_cost,
-            Aes256::key_size(),
-            salt,
-        ),
-        (
-            HashAlgorithmParams::Argon2Id {
-                time_cost,
-                memory_cost,
-                parallelism_cost,
-            },
-            CipherAlgorithm::Camellia,
-        ) => hash::argon2_with_salt(
+        } => hash::argon2_with_salt(
             password,
             argon2::Algorithm::Argon2id,
             time_cost,
             memory_cost,
             parallelism_cost,
-            Camellia256::key_size(),
+            key_size(cipher_algorithm),
             salt,
         ),
-        (
-            HashAlgorithmParams::Pbkdf2Sha256 { rounds },
-            CipherAlgorithm::Aes | CipherAlgorithm::Camellia,
-        ) => {
+        HashAlgorithmParams::Pbkdf2Sha256 { rounds } => {
             let mut params = pbkdf2::Params::default();
             if let Some(rounds) = rounds {
                 params.rounds = rounds;