Merge pull request #500 from sbruton/master

fix for zip v2.6 semver violation

Author: tafia

Cargo.toml

@@ -22,7 +22,7 @@ fast-float2 = "0.2"
 log = "0.4"
 serde = "1.0"
 quick-xml = { version = "0.37", features = ["encoding"] }
-zip = { version = "~2.5.0", default-features = false, features = ["deflate"] }
+zip = { version = "2.6", default-features = false, features = ["deflate"] }
 chrono = { version = "0.4", features = [
     "serde",
 ], optional = true, default-features = false }

src/ods.rs

@@ -21,7 +21,7 @@ use std::marker::PhantomData;
 
 const MIMETYPE: &[u8] = b"application/vnd.oasis.opendocument.spreadsheet";
 
-type OdsReader<'a> = XmlReader<BufReader<ZipFile<'a>>>;
+type OdsReader<'a, RS> = XmlReader<BufReader<ZipFile<'a, RS>>>;
 
 /// An enum for ods specific errors
 #[derive(Debug)]
@@ -387,7 +387,10 @@ fn parse_content<RS: Read + Seek>(mut zip: ZipArchive<RS>) -> Result<Content, Od
     })
 }
 
-fn read_table(reader: &mut OdsReader<'_>) -> Result<(Range<Data>, Range<String>), OdsError> {
+fn read_table<RS>(reader: &mut OdsReader<'_, RS>) -> Result<(Range<Data>, Range<String>), OdsError>
+where
+    RS: Read + Seek,
+{
     let mut cells = Vec::new();
     let mut rows_repeats = Vec::new();
     let mut formulas = Vec::new();
@@ -531,13 +534,16 @@ fn get_range<T: Default + Clone + PartialEq>(
     }
 }
 
-fn read_row(
-    reader: &mut OdsReader<'_>,
+fn read_row<RS>(
+    reader: &mut OdsReader<'_, RS>,
     row_buf: &mut Vec<u8>,
     cell_buf: &mut Vec<u8>,
     cells: &mut Vec<Data>,
     formulas: &mut Vec<String>,
-) -> Result<(), OdsError> {
+) -> Result<(), OdsError>
+where
+    RS: Read + Seek,
+{
     let mut empty_col_repeats = 0;
     loop {
         row_buf.clear();
@@ -595,11 +601,14 @@ fn read_row(
 /// Converts table-cell element into a `Data`
 ///
 /// ODF 1.2-19.385
-fn get_datatype(
-    reader: &mut OdsReader<'_>,
+fn get_datatype<RS>(
+    reader: &mut OdsReader<'_, RS>,
     atts: Attributes<'_>,
     buf: &mut Vec<u8>,
-) -> Result<(Data, String, bool), OdsError> {
+) -> Result<(Data, String, bool), OdsError>
+where
+    RS: Read + Seek,
+{
     let mut is_string = false;
     let mut is_value_set = false;
     let mut val = Data::Empty;
@@ -697,7 +706,12 @@ fn get_datatype(
     }
 }
 
-fn read_named_expressions(reader: &mut OdsReader<'_>) -> Result<Vec<(String, String)>, OdsError> {
+fn read_named_expressions<RS>(
+    reader: &mut OdsReader<'_, RS>,
+) -> Result<Vec<(String, String)>, OdsError>
+where
+    RS: Read + Seek,
+{
     let mut defined_names = Vec::new();
     let mut buf = Vec::with_capacity(512);
     loop {

src/xlsb/cells_reader.rs

@@ -1,3 +1,5 @@
+use std::io::{Read, Seek};
+
 use crate::{
     datatype::DataRef,
     formats::{format_excel_f64_ref, CellFormat},
@@ -8,8 +10,11 @@ use crate::{
 use super::{cell_format, parse_formula, wide_str, RecordIter};
 
 /// A cells reader for xlsb files
-pub struct XlsbCellsReader<'a> {
-    iter: RecordIter<'a>,
+pub struct XlsbCellsReader<'a, RS>
+where
+    RS: Read + Seek,
+{
+    iter: RecordIter<'a, RS>,
     formats: &'a [CellFormat],
     strings: &'a [String],
     extern_sheets: &'a [String],
@@ -21,9 +26,12 @@ pub struct XlsbCellsReader<'a> {
     buf: Vec<u8>,
 }
 
-impl<'a> XlsbCellsReader<'a> {
+impl<'a, RS> XlsbCellsReader<'a, RS>
+where
+    RS: Read + Seek,
+{
     pub(crate) fn new(
-        mut iter: RecordIter<'a>,
+        mut iter: RecordIter<'a, RS>,
         formats: &'a [CellFormat],
         strings: &'a [String],
         extern_sheets: &'a [String],

src/xlsb/mod.rs

@@ -408,7 +408,7 @@ impl<RS: Read + Seek> Xlsb<RS> {
     pub fn worksheet_cells_reader<'a>(
         &'a mut self,
         name: &str,
-    ) -> Result<XlsbCellsReader<'a>, XlsbError> {
+    ) -> Result<XlsbCellsReader<'a, RS>, XlsbError> {
         let path = match self.sheets.iter().find(|&(n, _)| n == name) {
             Some((_, path)) => path.clone(),
             None => return Err(XlsbError::WorksheetNotFound(name.into())),
@@ -608,16 +608,19 @@ impl<RS: Read + Seek> ReaderRef<RS> for Xlsb<RS> {
     }
 }
 
-pub(crate) struct RecordIter<'a> {
+pub(crate) struct RecordIter<'a, RS>
+where
+    RS: Read + Seek,
+{
     b: [u8; 1],
-    r: BufReader<ZipFile<'a>>,
+    r: BufReader<ZipFile<'a, RS>>,
 }
 
-impl<'a> RecordIter<'a> {
-    fn from_zip<RS: Read + Seek>(
-        zip: &'a mut ZipArchive<RS>,
-        path: &str,
-    ) -> Result<RecordIter<'a>, XlsbError> {
+impl<'a, RS> RecordIter<'a, RS>
+where
+    RS: Read + Seek,
+{
+    fn from_zip(zip: &'a mut ZipArchive<RS>, path: &str) -> Result<RecordIter<'a, RS>, XlsbError> {
         match zip.by_name(path) {
             Ok(f) => Ok(RecordIter {
                 r: BufReader::new(f),

src/xlsx/cells_reader.rs

@@ -2,7 +2,11 @@ use quick_xml::{
     events::{attributes::Attribute, BytesStart, Event},
     name::QName,
 };
-use std::{borrow::Borrow, collections::HashMap};
+use std::{
+    borrow::Borrow,
+    collections::HashMap,
+    io::{Read, Seek},
+};
 
 use super::{
     get_attribute, get_dimension, get_row, get_row_column, read_string, replace_cell_names,
@@ -17,8 +21,11 @@ use crate::{
 type FormulaMap = HashMap<(u32, u32), (i64, i64)>;
 
 /// An xlsx Cell Iterator
-pub struct XlsxCellReader<'a> {
-    xml: XlReader<'a>,
+pub struct XlsxCellReader<'a, RS>
+where
+    RS: Read + Seek,
+{
+    xml: XlReader<'a, RS>,
     strings: &'a [String],
     formats: &'a [CellFormat],
     is_1904: bool,
@@ -30,9 +37,12 @@ pub struct XlsxCellReader<'a> {
     formulas: Vec<Option<(String, FormulaMap)>>,
 }
 
-impl<'a> XlsxCellReader<'a> {
+impl<'a, RS> XlsxCellReader<'a, RS>
+where
+    RS: Read + Seek,
+{
     pub fn new(
-        mut xml: XlReader<'a>,
+        mut xml: XlReader<'a, RS>,
         strings: &'a [String],
         formats: &'a [CellFormat],
         is_1904: bool,
@@ -281,14 +291,17 @@ impl<'a> XlsxCellReader<'a> {
     }
 }
 
-fn read_value<'s>(
+fn read_value<'s, RS>(
     strings: &'s [String],
     formats: &[CellFormat],
     is_1904: bool,
-    xml: &mut XlReader<'_>,
+    xml: &mut XlReader<'_, RS>,
     e: &BytesStart<'_>,
     c_element: &BytesStart<'_>,
-) -> Result<DataRef<'s>, XlsxError> {
+) -> Result<DataRef<'s>, XlsxError>
+where
+    RS: Read + Seek,
+{
     Ok(match e.local_name().as_ref() {
         b"is" => {
             // inlineStr
@@ -385,7 +398,10 @@ fn read_v<'s>(
     }
 }
 
-fn read_formula(xml: &mut XlReader, e: &BytesStart) -> Result<Option<String>, XlsxError> {
+fn read_formula<RS>(xml: &mut XlReader<RS>, e: &BytesStart) -> Result<Option<String>, XlsxError>
+where
+    RS: Read + Seek,
+{
     match e.local_name().as_ref() {
         b"is" | b"v" => {
             xml.read_to_end_into(e.name(), &mut Vec::new())?;

src/xlsx/mod.rs

@@ -23,7 +23,7 @@ use crate::{
 };
 pub use cells_reader::XlsxCellReader;
 
-pub(crate) type XlReader<'a> = XmlReader<BufReader<ZipFile<'a>>>;
+pub(crate) type XlReader<'a, RS> = XmlReader<BufReader<ZipFile<'a, RS>>>;
 
 /// Maximum number of rows allowed in an xlsx file
 pub const MAX_ROWS: u32 = 1_048_576;
@@ -905,7 +905,7 @@ impl<RS: Read + Seek> Xlsx<RS> {
     pub fn worksheet_cells_reader<'a>(
         &'a mut self,
         name: &str,
-    ) -> Result<XlsxCellReader<'a>, XlsxError> {
+    ) -> Result<XlsxCellReader<'a, RS>, XlsxError> {
         let (_, path) = self
             .sheets
             .iter()
@@ -1095,7 +1095,7 @@ impl<RS: Read + Seek> ReaderRef<RS> for Xlsx<RS> {
 fn xml_reader<'a, RS: Read + Seek>(
     zip: &'a mut ZipArchive<RS>,
     path: &str,
-) -> Option<Result<XlReader<'a>, XlsxError>> {
+) -> Option<Result<XlReader<'a, RS>, XlsxError>> {
     let actual_path = zip
         .file_names()
         .find(|n| n.eq_ignore_ascii_case(path))?
@@ -1236,10 +1236,13 @@ fn get_row_and_optional_column(range: &[u8]) -> Result<(u32, Option<u32>), XlsxE
 }
 
 /// attempts to read either a simple or richtext string
-pub(crate) fn read_string(
-    xml: &mut XlReader<'_>,
+pub(crate) fn read_string<RS>(
+    xml: &mut XlReader<'_, RS>,
     closing: QName,
-) -> Result<Option<String>, XlsxError> {
+) -> Result<Option<String>, XlsxError>
+where
+    RS: Read + Seek,
+{
     let mut buf = Vec::with_capacity(1024);
     let mut val_buf = Vec::with_capacity(1024);
     let mut rich_buffer: Option<String> = None;
@@ -1301,7 +1304,10 @@ fn check_for_password_protected<RS: Read + Seek>(reader: &mut RS) -> Result<(),
     Ok(())
 }
 
-fn read_merge_cells(xml: &mut XlReader<'_>) -> Result<Vec<Dimensions>, XlsxError> {
+fn read_merge_cells<RS>(xml: &mut XlReader<'_, RS>) -> Result<Vec<Dimensions>, XlsxError>
+where
+    RS: Read + Seek,
+{
     let mut merge_cells = Vec::new();
 
     loop {