merge edition 2018 and other improvements from master
This commit is contained in:
Benjamin Richner
commit
cf7ff173b3
20 changed files with 153 additions and 98 deletions
|
|
@ -1,7 +1,7 @@
|
|||
[package]
|
||||
|
||||
name = "zip"
|
||||
version = "0.5.3"
|
||||
version = "0.5.5"
|
||||
authors = ["Mathijs van de Nes <git@mathijs.vd-nes.nl>"]
|
||||
license = "MIT"
|
||||
repository = "https://github.com/mvdnes/zip-rs.git"
|
||||
|
|
@ -10,6 +10,7 @@ keywords = ["zip", "archive"]
|
|||
description = """
|
||||
Library to support the reading and writing of zip files.
|
||||
"""
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
flate2 = { version = "1.0", default-features = false, optional = true }
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
**Unfortunately, due to a lack of time and loss of interest, this project will no longer be actively maintained.**
|
||||
|
||||
zip-rs
|
||||
======
|
||||
|
||||
|
|
@ -7,6 +9,7 @@ zip-rs
|
|||
|
||||
[Documentation](http://mvdnes.github.io/rust-docs/zip-rs/zip/index.html)
|
||||
|
||||
|
||||
Info
|
||||
----
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,4 @@
|
|||
#[macro_use]
|
||||
extern crate bencher;
|
||||
extern crate rand;
|
||||
extern crate zip;
|
||||
use bencher::{benchmark_group, benchmark_main};
|
||||
|
||||
use std::io::{Cursor, Read, Write};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
extern crate zip;
|
||||
|
||||
use std::io;
|
||||
use std::fs;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
use std::io::prelude::*;
|
||||
|
||||
extern crate zip;
|
||||
|
||||
fn main()
|
||||
{
|
||||
std::process::exit(real_main());
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
extern crate zip;
|
||||
|
||||
use std::fs;
|
||||
use std::io::BufReader;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
extern crate zip;
|
||||
|
||||
use std::io::{self, Read};
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
extern crate zip;
|
||||
extern crate walkdir;
|
||||
|
||||
use std::io::prelude::*;
|
||||
use std::io::{Write, Seek};
|
||||
|
|
@ -48,7 +46,7 @@ fn real_main() -> i32 {
|
|||
return 0;
|
||||
}
|
||||
|
||||
fn zip_dir<T>(it: &mut Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
|
||||
fn zip_dir<T>(it: &mut dyn Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
|
||||
-> zip::result::ZipResult<()>
|
||||
where T: Write+Seek
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,8 +1,6 @@
|
|||
use std::io::prelude::*;
|
||||
use zip::write::FileOptions;
|
||||
|
||||
extern crate zip;
|
||||
|
||||
fn main()
|
||||
{
|
||||
std::process::exit(real_main());
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ impl CompressionMethod {
|
|||
}
|
||||
|
||||
impl fmt::Display for CompressionMethod {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
// Just duplicate what the Debug format looks like, i.e, the enum key:
|
||||
write!(f, "{:?}", self)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
17
src/lib.rs
17
src/lib.rs
|
|
@ -2,19 +2,10 @@
|
|||
|
||||
#![warn(missing_docs)]
|
||||
|
||||
#[cfg(feature = "bzip2")]
|
||||
extern crate bzip2;
|
||||
extern crate crc32fast;
|
||||
#[cfg(feature = "deflate")]
|
||||
extern crate flate2;
|
||||
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;
|
||||
|
|
|
|||
56
src/read.rs
56
src/read.rs
|
|
@ -1,22 +1,20 @@
|
|||
//! Structs for reading a ZIP archive
|
||||
|
||||
use crc32::Crc32Reader;
|
||||
use compression::CompressionMethod;
|
||||
use zipcrypto::ZipCryptoReader;
|
||||
use zipcrypto::ZipCryptoReaderValid;
|
||||
use spec;
|
||||
use result::{ZipResult, ZipError};
|
||||
use crate::crc32::Crc32Reader;
|
||||
use crate::compression::CompressionMethod;
|
||||
use crate::zipcrypto::ZipCryptoReader;
|
||||
use crate::zipcrypto::ZipCryptoReaderValid;
|
||||
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;
|
||||
#[cfg(feature = "deflate")]
|
||||
use flate2::read::DeflateDecoder;
|
||||
|
||||
|
|
@ -66,8 +64,8 @@ pub struct ZipArchive<R: Read + io::Seek>
|
|||
|
||||
enum CryptoReader<'a>
|
||||
{
|
||||
Plaintext(io::Take<&'a mut Read>),
|
||||
ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut Read>>),
|
||||
Plaintext(io::Take<&'a mut dyn Read>),
|
||||
ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut dyn Read>>),
|
||||
}
|
||||
|
||||
impl<'a> Read for CryptoReader<'a> {
|
||||
|
|
@ -82,7 +80,7 @@ impl<'a> Read for CryptoReader<'a> {
|
|||
impl<'a> CryptoReader<'a>
|
||||
{
|
||||
/// Consumes this decoder, returning the underlying reader.
|
||||
pub fn into_inner(self) -> io::Take<&'a mut Read> {
|
||||
pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
|
||||
match self {
|
||||
CryptoReader::Plaintext(r) => r,
|
||||
CryptoReader::ZipCrypto(r) => r.into_inner(),
|
||||
|
|
@ -116,7 +114,7 @@ impl<'a> Read for ZipFileReader<'a> {
|
|||
impl<'a> ZipFileReader<'a>
|
||||
{
|
||||
/// Consumes this decoder, returning the underlying reader.
|
||||
pub fn into_inner(self) -> io::Take<&'a mut Read> {
|
||||
pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
|
||||
match self {
|
||||
ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
|
||||
ZipFileReader::Stored(r) => r.into_inner().into_inner(),
|
||||
|
|
@ -141,9 +139,9 @@ fn unsupported_zip_error<T>(detail: &'static str) -> ZipResult<T>
|
|||
|
||||
|
||||
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>,
|
||||
password: Option<&[u8]>)
|
||||
-> ZipResult<ZipFileReader<'a>> {
|
||||
|
||||
|
|
@ -324,7 +322,17 @@ impl<R: Read+io::Seek> ZipArchive<R>
|
|||
pub fn offset(&self) -> u64 {
|
||||
self.offset
|
||||
}
|
||||
|
||||
|
||||
/// Get the comment of the zip archive.
|
||||
pub fn comment(&self) -> &[u8] {
|
||||
&self.comment
|
||||
}
|
||||
|
||||
/// Returns an iterator over all the file and directory names in this archive.
|
||||
pub fn file_names(&self) -> impl Iterator<Item = &str> {
|
||||
self.names_map.keys().map(|s| s.as_str())
|
||||
}
|
||||
|
||||
/// Search for a file entry by name, decrypt with given password
|
||||
pub fn by_name_decrypt<'a>(&'a mut self, name: &str, password: &[u8]) -> ZipResult<ZipFile<'a>>
|
||||
{
|
||||
|
|
@ -336,7 +344,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
|
|||
{
|
||||
self.by_name_internal(name, None)
|
||||
}
|
||||
|
||||
|
||||
fn by_name_internal<'a>(&'a mut self, name: &str, password: Option<&[u8]>) -> ZipResult<ZipFile<'a>>
|
||||
{
|
||||
let index = match self.names_map.get(name) {
|
||||
|
|
@ -351,7 +359,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
|
|||
{
|
||||
self.by_index_internal(file_number, Some(password))
|
||||
}
|
||||
|
||||
|
||||
/// Get a contained file by index
|
||||
pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>>
|
||||
{
|
||||
|
|
@ -391,8 +399,8 @@ impl<R: Read+io::Seek> ZipArchive<R>
|
|||
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, password)?, data: Cow::Borrowed(data) })
|
||||
}
|
||||
|
||||
|
|
@ -645,7 +653,7 @@ impl<'a> Drop for ZipFile<'a> {
|
|||
/// * `comment`: set to an empty string
|
||||
/// * `data_start`: set to 0
|
||||
/// * `external_attributes`: `unix_mode()`: will return None
|
||||
pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult<Option<ZipFile>> {
|
||||
pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult<Option<ZipFile<'_>>> {
|
||||
let signature = reader.read_u32::<LittleEndian>()?;
|
||||
|
||||
match signature {
|
||||
|
|
@ -712,7 +720,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;
|
||||
|
|
@ -754,7 +762,7 @@ mod test {
|
|||
let mut v = Vec::new();
|
||||
v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
|
||||
let reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
|
||||
assert!(reader.comment == b"zip-rs");
|
||||
assert!(reader.comment() == b"zip-rs");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -33,14 +33,14 @@ pub enum ZipError
|
|||
|
||||
impl ZipError
|
||||
{
|
||||
fn detail(&self) -> ::std::borrow::Cow<str>
|
||||
fn detail(&self) -> ::std::borrow::Cow<'_, str>
|
||||
{
|
||||
use std::error::Error;
|
||||
|
||||
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()
|
||||
|
|
@ -70,7 +70,7 @@ impl convert::From<ZipError> for io::Error
|
|||
|
||||
impl fmt::Display for ZipError
|
||||
{
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error>
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error>
|
||||
{
|
||||
fmt.write_str(&*self.detail())
|
||||
}
|
||||
|
|
@ -82,7 +82,7 @@ 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",
|
||||
|
|
@ -91,11 +91,11 @@ impl error::Error for ZipError
|
|||
}
|
||||
}
|
||||
|
||||
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,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
73
src/types.rs
73
src/types.rs
|
|
@ -111,7 +111,7 @@ impl DateTime {
|
|||
/// Returns `Err` when this object is out of bounds
|
||||
pub fn from_time(tm: ::time::Tm) -> Result<DateTime, ()> {
|
||||
if tm.tm_year >= 80 && tm.tm_year <= 207
|
||||
&& tm.tm_mon >= 1 && tm.tm_mon <= 31
|
||||
&& tm.tm_mon >= 0 && tm.tm_mon <= 11
|
||||
&& tm.tm_mday >= 1 && tm.tm_mday <= 31
|
||||
&& tm.tm_hour >= 0 && tm.tm_hour <= 23
|
||||
&& tm.tm_min >= 0 && tm.tm_min <= 59
|
||||
|
|
@ -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,
|
||||
|
|
@ -333,6 +333,60 @@ mod test {
|
|||
assert!(DateTime::from_date_and_time(2107, 12, 32, 0, 0, 0).is_err());
|
||||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
#[test]
|
||||
fn datetime_from_time_bounds() {
|
||||
use super::DateTime;
|
||||
|
||||
// 1979-12-31 23:59:59
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 59,
|
||||
tm_min: 59,
|
||||
tm_hour: 23,
|
||||
tm_mday: 31,
|
||||
tm_mon: 11, // tm_mon has number range [0, 11]
|
||||
tm_year: 79, // 1979 - 1900 = 79
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_err());
|
||||
|
||||
// 1980-01-01 00:00:00
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 0,
|
||||
tm_min: 0,
|
||||
tm_hour: 0,
|
||||
tm_mday: 1,
|
||||
tm_mon: 0, // tm_mon has number range [0, 11]
|
||||
tm_year: 80, // 1980 - 1900 = 80
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_ok());
|
||||
|
||||
// 2107-12-31 23:59:59
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 59,
|
||||
tm_min: 59,
|
||||
tm_hour: 23,
|
||||
tm_mday: 31,
|
||||
tm_mon: 11, // tm_mon has number range [0, 11]
|
||||
tm_year: 207, // 2107 - 1900 = 207
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_ok());
|
||||
|
||||
// 2108-01-01 00:00:00
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 0,
|
||||
tm_min: 0,
|
||||
tm_hour: 0,
|
||||
tm_mday: 1,
|
||||
tm_mon: 0, // tm_mon has number range [0, 11]
|
||||
tm_year: 208, // 2108 - 1900 = 208
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn time_conversion() {
|
||||
use super::DateTime;
|
||||
|
|
@ -373,4 +427,15 @@ mod test {
|
|||
#[cfg(feature = "time")]
|
||||
assert_eq!(format!("{}", dt.to_time().rfc3339()), "1980-00-00T00:00:00Z");
|
||||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
#[test]
|
||||
fn time_at_january() {
|
||||
use super::DateTime;
|
||||
|
||||
// 2020-01-01 00:00:00
|
||||
let clock = ::time::Timespec::new(1577836800, 0);
|
||||
let tm = ::time::at_utc(clock);
|
||||
assert!(DateTime::from_time(tm).is_ok());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
40
src/write.rs
40
src/write.rs
|
|
@ -1,25 +1,19 @@
|
|||
//! 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::*;
|
||||
use std::mem;
|
||||
#[cfg(feature = "time")]
|
||||
use time;
|
||||
use podio::{WritePodExt, LittleEndian};
|
||||
|
||||
#[cfg(feature = "deflate")]
|
||||
use flate2;
|
||||
#[cfg(feature = "deflate")]
|
||||
use flate2::write::DeflateEncoder;
|
||||
|
||||
#[cfg(feature = "bzip2")]
|
||||
use bzip2;
|
||||
#[cfg(feature = "bzip2")]
|
||||
use bzip2::write::BzEncoder;
|
||||
|
||||
|
|
@ -63,6 +57,7 @@ pub struct ZipWriter<W: Write + io::Seek>
|
|||
files: Vec<ZipFileData>,
|
||||
stats: ZipWriterStats,
|
||||
writing_to_file: bool,
|
||||
comment: String,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
|
|
@ -180,9 +175,15 @@ impl<W: Write+io::Seek> ZipWriter<W>
|
|||
files: Vec::new(),
|
||||
stats: Default::default(),
|
||||
writing_to_file: false,
|
||||
comment: "zip-rs".into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Set ZIP archive comment. Defaults to 'zip-rs' if not set.
|
||||
pub fn set_comment<S>(&mut self, comment: S) where S: Into<String> {
|
||||
self.comment = comment.into();
|
||||
}
|
||||
|
||||
/// Start a new file for with the requested options.
|
||||
fn start_entry<S>(&mut self, name: S, options: FileOptions) -> ZipResult<()>
|
||||
where S: Into<String>
|
||||
|
|
@ -339,7 +340,7 @@ impl<W: Write+io::Seek> ZipWriter<W>
|
|||
number_of_files: self.files.len() as u16,
|
||||
central_directory_size: central_size as u32,
|
||||
central_directory_offset: central_start as u32,
|
||||
zip_file_comment: b"zip-rs".to_vec(),
|
||||
zip_file_comment: self.comment.as_bytes().to_vec(),
|
||||
};
|
||||
|
||||
footer.write(writer)?;
|
||||
|
|
@ -395,13 +396,13 @@ impl<W: Write+io::Seek> GenericZipWriter<W>
|
|||
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,16 +564,17 @@ 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() {
|
||||
let mut writer = ZipWriter::new(io::Cursor::new(Vec::new()));
|
||||
writer.set_comment("ZIP");
|
||||
let result = writer.finish().unwrap();
|
||||
assert_eq!(result.get_ref().len(), 28);
|
||||
assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 122, 105, 112, 45, 114, 115]);
|
||||
assert_eq!(result.get_ref().len(), 25);
|
||||
assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 90, 73, 80]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
extern crate zip;
|
||||
|
||||
use std::io::prelude::*;
|
||||
use zip::write::FileOptions;
|
||||
use std::io::Cursor;
|
||||
use std::iter::FromIterator;
|
||||
use std::collections::HashSet;
|
||||
|
||||
// This test asserts that after creating a zip file, then reading its contents back out,
|
||||
// the extracted data will *always* be exactly the same as the original data.
|
||||
|
|
@ -38,6 +38,11 @@ fn write_to_zip_file(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
|
|||
fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<String> {
|
||||
let mut archive = zip::ZipArchive::new(zip_file).unwrap();
|
||||
|
||||
let expected_file_names = [ "test/", "test/☃.txt", "test/lorem_ipsum.txt" ];
|
||||
let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied());
|
||||
let file_names = archive.file_names().collect::<HashSet<_>>();
|
||||
assert_eq!(file_names, expected_file_names);
|
||||
|
||||
let mut file = archive.by_name("test/lorem_ipsum.txt")?;
|
||||
|
||||
let mut contents = String::new();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
extern crate zip;
|
||||
|
||||
use zip::read::ZipArchive;
|
||||
use std::io::Cursor;
|
||||
|
||||
|
|
|
|||
|
|
@ -53,9 +53,6 @@
|
|||
// 22c400260 00 00 50 4b 05 06 00 00 00 00 03 00 03 00 27 01 |..PK..........'.|
|
||||
// 22c400270 00 00 ff ff ff ff 00 00 |........|
|
||||
// 22c400278
|
||||
|
||||
extern crate zip;
|
||||
|
||||
use std::io::{self, Seek, SeekFrom, Read};
|
||||
|
||||
const BLOCK1_LENGTH : u64 = 0x60;
|
||||
|
|
@ -167,16 +164,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];
|
||||
},
|
||||
_ => {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue