v0.3.0 (#5)

Prefer `impl AsRef<Path>`, expose `read` / `seek`, clippy fixes

Author: 0vercl0k

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: 0vercl0k

.github/workflows/kdmp-parser-rs.yml

@@ -57,7 +57,7 @@ jobs:
       - name: cargo clippy
         env:
           RUSTFLAGS: "-Dwarnings"
-        run: cargo clippy --example parser
+        run: cargo clippy --workspace --tests --examples
 
   doc:
     name: doc
@@ -99,18 +99,18 @@ jobs:
       - name: cargo test
         env:
           TESTDATAS: "."
-        run: cargo test
+        run: cargo test --workspace
 
       - name: cargo test release
         env:
           TESTDATAS: "."
-        run: cargo test --release
+        run: cargo test --release --workspace
 
       - name: cargo check
-        run: cargo check
+        run: cargo check --workspace
 
       - name: cargo build
-        run: cargo build --release --example parser
+        run: cargo build --release --examples
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v4

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kdmp-parser"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 authors = ["Axel '0vercl0k' Souchet"]
 categories = ["parser-implementations"]

src/bits.rs

@@ -106,6 +106,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::reversed_empty_ranges)]
     fn invalid_ranges() {
         assert!(std::panic::catch_unwind(|| 1u64.bits(10..=0)).is_err());
         assert!(std::panic::catch_unwind(|| 1u128.bits(0..=128)).is_err());

src/map.rs

@@ -3,7 +3,8 @@
 //! Unix and Windows (cf [`memory_map_file`] / [`unmap_memory_mapped_file`]).
 use std::fmt::Debug;
 use std::io::{Read, Seek};
-use std::{convert, fs, io, path, ptr, slice};
+use std::path::Path;
+use std::{fs, io, ptr, slice};
 
 pub trait Reader: Read + Seek {}
 
@@ -24,10 +25,7 @@ impl<'map> Debug for MappedFileReader<'map> {
 
 impl<'map> MappedFileReader<'map> {
     /// Create a new [`MappedFileReader`] from a path using a memory map.
-    pub fn new<P>(path: P) -> io::Result<Self>
-    where
-        P: convert::AsRef<path::Path>,
-    {
+    pub fn new(path: impl AsRef<Path>) -> io::Result<Self> {
         // Open the file..
         let file = fs::File::open(path)?;
 

src/parse.rs

@@ -332,10 +332,7 @@ impl KernelDumpParser {
         Ok(parser)
     }
 
-    pub fn new<P>(dump_path: &P) -> Result<Self>
-    where
-        P: AsRef<Path>,
-    {
+    pub fn new(dump_path: impl AsRef<Path>) -> Result<Self> {
         // We'll assume that if you are opening a dump file larger than 4gb, you don't
         // want it memory mapped.
         let size = dump_path.as_ref().metadata()?.len();
@@ -612,11 +609,11 @@ impl KernelDumpParser {
         filter_addr_translation_err(self.virt_read_struct::<T>(gva))
     }
 
-    fn seek(&self, pos: io::SeekFrom) -> Result<u64> {
+    pub fn seek(&self, pos: io::SeekFrom) -> Result<u64> {
         Ok(self.reader.borrow_mut().seek(pos)?)
     }
 
-    fn read(&self, buf: &mut [u8]) -> Result<usize> {
+    pub fn read(&self, buf: &mut [u8]) -> Result<usize> {
         Ok(self.reader.borrow_mut().read(buf)?)
     }
 

tests/regression.rs

@@ -28,11 +28,11 @@ struct Module {
     at: Range<Gva>,
 }
 
-impl Into<Module> for M {
-    fn into(self) -> Module {
-        Module {
-            name: self.name,
-            at: hex_str(&self.start).into()..hex_str(&self.end).into(),
+impl From<M> for Module {
+    fn from(value: M) -> Self {
+        Self {
+            name: value.name,
+            at: hex_str(&value.start).into()..hex_str(&value.end).into(),
         }
     }
 }
@@ -78,7 +78,7 @@ fn compare_modules(parser: &KernelDumpParser, modules: &[Module]) -> bool {
         let found_mod = modules.iter().find(|m| m.at == *r).unwrap();
         seen.insert(r.start);
 
-        let filename = name.rsplit_once('\\').map(|(_, s)| s).unwrap_or(&name);
+        let filename = name.rsplit_once('\\').map(|(_, s)| s).unwrap_or(name);
         if filename.to_lowercase() != found_mod.name.to_lowercase() {
             if found_mod.name == "nt" && filename == "ntoskrnl.exe" {
                 continue;