WIP restructure

Cargo.lock

@@ -1,4 +1,21 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "byteorder"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "one-rust"
 version = "0.1.0"
+dependencies = [
+ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "prs-rust 0.1.0",
+]
 
+[[package]]
+name = "prs-rust"
+version = "0.1.0"
+
+[metadata]
+"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"

src/main.rs

@@ -1,8 +1,13 @@
+use std::env;
 use std::fs::File;
 
 pub mod one;
 
-fn main() {
-    let mut infile = File::open("foo.one").unwrap();
-    one::OneJod::from_archive(&mut infile).extract();
+fn main() -> std::io::Result<()> {
+    let args: Vec<String> = env::args().collect();
+    for arg in &args[1..] {
+        let mut infile = File::open(arg)?;
+        one::OneJod::from_archive(&mut infile)?.extract()?;
+    }
+    Ok(())
 }

src/one/mod.rs

@@ -1,78 +1,80 @@
 extern crate byteorder;
 extern crate prs_rust;
 
-use self::byteorder::{ReadBytesExt, WriteBytesExt, BigEndian, LittleEndian};
+use self::byteorder::{ReadBytesExt, LittleEndian};
 use self::prs_rust::prs;
-use std::str;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
+use std::str;
 
 pub struct OneJod<R: Read + Seek> {
     read_handle: R,
-    header: OneJodHead,
+    _header: OneJodHead,
     entries: Vec<OneJodEntry>,
 }
 
-impl<R> OneJod<R>
-where
-    R: Read + Seek,
-{
-    pub fn from_archive(mut input: R) -> OneJod<R> {
-        let mut head = OneJodHead {
-            magic: [0; 16],
-            _unknown1: 0,
-            category: [0; 32],
-            file_count: 0,
-            reserved: [0; 128],
+impl<R: Read + Seek> OneJod<R> {
+    pub fn from_archive(mut input: R) -> std::io::Result<OneJod<R>> {
+        let mut magic = [0; 16];
+        input.read_exact(&mut magic)?;
+        let _unknown1 = input.read_u32::<LittleEndian>()?;
+        let mut category = [0; 32];
+        input.read_exact(&mut category)?;
+        let file_count = input.read_u32::<LittleEndian>()?;
+        let mut reserved = [0; 128];
+        input.read_exact(&mut reserved)?;
+        let head = OneJodHead {
+            magic,
+            _unknown1,
+            category,
+            file_count,
+            reserved,
         };
-        input.read_exact(&mut head.magic);
         assert_eq!(head.magic(), b"ThisIsOneFile\0\0\0");
-        head._unknown1 = input.read_u32::<byteorder::LittleEndian>().unwrap();
-        input.read_exact(&mut head.category);
-        head.file_count = input.read_u32::<byteorder::LittleEndian>().unwrap();
-        input.read_exact(&mut head.reserved);
 
         let mut entries = Vec::new();
         for i in 0..head.file_count() {
-            let mut entry = OneJodEntry {
-                _unknown1: 0,
-                id: 0,
-                size_cmp: 0,
-                _unknown2: 0,
-                size_dec: 0,
-                id_again: 0,
-                offset: 0,
-                file_name: [0; 188],
+            let _unknown1 = input.read_u32::<LittleEndian>()?;
+            let id = input.read_u32::<LittleEndian>()?;
+            let size_cmp = input.read_u32::<LittleEndian>()?;
+            let _unknown2 = input.read_u32::<LittleEndian>()?;
+            let size_dec = input.read_u32::<LittleEndian>()?;
+            let id_again = input.read_u32::<LittleEndian>()?;
+            let offset = input.read_u32::<LittleEndian>()?;
+            let mut file_name = [0u8; 188];
+            input.read_exact(&mut file_name)?;
+            let entry = OneJodEntry {
+                _unknown1,
+                id,
+                size_cmp,
+                _unknown2,
+                size_dec,
+                id_again,
+                offset,
+                file_name,
             };
-            entry._unknown1 = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry.id = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry.size_cmp = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry._unknown2 = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry.size_dec = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry.id_again = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            entry.offset = input.read_u32::<byteorder::LittleEndian>().unwrap();
-            input.read_exact(&mut entry.file_name);
             assert_eq!(entry.id(), i);
             entries.push(entry);
         }
 
-        OneJod{
+        Ok(OneJod {
             read_handle: input,
-            header: head,
+            _header: head,
             entries,
-        }
+        })
     }
 
-    pub fn extract(&mut self) {
+    pub fn extract(&mut self) -> std::io::Result<()> {
         for entry in &self.entries {
             let mut cmp_buf = vec![0u8; entry.size_cmp() as usize];
-            self.read_handle.seek(SeekFrom::Start(entry.offset() as u64));
-            self.read_handle.read_exact(cmp_buf.as_mut_slice());
-            let mut dec_buf = prs::decompress::Decompressor::new(&cmp_buf).decompress();
+            self.read_handle.seek(SeekFrom::Start(entry.offset() as u64))?;
+            self.read_handle.read_exact(cmp_buf.as_mut_slice())?;
+            let dec_buf = prs::decompress::Decompressor::new(&cmp_buf).decompress();
             println!("{}", entry.file_name());
             let mut file_out = File::create(entry.file_name()).unwrap();
-            file_out.write_all(&dec_buf);
+            file_out.write_all(&dec_buf)?;
         }
+        Ok(())
     }
 }
 
@@ -84,6 +86,7 @@ struct OneJodHead {
     reserved: [u8; 128],
 }
 
+#[allow(unused)]
 impl OneJodHead {
     fn magic(&self) -> &[u8] { &self.magic }
     fn magic_mut(&mut self) -> &mut [u8] { &mut self.magic }
@@ -114,6 +117,7 @@ struct OneJodEntry {
     file_name: [u8; 188],
 }
 
+#[allow(unused)]
 impl OneJodEntry {
     fn _unknown1(&self) -> u32 { self._unknown1 }
     fn set_unknown1(&mut self, n: u32) { self._unknown1 = n; }