Bumped version and rustfmt 🌈

dafitius · dafitius · commit 64e231c870c4 · 2024-09-07T17:27:28.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rpkg-rs"
-version = "1.1.0"
+version = "1.1.1"
 edition = "2021"
 license = "Apache-2.0"
 categories = ["game-development", "data-structures", "parser-implementations"]
diff --git a/examples/mount_game_files.rs b/examples/mount_game_files.rs
@@ -1,8 +1,8 @@
+use itertools::Itertools;
 use std::io::{stdin, Write};
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::{env, io};
-use itertools::Itertools;
 
 use rpkg_rs::misc::resource_id::ResourceID;
 use rpkg_rs::resource::partition_manager::{PartitionManager, PartitionState};
@@ -64,18 +64,18 @@ fn main() {
             },
         );
 
-        //read the packagedefs here
-        let mut last_index = 0;
-        let mut progress = 0.0;
-        let progress_callback = |current, state: &PartitionState| {
-            if current != last_index {
-                last_index = current;
-                print!("Mounting partition {} ", current);
-            }
-            if !state.installing && !state.mounted {
-                println!("[Failed to mount this partition. Is it installed?]");
-            }
-            let install_progress = (state.install_progress * 10.0).ceil() / 10.0;
+    //read the packagedefs here
+    let mut last_index = 0;
+    let mut progress = 0.0;
+    let progress_callback = |current, state: &PartitionState| {
+        if current != last_index {
+            last_index = current;
+            print!("Mounting partition {} ", current);
+        }
+        if !state.installing && !state.mounted {
+            println!("[Failed to mount this partition. Is it installed?]");
+        }
+        let install_progress = (state.install_progress * 10.0).ceil() / 10.0;
 
         let chars_to_add = (install_progress * 10.0 - progress * 10.0) as usize * 2;
         let chars_to_add = std::cmp::min(chars_to_add, 20);
@@ -124,8 +124,7 @@ fn main() {
         for partition in &package_manager.partitions {
             let mut last_occurence: Option<&ResourceInfo> = None;
 
-            let size =
-                |info: &ResourceInfo| info.compressed_size().unwrap_or(info.size());
+            let size = |info: &ResourceInfo| info.compressed_size().unwrap_or(info.size());
 
             let changes = partition.resource_patch_indices(&rrid);
             let deletions = partition.resource_removal_indices(&rrid);
diff --git a/examples/rebuild_game.rs b/examples/rebuild_game.rs
@@ -67,10 +67,7 @@ fn main() {
             }
 
             builder
-                .build(
-                    package.version(),
-                    output_path.join(&output_name).as_path()
-                )
+                .build(package.version(), output_path.join(&output_name).as_path())
                 .unwrap_or_else(|e| {
                     eprintln!("failed to build package '{}': {}", output_name, e);
                     std::process::exit(0);
diff --git a/src/encryption/xtea.rs b/src/encryption/xtea.rs
@@ -1,7 +1,7 @@
 use crate::encryption::xtea::XteaError::InvalidInput;
+use byteorder::{LittleEndian, WriteBytesExt};
 use extended_tea::XTEA;
 use std::io::Cursor;
-use byteorder::{LittleEndian, WriteBytesExt};
 use thiserror::Error;
 
 /// Errors that can occur during XTEA encryption or decryption.
@@ -17,7 +17,7 @@ pub enum XteaError {
     InvalidInput(String),
 
     #[error("Xtea encoding error: {0}")]
-    XteaEncodingError(std::io::Error)
+    XteaEncodingError(std::io::Error),
 }
 
 /// Implementation of XTEA encryption and decryption methods.
@@ -53,7 +53,7 @@ impl Xtea {
         if !input_buffer.starts_with(&Self::DEFAULT_ENCRYPTED_HEADER) {
             return Err(InvalidInput("Header mismatch".to_string()));
         }
-        let checksum =&input_buffer[payload_start-4..payload_start];
+        let checksum = &input_buffer[payload_start - 4..payload_start];
         let input = &input_buffer[payload_start..];
 
         if input.len() % 8 != 0 {
@@ -71,12 +71,14 @@ impl Xtea {
         xtea.decipher_stream::<LittleEndian, _, _>(&mut input_reader, &mut ouput_writer)
             .map_err(XteaError::CipherError)?;
 
-        let output = String::from_utf8(ouput_writer.get_mut().to_owned()).map_err(XteaError::TextEncodingError)?;
+        let output = String::from_utf8(ouput_writer.get_mut().to_owned())
+            .map_err(XteaError::TextEncodingError)?;
 
-        let result_checksum = crc32fast::hash(output.trim_end_matches('\0').as_bytes()).to_le_bytes();
-        match result_checksum == checksum{
+        let result_checksum =
+            crc32fast::hash(output.trim_end_matches('\0').as_bytes()).to_le_bytes();
+        match result_checksum == checksum {
             true => Ok(output),
-            false => Err(InvalidInput("CRC checksum mismatched!".to_string()))
+            false => Err(InvalidInput("CRC checksum mismatched!".to_string())),
         }
     }
 
@@ -102,8 +104,7 @@ impl Xtea {
         String::from_utf8(ouput_writer.get_mut().to_owned()).map_err(XteaError::TextEncodingError)
     }
 
-    pub fn encrypt_text_file(input_string: String) -> Result<Vec<u8>, XteaError>{
-
+    pub fn encrypt_text_file(input_string: String) -> Result<Vec<u8>, XteaError> {
         //get the input buffer and trim any trailing zeros
         let mut input_buffer = input_string.trim_end_matches('\0').as_bytes().to_vec();
         let checksum = crc32fast::hash(&input_buffer);
@@ -124,7 +125,8 @@ impl Xtea {
         let mut final_buffer = Vec::new();
         final_buffer.extend_from_slice(&Self::DEFAULT_ENCRYPTED_HEADER);
 
-        final_buffer.write_u32::<LittleEndian>(checksum)
+        final_buffer
+            .write_u32::<LittleEndian>(checksum)
             .map_err(XteaError::XteaEncodingError)?;
 
         final_buffer.extend_from_slice(&out_buffer);
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/rpkg-rs/1.1.0")]
+#![doc(html_root_url = "https://docs.rs/rpkg-rs/1.1.1")]
 //! `rpkg-rs` provides comprehensive functionality for interacting with `ResourcePackage` (rpkg) files found within Hitman games.
 //! This crate facilitates parsing of these files, enabling seamless access to the contained resource files.
 //! By parsing configuration files such as `thumbs.ini` and `packagedefintion.txt`, rpkg-rs offers extensive support for reading and manipulating these packages.
diff --git a/src/resource/package_builder.rs b/src/resource/package_builder.rs
@@ -21,7 +21,7 @@ use indexmap::{IndexMap, IndexSet};
 use lzzzz::{lz4, lz4_hc};
 use thiserror::Error;
 
-/// `PackageResourceBlob` is an enum representing various types of package resource stores, which can 
+/// `PackageResourceBlob` is an enum representing various types of package resource stores, which can
 /// include files, file sections, and memory buffers, optionally compressed or scrambled.
 enum PackageResourceBlob {
     File {
@@ -450,8 +450,8 @@ impl PackageBuilder {
         Self {
             partition_id: PartitionId {
                 part_type: match chunk_type {
-                    ChunkType::Standard => { PartitionType::Standard }
-                    ChunkType::Addon => { PartitionType::Addon }
+                    ChunkType::Standard => PartitionType::Standard,
+                    ChunkType::Addon => PartitionType::Addon,
                 },
                 index: chunk_id as usize,
             },
@@ -467,10 +467,7 @@ impl PackageBuilder {
     /// # Arguments
     /// * `partition_id` - The partition id of the package.
     /// * `patch_id` - The patch id of the package.
-    pub fn new_with_patch_id(
-        partition_id: PartitionId,
-        patch_id: PatchId,
-    ) -> Self {
+    pub fn new_with_patch_id(partition_id: PartitionId, patch_id: PatchId) -> Self {
         Self {
             partition_id,
             patch_id,
@@ -498,9 +495,10 @@ impl PackageBuilder {
                     .metadata
                     .as_ref()
                     .map(|m| m.chunk_type)
-                    .unwrap_or_default() {
-                    ChunkType::Standard => { PartitionType::Standard }
-                    ChunkType::Addon => { PartitionType::Addon }
+                    .unwrap_or_default()
+                {
+                    ChunkType::Standard => PartitionType::Standard,
+                    ChunkType::Addon => PartitionType::Addon,
                 },
                 index: resource_package
                     .metadata
@@ -512,9 +510,10 @@ impl PackageBuilder {
                 .metadata
                 .as_ref()
                 .map(|m| m.patch_id)
-                .unwrap_or_default() {
+                .unwrap_or_default()
+            {
                 0 => PatchId::Base,
-                x => PatchId::Patch(x as usize)
+                x => PatchId::Patch(x as usize),
             },
             use_legacy_references: false,
             resources: IndexMap::new(),
@@ -533,7 +532,7 @@ impl PackageBuilder {
                         resource.compressed_size(),
                         resource.is_scrambled(),
                     )
-                        .map_err(|e| PackageBuilderError::CannotDuplicateResource(*rrid, e))?
+                    .map_err(|e| PackageBuilderError::CannotDuplicateResource(*rrid, e))?
                 }
 
                 ResourcePackageSource::Memory(source_data) => {
@@ -557,7 +556,7 @@ impl PackageBuilder {
                         decompressed_size,
                         resource.is_scrambled(),
                     )
-                        .map_err(|e| PackageBuilderError::CannotDuplicateResource(*rrid, e))?
+                    .map_err(|e| PackageBuilderError::CannotDuplicateResource(*rrid, e))?
                 }
             };
 
@@ -625,7 +624,7 @@ impl PackageBuilder {
         data: &T,
     ) -> Result<(), PackageBuilderError>
     where
-            for<'a> T::Args<'a>: Required,
+        for<'a> T::Args<'a>: Required,
     {
         let current_offset = writer
             .stream_position()
@@ -813,12 +812,12 @@ impl PackageBuilder {
                     unknown: 1,
                     chunk_id: self.partition_id.index as u8,
                     chunk_type: match self.partition_id.part_type {
-                        PartitionType::Addon => { ChunkType::Addon }
-                        _ => { ChunkType::Standard }
+                        PartitionType::Addon => ChunkType::Addon,
+                        _ => ChunkType::Standard,
                     },
                     patch_id: match self.patch_id {
-                        PatchId::Base => { 0 }
-                        PatchId::Patch(x) => { x as u8 }
+                        PatchId::Base => 0,
+                        PatchId::Patch(x) => x as u8,
                     },
                     language_tag: *b"xx",
                 }),
@@ -839,7 +838,8 @@ impl PackageBuilder {
             .map_err(PackageBuilderError::SerializationError)?;
 
         let offset_table_result = self.write_offset_table(writer)?;
-        let metadata_table_result = self.write_metadata_table(writer, self.use_legacy_references)?;
+        let metadata_table_result =
+            self.write_metadata_table(writer, self.use_legacy_references)?;
 
         // Now that we're done writing the tables, let's patch the header.
         header.header.offset_table_size = offset_table_result.offset_table_size;
@@ -1014,8 +1014,8 @@ impl PackageBuilder {
         output_path: &Path,
     ) -> Result<(), PackageBuilderError> {
         let output_file = match output_path.is_dir() {
-            true => { output_path.join(self.partition_id.to_filename(self.patch_id)) }
-            false => { output_path.to_path_buf() }
+            true => output_path.join(self.partition_id.to_filename(self.patch_id)),
+            false => output_path.to_path_buf(),
         };
 
         let mut file = File::create(output_file).map_err(PackageBuilderError::IoError)?;
@@ -1028,10 +1028,7 @@ impl PackageBuilder {
     /// * `version` - The version of the package to build.
     /// * `is_patch` - Whether the package is a patch package.
     /// * `legacy_references` - Whether to use the legacy references format.
-    pub fn build_in_memory(
-        self,
-        version: PackageVersion,
-    ) -> Result<Vec<u8>, PackageBuilderError> {
+    pub fn build_in_memory(self, version: PackageVersion) -> Result<Vec<u8>, PackageBuilderError> {
         let mut writer = Cursor::new(vec![]);
         self.build_internal(version, &mut writer)?;
         Ok(writer.into_inner())
diff --git a/src/resource/partition_manager.rs b/src/resource/partition_manager.rs
@@ -279,12 +279,18 @@ impl PartitionManager {
         }
     }
 
-    #[deprecated(since="1.0.0", note="prefer direct access through the partitions field")]
-    pub fn partitions(&self) -> &Vec<ResourcePartition>{
+    #[deprecated(
+        since = "1.0.0",
+        note = "prefer direct access through the partitions field"
+    )]
+    pub fn partitions(&self) -> &Vec<ResourcePartition> {
         &self.partitions
     }
 
-    #[deprecated(since="1.1.0", note="please implement this yourself, it is out of scope for this struct")]
+    #[deprecated(
+        since = "1.1.0",
+        note = "please implement this yourself, it is out of scope for this struct"
+    )]
     pub fn print_resource_changelog(&self, rrid: &RuntimeResourceID) {
         println!("Resource: {rrid}");
 
diff --git a/src/resource/pdefs/mod.rs b/src/resource/pdefs/mod.rs
@@ -10,11 +10,11 @@ use thiserror::Error;
 use crate::encryption::xtea::XteaError;
 use crate::misc::ini_file_system::{IniFileError, IniFileSystem};
 use crate::misc::resource_id::ResourceID;
+use crate::resource::pdefs::GameDiscoveryError::InvalidRuntimePath;
 use crate::resource::pdefs::PackageDefinitionSource::{HM2, HM2016, HM3};
 use crate::resource::pdefs::PartitionType::{Dlc, LanguageDlc, LanguageStandard, Standard};
 use crate::resource::resource_partition::PatchId;
 use crate::{utils, WoaVersion};
-use crate::resource::pdefs::GameDiscoveryError::InvalidRuntimePath;
 
 pub mod h2016_parser;
 pub mod hm2_parser;
@@ -192,34 +192,40 @@ impl PartitionInfo {
         self.id.to_filename(patch_index)
     }
 
-    #[deprecated(since="1.1.0", note="you can push to the roots field directly")]
+    #[deprecated(since = "1.1.0", note = "you can push to the roots field directly")]
     pub fn add_root(&mut self, resource_id: ResourceID) {
         self.roots.push(resource_id);
     }
-    #[deprecated(since="1.1.0", note="prefer direct access through the roots field")]
+    #[deprecated(since = "1.1.0", note = "prefer direct access through the roots field")]
     pub fn roots(&self) -> &Vec<ResourceID> {
         &self.roots
     }
 
-    #[deprecated(since="1.1.0", note="prefer direct access through the name field")]
+    #[deprecated(since = "1.1.0", note = "prefer direct access through the name field")]
     pub fn name(&self) -> &Option<String> {
         &self.name
     }
-    
-    #[deprecated(since="1.1.0", note="prefer direct access through the parent field")]
+
+    #[deprecated(
+        since = "1.1.0",
+        note = "prefer direct access through the parent field"
+    )]
     pub fn parent(&self) -> &Option<PartitionId> {
         &self.parent
     }
 
-    #[deprecated(since="1.1.0", note="prefer direct access through the id field")]
+    #[deprecated(since = "1.1.0", note = "prefer direct access through the id field")]
     pub fn id(&self) -> PartitionId {
         self.id.clone()
     }
-    #[deprecated(since="1.1.0", note="prefer direct access through the patch_level field")]
+    #[deprecated(
+        since = "1.1.0",
+        note = "prefer direct access through the patch_level field"
+    )]
     pub fn max_patch_level(&self) -> usize {
         self.patch_level
     }
-    
+
     pub fn set_max_patch_level(&mut self, patch_level: usize) {
         self.patch_level = patch_level
     }
@@ -293,7 +299,7 @@ pub enum GameDiscoveryError {
 
     #[error("No PROJECT_PATH found in thumbs.dat")]
     NoProjectPath,
-    
+
     #[error("The Runtime path cannot be found")]
     InvalidRuntimePath,
 
@@ -325,11 +331,15 @@ impl GamePaths {
         let mut runtime_path = retail_directory
             .join(project_path.replace("\\", "/"))
             .join(relative_runtime_path);
-        if !runtime_path.exists(){
-            runtime_path = retail_directory.join(project_path.replace("\\", "/")).join(utils::uppercase_first_letter(relative_runtime_path));
+        if !runtime_path.exists() {
+            runtime_path = retail_directory
+                .join(project_path.replace("\\", "/"))
+                .join(utils::uppercase_first_letter(relative_runtime_path));
         }
-        
-        runtime_path = runtime_path.canonicalize().map_err(|_| InvalidRuntimePath)?;
+
+        runtime_path = runtime_path
+            .canonicalize()
+            .map_err(|_| InvalidRuntimePath)?;
         let package_definition_path = runtime_path.join("packagedefinition.txt");
 
         Ok(Self {
diff --git a/src/resource/resource_package.rs b/src/resource/resource_package.rs
diff --git a/src/resource/resource_partition.rs b/src/resource/resource_partition.rs
diff --git a/src/utils.rs b/src/utils.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![doc(html_root_url = "https://docs.rs/rpkg-rs/1.1.0")]`
	`1`	`+#![doc(html_root_url = "https://docs.rs/rpkg-rs/1.1.1")]`
`2`	`2`	//! `rpkg-rs` provides comprehensive functionality for interacting with `ResourcePackage` (rpkg) files found within Hitman games.
`3`	`3`	`//! This crate facilitates parsing of these files, enabling seamless access to the contained resource files.`
`4`	`4`	//! By parsing configuration files such as `thumbs.ini` and `packagedefintion.txt`, rpkg-rs offers extensive support for reading and manipulating these packages.
Original file line number	Diff line number	Diff line change
`@@ -279,12 +279,18 @@ impl PartitionManager {`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`282`		`- #[deprecated(since="1.0.0", note="prefer direct access through the partitions field")]`
`283`		`- pub fn partitions(&self) -> &Vec<ResourcePartition>{`
	`282`	`+ #[deprecated(`
	`283`	`+ since = "1.0.0",`
	`284`	`+ note = "prefer direct access through the partitions field"`
	`285`	`+ )]`
	`286`	`+ pub fn partitions(&self) -> &Vec<ResourcePartition> {`
`284`	`287`	`&self.partitions`
`285`	`288`	`}`
`286`	`289`
`287`		`- #[deprecated(since="1.1.0", note="please implement this yourself, it is out of scope for this struct")]`
	`290`	`+ #[deprecated(`
	`291`	`+ since = "1.1.0",`
	`292`	`+ note = "please implement this yourself, it is out of scope for this struct"`
	`293`	`+ )]`
`288`	`294`	`pub fn print_resource_changelog(&self, rrid: &RuntimeResourceID) {`
`289`	`295`	`println!("Resource: {rrid}");`
`290`	`296`