update to 0.4.5

Cargo.toml

@@ -7,7 +7,7 @@ repository = "https://github.com/MortalreminderPT/edit-xlsx"
 documentation = "https://docs.rs/edit-xlsx/latest/edit_xlsx"
 keywords = ["excel", "xlsx", "writer", "editor"]
 readme = "README.md"
-version = "0.4.4"
+version = "0.4.5"
 edition = "2021"
 exclude = ["tests/"]
 

README.md

@@ -27,7 +27,7 @@ To use Edit-xlsx in your Rust project, add the following to your Cargo.toml file
 
 ```toml
 [dependencies]
-edit-xlsx = "0.4.4"
+edit-xlsx = "0.4.5"
 ```
 
 ## Notice

src/api/cell/rich_text.rs

@@ -1,9 +1,9 @@
 use std::ops::Add;
 use crate::api::format::FormatFont;
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct RichText {
-    pub(crate) words: Vec<Word>
+    pub words: Vec<Word>
 }
 
 impl RichText {
@@ -29,10 +29,19 @@ impl Add<Word> for RichText {
     }
 }
 
-#[derive(Debug, Clone, Default)]
+impl Add<&RichText> for RichText {
+    type Output = RichText;
+
+    fn add(mut self, rhs: &RichText) -> Self::Output {
+        self.words.extend(rhs.words.clone());
+        self
+    }
+}
+
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct Word {
-    pub(crate) text: String,
-    pub(crate) font: FormatFont,
+    pub text: String,
+    pub font: FormatFont,
 }
 
 impl Word {

src/lib.rs

@@ -25,5 +25,16 @@ pub use api::worksheet::col::{Column, WorkSheetCol};
 pub use api::properties::Properties;
 pub use api::filter::Filter;
 pub use api::filter::Filters;
-pub use result::WorkbookResult;
+
+pub use result::CellError;
+pub use result::ColError;
+pub use result::RowError;
+pub use result::RelationshipError;
+pub use result::WorkSheetError;
+pub use result::WorkbookError;
+pub use result::CellResult;
+pub use result::ColResult;
+pub use result::RowResult;
+pub use result::RelationshipResult;
 pub use result::WorkSheetResult;
+pub use result::WorkbookResult;

src/result.rs

@@ -1,4 +1,4 @@
-use std::io;
+use std::{error, fmt, io};
 use quick_xml::DeError;
 use zip::result::ZipError;
 
@@ -8,13 +8,48 @@ pub enum CellError {
     CellNotFound
 }
 
+impl fmt::Display for CellError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            CellError::CellNotFound => write!(f, "Cell not found"),
+        }
+    }
+}
+
+impl error::Error for CellError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            CellError::CellNotFound => None,
+        }
+    }
+}
+
 pub type RowResult<T> = Result<T, RowError>;
 #[derive(Debug)]
 pub enum RowError {
     RowNotFound,
     CellError(CellError),
 }
 
+impl fmt::Display for RowError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            RowError::RowNotFound => write!(f, "Row not found"),
+            RowError::CellError(ref err) => write!(f, "Cell Error: {:?}", err),
+        }
+    }
+}
+
+impl error::Error for RowError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            RowError::RowNotFound => None,
+            RowError::CellError(ref err) => Some(err),
+        }
+    }
+}
+
+
 impl From<CellError> for RowError { fn from(err: CellError) -> RowError { RowError::CellError(err) } }
 
 pub type ColResult<T> = Result<T, ColError>;
@@ -23,6 +58,22 @@ pub enum ColError {
     ColNotFound,
 }
 
+impl fmt::Display for ColError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ColError::ColNotFound => write!(f, "Column not found"),
+        }
+    }
+}
+
+impl error::Error for ColError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            ColError::ColNotFound => None,
+        }
+    }
+}
+
 pub type WorkSheetResult<T> = Result<T, WorkSheetError>;
 #[derive(Debug)]
 pub enum WorkSheetError {
@@ -36,6 +87,37 @@ pub enum WorkSheetError {
     FormatError,
 }
 
+
+impl fmt::Display for WorkSheetError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            WorkSheetError::Io(ref err) => write!(f, "I/O Error: {:?}", err),
+            WorkSheetError::DeError(ref err) => write!(f, "Deserialization Error: {:?}", err),
+            WorkSheetError::ZipError(ref err) => write!(f, "ZIP File Error: {:?}", err),
+            WorkSheetError::FileNotFound => write!(f, "File not found"),
+            WorkSheetError::RowError(ref err) => write!(f, "Row Error: {:?}", err),
+            WorkSheetError::ColError(ref err) => write!(f, "Column Error: {:?}", err),
+            WorkSheetError::DuplicatedSheets => write!(f, "Duplicated Sheets"),
+            WorkSheetError::FormatError => write!(f, "Format Error"),
+        }
+    }
+}
+
+impl error::Error for WorkSheetError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            WorkSheetError::Io(ref err) => Some(err),
+            WorkSheetError::DeError(ref err) => Some(err),
+            WorkSheetError::ZipError(ref err) => Some(err),
+            WorkSheetError::FileNotFound => None,
+            WorkSheetError::RowError(ref err) => Some(err),
+            WorkSheetError::ColError(ref err) => Some(err),
+            WorkSheetError::DuplicatedSheets => None,
+            WorkSheetError::FormatError => None,
+        }
+    }
+}
+
 impl From<DeError> for WorkSheetError { fn from(err: DeError) -> WorkSheetError { WorkSheetError::DeError(err) } }
 impl From<io::Error> for WorkSheetError { fn from(err: io::Error) -> WorkSheetError {
         WorkSheetError::Io(err)
@@ -53,6 +135,32 @@ pub enum WorkbookError {
     RelationshipError(RelationshipError),
 }
 
+
+
+impl fmt::Display for WorkbookError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            WorkbookError::Io(ref err) => write!(f, "I/O Error: {:?}", err),
+            WorkbookError::ZipError(ref err) => write!(f, "ZIP File Error: {:?}", err),
+            WorkbookError::SheetError(ref err) => write!(f, "Worksheet Error: {:?}", err),
+            WorkbookError::FileNotFound => write!(f, "File not found"),
+            WorkbookError::RelationshipError(ref err) => write!(f, "Relationship Error: {:?}", err),
+        }
+    }
+}
+
+impl error::Error for WorkbookError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            WorkbookError::Io(ref err) => Some(err),
+            WorkbookError::ZipError(ref err) => Some(err),
+            WorkbookError::SheetError(ref err) => Some(err),
+            WorkbookError::FileNotFound => None,  // No underlying source error
+            WorkbookError::RelationshipError(ref err) => Some(err),
+        }
+    }
+}
+
 impl From<io::Error> for WorkbookError {
     fn from(err: io::Error) -> WorkbookError {
         WorkbookError::Io(err)
@@ -78,3 +186,17 @@ pub enum RelationshipError {
     UnsupportedNamespace,
 }
 
+impl fmt::Display for RelationshipError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            RelationshipError::UnsupportedNamespace => write!(f, "Unsupported namespace"),
+        }
+    }
+}
+
+impl error::Error for RelationshipError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        None
+    }
+}
+

