Merge pull request #55 from Razican/update

Updated packages and formatted. Also fixed 3 warnings.

Author: gnieto

.travis.yml

@@ -24,7 +24,7 @@ rust:
   - nightly
   - beta
   - stable
-  - 1.15.1
+  - 1.20.0
 
 matrix:
   allow_failures:
@@ -52,4 +52,4 @@ notifications:
     recipients:
       - [email protected]
     on_success: change
-    on_failure: always
+    on_failure: always

Cargo.toml

@@ -10,14 +10,14 @@ Parser for resources.arsc contained on APKs and binary XML decompresser
 keywords = ["android", "arsc", "apk", "parser"]
 
 [dependencies]
-byteorder = "^1.0"
-error-chain = "^0.10"
-ansi_term = "^0.9"
-log = "^0.3"
-env_logger = "^0.4"
-zip = { version = "^0.2", optional = true}
-encoding = "^0.2"
-xml-rs = "^0.4"
+byteorder = "1.1"
+error-chain = "0.11"
+ansi_term = "0.10"
+log = "0.3"
+env_logger = "0.4"
+zip = { version = "0.2", optional = true}
+encoding = "0.2"
+xml-rs = "0.6"
 
 [features]
 default = ["zip_decode"]

examples/converter.rs

@@ -60,10 +60,9 @@ fn run() -> Result<()> {
     let mut archive = zip::ZipArchive::new(file).unwrap();
 
     let mut resources_content = Vec::new();
-    archive
-        .by_name("resources.arsc")
-        .unwrap()
-        .read_to_end(&mut resources_content)?;
+    archive.by_name("resources.arsc").unwrap().read_to_end(
+        &mut resources_content,
+    )?;
 
     let mut resources_visitor = ModelVisitor::default();
     Executor::arsc(&resources_content, &mut resources_visitor)?;
@@ -80,8 +79,9 @@ fn run() -> Result<()> {
                 let new_content = xml_content.clone();
 
                 let resources = resources_visitor.get_resources();
-                let out = parse_xml(&new_content, resources)
-                    .chain_err(|| "Could not decode target file")?;
+                let out = parse_xml(&new_content, resources).chain_err(
+                    || "Could not decode target file",
+                )?;
                 println!("{}", out);
             }
         }
