From 99dba6b3975c2df9c9212058bd89574f574b5518 Mon Sep 17 00:00:00 2001 From: Lachezar Lechev Date: Mon, 11 Nov 2019 08:58:59 +0200 Subject: [PATCH] run `cargo fix --edition` --- examples/write_dir.rs | 2 +- src/cp437.rs | 2 +- src/lib.rs | 8 ++++---- src/read.rs | 36 ++++++++++++++++++------------------ src/result.rs | 8 ++++---- src/spec.rs | 2 +- src/types.rs | 6 +++--- src/write.rs | 20 ++++++++++---------- tests/zip64_large.rs | 8 ++++---- 9 files changed, 46 insertions(+), 46 deletions(-) diff --git a/examples/write_dir.rs b/examples/write_dir.rs index fb36ccaf..fb957742 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -48,7 +48,7 @@ fn real_main() -> i32 { return 0; } -fn zip_dir(it: &mut Iterator, prefix: &str, writer: T, method: zip::CompressionMethod) +fn zip_dir(it: &mut dyn Iterator, prefix: &str, writer: T, method: zip::CompressionMethod) -> zip::result::ZipResult<()> where T: Write+Seek { diff --git a/src/cp437.rs b/src/cp437.rs index 69547219..a1ef6d27 100644 --- a/src/cp437.rs +++ b/src/cp437.rs @@ -41,7 +41,7 @@ fn to_char(input: u8) -> char { let output = match input { - 0x00 ... 0x7f => input as u32, + 0x00 ..= 0x7f => input as u32, 0x80 => 0x00c7, 0x81 => 0x00fc, 0x82 => 0x00e9, diff --git a/src/lib.rs b/src/lib.rs index cfe4a598..3de71965 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,10 +11,10 @@ extern crate podio; #[cfg(feature = "time")] extern crate time; -pub use read::ZipArchive; -pub use write::ZipWriter; -pub use compression::CompressionMethod; -pub use types::DateTime; +pub use crate::read::ZipArchive; +pub use crate::write::ZipWriter; +pub use crate::compression::CompressionMethod; +pub use crate::types::DateTime; mod spec; mod crc32; diff --git a/src/read.rs b/src/read.rs index 2eb3d83b..a55e2eb6 100644 --- a/src/read.rs +++ b/src/read.rs @@ -1,17 +1,17 @@ //! Structs for reading a ZIP archive -use crc32::Crc32Reader; -use compression::CompressionMethod; -use spec; -use result::{ZipResult, ZipError}; +use crate::crc32::Crc32Reader; +use crate::compression::CompressionMethod; +use crate::spec; +use crate::result::{ZipResult, ZipError}; use std::io; use std::io::prelude::*; use std::collections::HashMap; use std::borrow::Cow; use podio::{ReadPodExt, LittleEndian}; -use types::{ZipFileData, System, DateTime}; -use cp437::FromCp437; +use crate::types::{ZipFileData, System, DateTime}; +use crate::cp437::FromCp437; #[cfg(feature = "deflate")] use flate2; @@ -64,11 +64,11 @@ pub struct ZipArchive enum ZipFileReader<'a> { NoReader, - Stored(Crc32Reader>), + Stored(Crc32Reader>), #[cfg(feature = "deflate")] - Deflated(Crc32Reader>>), + Deflated(Crc32Reader>>), #[cfg(feature = "bzip2")] - Bzip2(Crc32Reader>>), + Bzip2(Crc32Reader>>), } /// A struct for reading a zip file @@ -84,9 +84,9 @@ fn unsupported_zip_error(detail: &'static str) -> ZipResult fn make_reader<'a>( - compression_method: ::compression::CompressionMethod, + compression_method: crate::compression::CompressionMethod, crc32: u32, - reader: io::Take<&'a mut io::Read>) + reader: io::Take<&'a mut dyn io::Read>) -> ZipResult> { match compression_method { @@ -289,7 +289,7 @@ impl ZipArchive data.data_start = data.header_start + magic_and_header + file_name_length + extra_field_length; self.reader.seek(io::SeekFrom::Start(data.data_start))?; - let limit_reader = (self.reader.by_ref() as &mut Read).take(data.compressed_size); + let limit_reader = (self.reader.by_ref() as &mut dyn Read).take(data.compressed_size); Ok(ZipFile { reader: make_reader(data.compression_method, data.crc32, limit_reader)?, data: Cow::Borrowed(data) }) } @@ -414,20 +414,20 @@ fn parse_extra_field(file: &mut ZipFileData, data: &[u8]) -> ZipResult<()> Ok(()) } -fn get_reader<'a>(reader: &'a mut ZipFileReader) -> &'a mut Read { +fn get_reader<'a>(reader: &'a mut ZipFileReader) -> &'a mut dyn Read { match *reader { ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"), - ZipFileReader::Stored(ref mut r) => r as &mut Read, + ZipFileReader::Stored(ref mut r) => r as &mut dyn Read, #[cfg(feature = "deflate")] - ZipFileReader::Deflated(ref mut r) => r as &mut Read, + ZipFileReader::Deflated(ref mut r) => r as &mut dyn Read, #[cfg(feature = "bzip2")] - ZipFileReader::Bzip2(ref mut r) => r as &mut Read, + ZipFileReader::Bzip2(ref mut r) => r as &mut dyn Read, } } /// Methods for retrieving information on zip files impl<'a> ZipFile<'a> { - fn get_reader(&mut self) -> &mut Read { + fn get_reader(&mut self) -> &mut dyn Read { get_reader(&mut self.reader) } /// Get the version of the file @@ -630,7 +630,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult return unsupported_zip_error("The file length is not available in the local header"); } - let limit_reader = (reader as &'a mut io::Read).take(result.compressed_size as u64); + let limit_reader = (reader as &'a mut dyn io::Read).take(result.compressed_size as u64); let result_crc32 = result.crc32; let result_compression_method = result.compression_method; diff --git a/src/result.rs b/src/result.rs index d82259ea..a7e5d4b0 100644 --- a/src/result.rs +++ b/src/result.rs @@ -34,7 +34,7 @@ impl ZipError match *self { ZipError::Io(ref io_err) => { - ("Io Error: ".to_string() + (io_err as &error::Error).description()).into() + ("Io Error: ".to_string() + (io_err as &dyn error::Error).description()).into() }, ZipError::InvalidArchive(msg) | ZipError::UnsupportedArchive(msg) => { (self.description().to_string() + ": " + msg).into() @@ -76,18 +76,18 @@ impl error::Error for ZipError { match *self { - ZipError::Io(ref io_err) => (io_err as &error::Error).description(), + ZipError::Io(ref io_err) => (io_err as &dyn error::Error).description(), ZipError::InvalidArchive(..) => "Invalid Zip archive", ZipError::UnsupportedArchive(..) => "Unsupported Zip archive", ZipError::FileNotFound => "Specified file not found in archive", } } - fn cause(&self) -> Option<&error::Error> + fn cause(&self) -> Option<&dyn error::Error> { match *self { - ZipError::Io(ref io_err) => Some(io_err as &error::Error), + ZipError::Io(ref io_err) => Some(io_err as &dyn error::Error), _ => None, } } diff --git a/src/spec.rs b/src/spec.rs index 9da07caa..8a165391 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -1,6 +1,6 @@ use std::io; use std::io::prelude::*; -use result::{ZipResult, ZipError}; +use crate::result::{ZipResult, ZipError}; use podio::{ReadPodExt, WritePodExt, LittleEndian}; pub const LOCAL_FILE_HEADER_SIGNATURE : u32 = 0x04034b50; diff --git a/src/types.rs b/src/types.rs index e0ed8006..640e0c52 100644 --- a/src/types.rs +++ b/src/types.rs @@ -202,7 +202,7 @@ pub struct ZipFileData /// True if the file is encrypted. pub encrypted: bool, /// Compression method used to store the file - pub compression_method: ::compression::CompressionMethod, + pub compression_method: crate::compression::CompressionMethod, /// Last modified time. This will only have a 2 second precision. pub last_modified_time: DateTime, /// CRC32 checksum @@ -258,7 +258,7 @@ impl ZipFileData { pub fn version_needed(&self) -> u16 { match self.compression_method { #[cfg(feature = "bzip2")] - ::compression::CompressionMethod::Bzip2 => 46, + crate::compression::CompressionMethod::Bzip2 => 46, _ => 20, } } @@ -283,7 +283,7 @@ mod test { system: System::Dos, version_made_by: 0, encrypted: false, - compression_method: ::compression::CompressionMethod::Stored, + compression_method: crate::compression::CompressionMethod::Stored, last_modified_time: DateTime::default(), crc32: 0, compressed_size: 0, diff --git a/src/write.rs b/src/write.rs index 5e4c223f..c08472e0 100644 --- a/src/write.rs +++ b/src/write.rs @@ -1,10 +1,10 @@ //! Structs for creating a new zip archive -use compression::CompressionMethod; -use types::{ZipFileData, System, DEFAULT_VERSION, DateTime}; -use spec; +use crate::compression::CompressionMethod; +use crate::types::{ZipFileData, System, DEFAULT_VERSION, DateTime}; +use crate::spec; use crc32fast::Hasher; -use result::{ZipResult, ZipError}; +use crate::result::{ZipResult, ZipError}; use std::default::Default; use std::io; use std::io::prelude::*; @@ -395,13 +395,13 @@ impl GenericZipWriter Ok(()) } - fn ref_mut(&mut self) -> Option<&mut Write> { + fn ref_mut(&mut self) -> Option<&mut dyn Write> { match *self { - GenericZipWriter::Storer(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Storer(ref mut w) => Some(w as &mut dyn Write), #[cfg(feature = "deflate")] - GenericZipWriter::Deflater(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Deflater(ref mut w) => Some(w as &mut dyn Write), #[cfg(feature = "bzip2")] - GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut dyn Write), GenericZipWriter::Closed => None, } } @@ -563,9 +563,9 @@ fn path_to_string(path: &std::path::Path) -> String { mod test { use std::io; use std::io::Write; - use types::DateTime; + use crate::types::DateTime; use super::{FileOptions, ZipWriter}; - use compression::CompressionMethod; + use crate::compression::CompressionMethod; #[test] fn write_empty_zip() { diff --git a/tests/zip64_large.rs b/tests/zip64_large.rs index d10c91e8..6aeeedfb 100644 --- a/tests/zip64_large.rs +++ b/tests/zip64_large.rs @@ -167,16 +167,16 @@ impl Read for Zip64File { return Ok(0); } match self.pointer { - BLOCK1_START ... BLOCK1_END => { + BLOCK1_START ..= BLOCK1_END => { buf[0] = BLOCK1[(self.pointer - BLOCK1_START) as usize]; }, - BLOCK2_START ... BLOCK2_END => { + BLOCK2_START ..= BLOCK2_END => { buf[0] = BLOCK2[(self.pointer - BLOCK2_START) as usize]; }, - BLOCK3_START ... BLOCK3_END => { + BLOCK3_START ..= BLOCK3_END => { buf[0] = BLOCK3[(self.pointer - BLOCK3_START) as usize]; }, - BLOCK4_START ... BLOCK4_END => { + BLOCK4_START ..= BLOCK4_END => { buf[0] = BLOCK4[(self.pointer - BLOCK4_START) as usize]; }, _ => {