src/xml/worksheet/sheet_data/cell/inline_string.rs

@@ -41,7 +41,13 @@ impl FromFormat<Word> for RichText {
     }
 
     fn set_format(&self, word: &mut Word) {
-        word.text = self.text.clone().unwrap().text;
-        word.font = self.font.clone().unwrap().get_rich_font_format();
+        if let Some(text) = &self.text {
+            word.text = text.text.clone();
+        }
+        if let Some(font) = &self.font {
+            word.font = font.get_rich_font_format();
+        }
+        // word.text = self.text.clone().unwrap().text;
+        // word.font = self.font.clone().unwrap().get_rich_font_format();
     }
 }

tests/test_error.rs

@@ -0,0 +1,41 @@
+#[cfg(test)]
+mod tests {
+    use std::num::ParseIntError;
+    use edit_xlsx::{Workbook, WorkbookResult, WorkbookError};
+
+    #[test]
+    fn test_new() {
+        fn test_parse() -> Result<(), MyError> {
+            let i = "10";
+            let mut workbook = Workbook::new();
+            let worksheet = workbook.get_worksheet_mut(i.parse()?)?;
+            Ok(())
+        }
+        test_parse().unwrap_err();
+    }
+
+    #[test]
+    fn test_from() -> WorkbookResult<()> {
+        let mut workbook = Workbook::from_path("tests/xlsx/{file_name}.xlsx")?;
+        let worksheet = workbook.get_worksheet_mut(1)?;
+        workbook.save_as("tests/output/{file_name}_test_from.xlsx")?;
+        Ok(())
+    }
+
+    #[derive(Debug)]
+    enum MyError {
+        ParseIntError(ParseIntError),
+        WorkbookError(WorkbookError),
+    }
+
+    impl From<WorkbookError> for MyError {
+        fn from(value: WorkbookError) -> Self {
+            MyError::WorkbookError(value)
+        }
+    }
+    impl From<ParseIntError> for MyError {
+        fn from(value: ParseIntError) -> Self {
+            MyError::ParseIntError(value)
+        }
+    }
+}

tests/test_rich_text.rs

@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use edit_xlsx::{FormatColor, FormatFont, Read, RichText, Word, Workbook, WorkbookResult, Write};
+    use edit_xlsx::{Format, FormatColor, FormatFont, Read, RichText, Word, Workbook, WorkbookResult, Write};
 
     #[test]
     fn test_new() -> WorkbookResult<()> {
@@ -28,8 +28,40 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_read_words() -> WorkbookResult<()> {
+        let mut workbook = Workbook::from_path("tests/xlsx/rich-text.xlsx")?;
+        let worksheet = workbook.get_worksheet_mut(1)?;
+        let mut cell = worksheet.read_cell("A1")?;
+        let mut rich_text = cell.rich_text.unwrap_or_default();
+        let rich_text2 = RichText::new_word("Hello", &FormatFont::default());
+        let mut red = FormatFont::default();
+        red.color = FormatColor::RGB(255, 0, 0);
+        let rich_text3 = RichText::new_word(" World", &red);
+        rich_text = rich_text + &rich_text2 + &rich_text3;
+        println!("{:?}", rich_text);
+        println!("{:?}", rich_text2);
+        println!("{:?}", rich_text3);
+        rich_text.words.iter().for_each(|w| print!("{}", w.text));
+        rich_text.words.iter_mut().for_each(|w| {
+            w.font.bold = true;
+            w.font.italic = false;
+            w.font.underline = true;
+        });
+        cell.rich_text = Some(rich_text);
+        worksheet.write_cell("A1", &cell)?;
+        workbook.save_as("tests/output/rich_text_test_read_words.xlsx")?;
+        Ok(())
+    }
+
     #[test]
     fn test_read_from() -> WorkbookResult<()> {
+        let workbook = Workbook::from_path("tests/xlsx/rich-text.xlsx")?;
+        let worksheet = workbook.get_worksheet(1)?;
+        let cell = worksheet.read_cell("A1")?;
+        let rt = cell.rich_text.unwrap();
+        println!("{:?}", rt);
+
         let mut workbook = Workbook::from_path("tests/xlsx/image_nao.xlsx")?;
         let worksheet = workbook.get_worksheet_mut(1)?;
         let mut cell = worksheet.read_cell("A1")?;