@@ -100,8 +100,9 @@ fn parse_xml<'a>(content: &[u8], resources: &'a Resources<'a>) -> Result<String>
         Some(ref root) => {
             match *visitor.get_string_table() {
                 Some(_) => {
-                    return Xml::encode(visitor.get_namespaces(), root)
-                               .chain_err(|| "Could note encode XML");
+                    return Xml::encode(visitor.get_namespaces(), root).chain_err(
+                        || "Could note encode XML",
+                    );
                 }
                 None => {
                     println!("No string table found");

examples/exporter.rs

@@ -52,8 +52,9 @@ fn run() -> Result<()> {
 
     let path = Path::new(&apk_path);
     let mut apk = Apk::new(path).chain_err(|| "Error loading APK")?;
-    apk.export(Path::new(&output), true)
-        .chain_err(|| "APK could not be exported")?;
+    apk.export(Path::new(&output), true).chain_err(
+        || "APK could not be exported",
+    )?;
 
     Ok(())
 }

src/apk.rs

@@ -19,9 +19,9 @@ impl Apk {
         let mut buffer = Vec::new();
         let file = std::fs::File::open(&path)?;
         let mut zip_handler = ZipArchive::new(file)?;
-        zip_handler
-            .by_name("resources.arsc")?
-            .read_to_end(&mut buffer)?;
+        zip_handler.by_name("resources.arsc")?.read_to_end(
+            &mut buffer,
+        )?;
 
         let apk = Apk {
             handler: zip_handler,
@@ -34,40 +34,43 @@ impl Apk {
     /// It exports to target output_path the contents of the APK, transcoding the binary XML files
     /// found on it.
     pub fn export<P: AsRef<Path>>(&mut self, output_path: P, force: bool) -> Result<()> {
-        let decoder = self.decoder
-            .get_decoder()
-            .chain_err(|| "Could not get the decoder")?;
+        let decoder = self.decoder.get_decoder().chain_err(
+            || "Could not get the decoder",
+        )?;
 
         if fs::create_dir_all(&output_path).is_err() && force {
-            fs::remove_dir_all(&output_path)
-                .chain_err(|| {
-                               format!("Could not clean target directory: {}",
-                                       output_path.as_ref().display())
-                           })?;
-            fs::create_dir_all(&output_path)
-                .chain_err(|| {
-                               format!("Error creating the output folder: {}",
-                                       output_path.as_ref().display())
-                           })?;
+            fs::remove_dir_all(&output_path).chain_err(|| {
+                format!(
+                    "Could not clean target directory: {}",
+                    output_path.as_ref().display()
+                )
+            })?;
+            fs::create_dir_all(&output_path).chain_err(|| {
+                format!(
+                    "Error creating the output folder: {}",
+                    output_path.as_ref().display()
+                )
+            })?;
         }
 
         // Iterate over all the files on the ZIP and extract them
         for i in 0..self.handler.len() {
             let (file_name, contents) = {
-                let mut current_file = self.handler
-                    .by_index(i)
-                    .chain_err(|| "Could not read ZIP entry")?;
+                let mut current_file = self.handler.by_index(i).chain_err(
+                    || "Could not read ZIP entry",
+                )?;
                 let mut contents = Vec::new();
-                current_file
-                    .read_to_end(&mut contents)
-                    .chain_err(|| format!("Could not read: {}", current_file.name()))?;
+                current_file.read_to_end(&mut contents).chain_err(|| {
+                    format!("Could not read: {}", current_file.name())
+                })?;
                 let is_xml = current_file.name().to_string();
 
                 (is_xml, contents)
             };
 
             let contents = if (file_name.starts_with("res/") && file_name.ends_with(".xml")) ||
-                              file_name == "AndroidManifest.xml" {
+                file_name == "AndroidManifest.xml"
+            {
 
                 decoder
                     .xml_visitor(&contents)
@@ -86,24 +89,26 @@ impl Apk {
         Ok(())
     }
 
-    fn write_file<B: AsRef<Path>, R: AsRef<Path>>(base_path: B,
-                                                  relative: R,
-                                                  content: &[u8])
-                                                  -> Result<()> {
+    fn write_file<B: AsRef<Path>, R: AsRef<Path>>(
+        base_path: B,
+        relative: R,
+        content: &[u8],
+    ) -> Result<()> {
         let full_path = base_path.as_ref().join(&relative);
         // println!("Full path: {}", full_path.display());
-        fs::create_dir_all(full_path.parent().unwrap())
-            .chain_err(|| "Could not create the output dir")?;
+        fs::create_dir_all(full_path.parent().unwrap()).chain_err(
+            || "Could not create the output dir",
+        )?;
 
         let mut descriptor = fs::OpenOptions::new()
             .write(true)
             .create_new(true)
             .open(full_path)
             .chain_err(|| "Could not open file to write")?;
 
-        descriptor
-            .write_all(content)
-            .chain_err(|| "Could not write to target file")?;
+        descriptor.write_all(content).chain_err(
+            || "Could not write to target file",
+        )?;
 
         Ok(())
     }

src/chunks/chunk_header.rs

@@ -51,12 +51,14 @@ impl ChunkHeader {
 
 impl fmt::Display for ChunkHeader {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f,
-               "(Token:{:X}; Start: {}; Data: {}; End {})",
-               self.chunk_type,
-               self.offset,
-               self.get_data_offset(),
-               self.get_chunk_end())
+        write!(
+            f,
+            "(Token:{:X}; Start: {}; Data: {}; End {})",
+            self.chunk_type,
+            self.offset,
+            self.get_data_offset(),
+            self.get_chunk_end()
+        )
     }
 }
 

src/chunks/resource.rs

@@ -21,11 +21,14 @@ impl<'a> ResourceWrapper<'a> {
         let amount_of_resources = (count / 4) - 2;
 
         if count > self.raw_data.len() as u32 {
-            return Err(format!("There is not enough data on the buffer ({}) to read \
+            return Err(
+                format!(
+                    "There is not enough data on the buffer ({}) to read \
                     the reported resources count ({})",
-                               self.raw_data.len(),
-                               count)
-                               .into());
+                    self.raw_data.len(),
+                    count
+                ).into(),
+            );
         }
 
         let mut resources = Vec::with_capacity(amount_of_resources as usize);
@@ -68,8 +71,10 @@ mod tests {
 
         let result = wrapper.get_resources();
         assert!(result.is_err());
-        assert_eq!("There is not enough data on the buffer (16) to read the \
+        assert_eq!(
+            "There is not enough data on the buffer (16) to read the \
                     reported resources count (255)",
-                   result.err().unwrap().to_string());
+            result.err().unwrap().to_string()
+        );
     }
 }

src/chunks/string_table.rs

@@ -167,8 +167,9 @@ impl<'a> StringTable for StringTableWrapper<'a> {
             return Err("Index out of bounds".into());
         }
 
-        let string = self.get_string_position(idx)
-            .and_then(|position| self.parse_string(position as u32))?;
+        let string = self.get_string_position(idx).and_then(|position| {
+            self.parse_string(position as u32)
+        })?;
 
         Ok(Rc::new(string))
     }

src/chunks/table_type/mod.rs

@@ -44,7 +44,7 @@ impl<'a> TableTypeWrapper<'a> {
         self.decode_entries(&mut cursor)
     }
 
-    fn decode_entries(&self, mut cursor: &mut Cursor<&[u8]>) -> Result<Vec<Entry>> {
+    fn decode_entries(&self, cursor: &mut Cursor<&[u8]>) -> Result<Vec<Entry>> {
         let mut offsets = Vec::new();
         let mut entries = Vec::new();
 
@@ -87,10 +87,11 @@ impl<'a> TableTypeWrapper<'a> {
         }
     }
 
-    fn decode_simple_entry(cursor: &mut Cursor<&[u8]>,
-                           header: &EntryHeader,
-                           id: u32)
-                           -> Result<Option<Entry>> {
+    fn decode_simple_entry(
+        cursor: &mut Cursor<&[u8]>,
+        header: &EntryHeader,
+        id: u32,
+    ) -> Result<Option<Entry>> {
         cursor.read_u16::<LittleEndian>()?;
         // Padding
         cursor.read_u8()?;
@@ -103,10 +104,11 @@ impl<'a> TableTypeWrapper<'a> {
         Ok(Some(entry))
     }
 
-    fn decode_complex_entry(cursor: &mut Cursor<&[u8]>,
-                            header: &EntryHeader,
-                            id: u32)
-                            -> Result<Option<Entry>> {
+    fn decode_complex_entry(
+        cursor: &mut Cursor<&[u8]>,
+        header: &EntryHeader,
+        id: u32,
+    ) -> Result<Option<Entry>> {
         let parent_entry = cursor.read_u32::<LittleEndian>()?;
         let value_count = cursor.read_u32::<LittleEndian>()?;
         let mut entries = Vec::with_capacity(value_count as usize);
@@ -116,10 +118,12 @@ impl<'a> TableTypeWrapper<'a> {
         }
 
         for j in 0..value_count {
-            debug!("Parsing value: {}/{} (@{})",
-                   j,
-                   value_count - 1,
-                   cursor.position());
+            debug!(
+                "Parsing value: {}/{} (@{})",
+                j,
+                value_count - 1,
+                cursor.position()
+            );
             let val_id = cursor.read_u32::<LittleEndian>()?;
             cursor.read_u16::<LittleEndian>()?;
             // Padding
@@ -162,7 +166,8 @@ impl<'a> TableType for TableTypeWrapper<'a> {
         let end = self.data_offset as usize;
 
         if ini > end || (end - ini) <= 28 || self.raw_data.len() < ini ||
-           self.raw_data.len() < end {
+            self.raw_data.len() < end
+        {
             return Err("Configuration slice is not valid".into());
         }
 
@@ -174,9 +179,8 @@ impl<'a> TableType for TableTypeWrapper<'a> {
 
     fn get_entry(&self, index: u32) -> Result<Entry> {
         let entries = self.get_entries()?;
-        entries
-            .get(index as usize)
-            .cloned()
-            .ok_or_else(|| "Entry not found".into())
+        entries.get(index as usize).cloned().ok_or_else(|| {
+            "Entry not found".into()
+        })
     }
 }

src/chunks/table_type_spec.rs

@@ -46,7 +46,9 @@ impl<'a> TypeSpec for TypeSpecWrapper<'a> {
         let amount = self.get_amount()?;
 
         if index >= amount {
-            return Err(format!("Invalid flag on index {} out of {}", index, amount).into());
+            return Err(
+                format!("Invalid flag on index {} out of {}", index, amount).into(),
+            );
         }
 
         let mut cursor = Cursor::new(self.raw_data);
@@ -75,7 +77,9 @@ mod tests {
 
         let errored_flag = wrapper.get_flag(1541);
         assert!(errored_flag.is_err());
-        assert_eq!("Invalid flag on index 1541 out of 1541",
-                   errored_flag.err().unwrap().to_string());
+        assert_eq!(
+            "Invalid flag on index 1541 out of 1541",
+            errored_flag.err().unwrap().to_string()
+        );
     }
 }