* Added ability to export to JSON, CSV and TXT

Author: CodeDead

Cargo.lock

@@ -12,6 +12,8 @@ license-file = "LICENSE"
 [dependencies]
 iced = { git = "https://github.com/iced-rs/iced" }
 native-dialog = "0.6.3"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 
 [profile.release]
 lto = true

Cargo.toml

@@ -40,6 +40,8 @@ cargo run
 * [Rust](https://www.rust-lang.org/)
 * [iced](https://iced.rs/)
 * [native-dialog](https://github.com/balthild/native-dialog-rs)
+* [serde](https://serde.rs/)
+* [serde_json](https://serde.rs/)
 
 ## About
 

README.md

@@ -1,10 +1,11 @@
 use iced::window;
 use iced::{Sandbox, Settings};
 
-mod view;
-mod style;
 mod filereader;
+mod style;
 mod vector_comparer;
+mod vector_exporter;
+mod view;
 
 pub fn main() -> iced::Result {
     view::ApplicationContext::run(Settings {

src/main.rs

@@ -0,0 +1,107 @@
+use std::{fs::File, io::Write};
+
+#[derive(Debug, Clone)]
+pub enum ExportType {
+    Text,
+    Csv,
+    Json,
+}
+
+pub enum ExportError {
+    IoError(std::io::Error),
+    JsonError(serde_json::Error),
+}
+
+impl Default for ExportType {
+    fn default() -> Self {
+        ExportType::Text
+    }
+}
+
+pub trait IVectorExporter<T> {
+    fn new(vec: Vec<T>, export_type: ExportType, export_type: &str) -> Self;
+
+    fn export(&self) -> Result<(), ExportError>;
+}
+
+#[derive(Debug, Clone)]
+pub struct VectorExporter<T> {
+    pub vec: Vec<T>,
+    pub export_type: ExportType,
+    pub export_path: String,
+}
+
+impl IVectorExporter<String> for VectorExporter<String> {
+    /// Initialize a new `VectorExporter` for type `String`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let vec_exporter: VectorExporter<String> = IVectorExporter::<String>::new(vec![], ExportType::default(), "/path/to/file");
+    /// ```
+    ///
+    /// # Returns
+    ///
+    /// The `VectorExporter` struct for type `String`
+    fn new(vec: Vec<String>, export_type: ExportType, export_path: &str) -> VectorExporter<String> {
+        VectorExporter {
+            vec,
+            export_type,
+            export_path: String::from(export_path),
+        }
+    }
+
+    /// Export the `Vec` of type `String` to a file
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let res = vec_exporter.export();
+    /// ```
+    ///
+    /// # Returns
+    ///
+    /// A `Result` that can either contain an `Ok` or an `Error` struct
+    fn export(&self) -> Result<(), ExportError> {
+        let file = File::create(&self.export_path);
+        let mut file = match file {
+            Ok(file) => file,
+            Err(e) => return Err(ExportError::IoError(e)),
+        };
+        match self.export_type {
+            ExportType::Text => {
+                let mut data = String::new();
+                for l in &self.vec {
+                    data.push_str(&format!("{}\n", l));
+                }
+
+                match write!(file, "{}", data) {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(ExportError::IoError(e)),
+                }
+            }
+            ExportType::Csv => {
+                let mut data = String::new();
+                for l in &self.vec {
+                    data.push_str(&format!("\"{}\"\n", l));
+                }
+
+                match write!(file, "{}", data) {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(ExportError::IoError(e)),
+                }
+            }
+            ExportType::Json => {
+                let serialized = match serde_json::to_string(&self.vec) {
+                    Ok(d) => d,
+                    Err(e) => return Err(ExportError::JsonError(e)),
+                };
+
+                match write!(file, "{}", serialized) {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(ExportError::IoError(e)),
+                }
+            }
+        }
+    }
+}

src/vector_exporter.rs

@@ -1,6 +1,10 @@
+use std::ffi::OsStr;
+use std::path::Path;
+
 use crate::filereader::FileReader;
 use crate::style;
 use crate::vector_comparer::{IVectorComparer, VectorComparer};
+use crate::vector_exporter::{ExportType, IVectorExporter, VectorExporter};
 use iced::{alignment, scrollable, Rule};
 use iced::{
     button, text_input, Alignment, Button, Column, Container, Element, Length, Radio, Row, Sandbox,
@@ -17,6 +21,7 @@ pub enum Message {
     SelectSecondFilePressed,
     ComparePressed,
     ClearComparePressed,
+    ExportPressed,
 }
 
 #[derive(Default)]
@@ -30,6 +35,7 @@ pub struct ApplicationContext {
     pub btn_select_second_file: button::State,
     pub btn_compare: button::State,
     pub btn_clean_compare: button::State,
+    pub btn_export: button::State,
     pub scrollable: scrollable::State,
     pub differences: Vec<String>,
     pub has_compared: bool,
@@ -100,7 +106,10 @@ impl Sandbox for ApplicationContext {
                         MessageDialog::new()
                             .set_type(MessageType::Error)
                             .set_title("text-diff")
-                            .set_text(&format!("Error while reading file {}!\n{}", &self.first_file, e))
+                            .set_text(&format!(
+                                "Error while reading file {}!\n{}",
+                                &self.first_file, e
+                            ))
                             .show_alert()
                             .unwrap();
                         return;
@@ -113,7 +122,10 @@ impl Sandbox for ApplicationContext {
                         MessageDialog::new()
                             .set_type(MessageType::Error)
                             .set_title("text-diff")
-                            .set_text(&format!("Error while reading file {}!\n{}", &self.second_file, e))
+                            .set_text(&format!(
+                                "Error while reading file {}!\n{}",
+                                &self.second_file, e
+                            ))
                             .show_alert()
                             .unwrap();
                         return;
@@ -133,6 +145,61 @@ impl Sandbox for ApplicationContext {
                 self.has_compared = false;
                 self.differences = vec![];
             }
+            Message::ExportPressed => {
+                let path = FileDialog::new()
+                    .add_filter("Text file", &["txt"])
+                    .add_filter("Csv file", &["csv"])
+                    .add_filter("Json file", &["json"])
+                    .show_save_single_file()
+                    .unwrap();
+
+                let path = match path {
+                    Some(path) => path,
+                    None => return,
+                };
+
+                let path = path.into_os_string().into_string().unwrap();
+
+                let extension = match Path::new(&path).extension().and_then(OsStr::to_str) {
+                    Some(x) => x,
+                    None => return,
+                };
+
+                let extension = match extension.to_lowercase().as_str() {
+                    "txt" => ExportType::Text,
+                    "csv" => ExportType::Csv,
+                    "json" => ExportType::Json,
+                    _ => ExportType::default(),
+                };
+
+                let vec_exporter: VectorExporter<String> =
+                    IVectorExporter::<String>::new(self.differences.clone(), extension, &path);
+
+                match vec_exporter.export() {
+                    Ok(_) => return,
+                    Err(e) => match e {
+                        crate::vector_exporter::ExportError::IoError(e) => {
+                            MessageDialog::new()
+                                .set_type(MessageType::Error)
+                                .set_title("text-diff")
+                                .set_text(&format!("Error while writing to file {}!\n{}", &path, e))
+                                .show_alert()
+                                .unwrap();
+                        }
+                        crate::vector_exporter::ExportError::JsonError(e) => {
+                            MessageDialog::new()
+                                .set_type(MessageType::Error)
+                                .set_title("text-diff")
+                                .set_text(&format!(
+                                    "Error while creating JSON for file {}!\n{}",
+                                    &path, e
+                                ))
+                                .show_alert()
+                                .unwrap();
+                        }
+                    },
+                };
+            }
         };
     }
 
@@ -262,17 +329,34 @@ impl Sandbox for ApplicationContext {
             if self.differences.is_empty() {
                 diff_text = Text::new("No differences detected!")
             }
-            
+
             let diff_column = self.differences.iter().fold(
-                Column::new()
-                    .spacing(10)
-                    .push(diff_text.size(30)),
-                |column, theme| column.push(Text::new(format!("{}", theme))),
+                Column::new().spacing(10).push(diff_text.size(30)),
+                |column, theme| column.push(Text::new(format!("- {}", theme))),
             );
 
             content = content
                 .push(Rule::horizontal(20).style(self.theme))
                 .push(diff_column);
+
+            if !self.differences.is_empty() {
+                let btn_export = Button::new(
+                    &mut self.btn_export,
+                    Text::new("Export").horizontal_alignment(alignment::Horizontal::Center),
+                )
+                .padding(10)
+                .min_width(100)
+                .on_press(Message::ExportPressed)
+                .style(self.theme);
+
+                content = content.push(
+                    Column::new()
+                        .width(Length::Fill)
+                        .align_items(Alignment::End)
+                        .spacing(20)
+                        .push(btn_export),
+                );
+            }
         }
 
         content = content