Merged sdiff logic from PR #159.

This is now a good option parser and has basic sdiff compare functionality. This is a good base for further development.

Author: Gunter Schmidt

Cargo.lock

@@ -4,12 +4,9 @@
 // files that was distributed with this source code.
 
 use crate::params::{parse_params, Format};
-use crate::utils::report_failure_to_read_input_file;
-use crate::{context_diff, ed_diff, normal_diff, side_diff, unified_diff};
+use crate::{context_diff, ed_diff, normal_diff, side_diff, unified_diff, utils};
 use std::env::ArgsOs;
-use std::ffi::OsString;
-use std::fs;
-use std::io::{self, stdout, Read, Write};
+use std::io::{self, stdout, Write};
 use std::iter::Peekable;
 use std::process::{exit, ExitCode};
 
@@ -40,35 +37,16 @@ pub fn main(opts: Peekable<ArgsOs>) -> ExitCode {
         return ExitCode::SUCCESS;
     }
 
-    // read files
-    fn read_file_contents(filepath: &OsString) -> io::Result<Vec<u8>> {
-        if filepath == "-" {
-            let mut content = Vec::new();
-            io::stdin().read_to_end(&mut content).and(Ok(content))
-        } else {
-            fs::read(filepath)
-        }
-    }
-    let mut io_error = false;
-    let from_content = match read_file_contents(&params.from) {
-        Ok(from_content) => from_content,
-        Err(e) => {
-            report_failure_to_read_input_file(&params.executable, &params.from, &e);
-            io_error = true;
-            vec![]
-        }
-    };
-    let to_content = match read_file_contents(&params.to) {
-        Ok(to_content) => to_content,
-        Err(e) => {
-            report_failure_to_read_input_file(&params.executable, &params.to, &e);
-            io_error = true;
-            vec![]
+    let (from_content, to_content) = match utils::read_both_files(&params.from, &params.to) {
+        Ok(contents) => contents,
+        Err((filepath, error)) => {
+            eprintln!(
+                "{}",
+                utils::format_failure_to_read_input_file(&params.executable, &filepath, &error)
+            );
+            return ExitCode::from(2);
         }
     };
-    if io_error {
-        return ExitCode::from(2);
-    }
 
     // run diff
     let result: Vec<u8> = match params.format {
@@ -81,7 +59,7 @@ pub fn main(opts: Peekable<ArgsOs>) -> ExitCode {
         }),
         Format::SideBySide => {
             let mut output = stdout().lock();
-            side_diff::diff(&from_content, &to_content, &mut output, &params)
+            side_diff::diff(&from_content, &to_content, &mut output, &(&params).into())
         }
     };
     if params.brief && !result.is_empty() {

src/diff.rs

@@ -1,10 +1,19 @@
 //! This module holds the core compare logic of sdiff.
-mod params_sdiff;
-mod params_sdiff_def;
+pub mod params_sdiff;
+pub mod params_sdiff_def;
 
-use std::{env::ArgsOs, fmt::Display, iter::Peekable, process::ExitCode};
+use std::{
+    env::ArgsOs,
+    fmt::Display,
+    io::{stdout, Write},
+    iter::Peekable,
+    process::ExitCode,
+};
 
-use crate::sdiff::{params_sdiff::ParamsSdiff, params_sdiff_def::ParamsSdiffOk};
+use crate::{
+    sdiff::{params_sdiff::ParamsSdiff, params_sdiff_def::ParamsSdiffOk},
+    side_diff, utils,
+};
 
 pub const EXE_NAME: &str = "sdiff";
 
@@ -59,22 +68,55 @@ pub enum SdiffOk {
 /// To centralize error messages and make it easier to use in a lib.
 #[derive(Debug, PartialEq)]
 pub enum SdiffError {
-    // Dummy,
+    OutputError(String),
+    // (msg)
+    ReadFileError(String),
 }
 
 impl Display for SdiffError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // TODO Display errors
-        write!(f, "Error message of Sdiff")
+        match self {
+            SdiffError::OutputError(msg) => write!(f, "{msg}"),
+            SdiffError::ReadFileError(msg) => write!(f, "{msg}"),
+        }
     }
 }
 
 /// This is the main function to compare the files. \
 /// Files are limited to u64 bytes and u64 lines.
-pub fn sdiff(_params: &ParamsSdiff) -> Result<SdiffOk, SdiffError> {
-    // TODO sdiff file compare logic
-    // There seems to be a lot of similarity to diff, mainly a different output.
-    println!("\nsdiff does not compare files yet.");
-    println!("{:?} or {:?}?", SdiffOk::Different, SdiffOk::Equal);
-    Ok(SdiffOk::Equal)
+/// TODO sdiff is missing a number of options, currently implemented:
+/// * expand_tabs
+/// * tabsize
+/// * width
+pub fn sdiff(params: &ParamsSdiff) -> Result<SdiffOk, SdiffError> {
+    let (from_content, to_content) = match utils::read_both_files(&params.from, &params.to) {
+        Ok(contents) => contents,
+        Err((filepath, error)) => {
+            let msg = utils::format_failure_to_read_input_file(
+                &params.util.executable(),
+                &filepath,
+                &error,
+            );
+            return Err(SdiffError::ReadFileError(msg));
+        }
+    };
+
+    // run diff
+    let mut output = stdout().lock();
+    let result = side_diff::diff(&from_content, &to_content, &mut output, &params.into());
+
+    match std::io::stdout().write_all(&result) {
+        Ok(_) => {
+            if result.is_empty() {
+                Ok(SdiffOk::Equal)
+            } else {
+                Ok(SdiffOk::Different)
+            }
+        }
+        Err(e) => Err(SdiffError::OutputError(e.to_string())),
+    }
+
+    // println!("\nsdiff does not compare files yet.");
+    // println!("{:?} or {:?}?", SdiffOk::Different, SdiffOk::Equal);
+    // Ok(SdiffOk::Equal)
 }

src/sdiff.rs

@@ -9,7 +9,7 @@ use crate::{
 };
 
 /// Holds the given command line arguments except "--version" and "--help".
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ParamsSdiff {
     /// Identifier
     pub util: DiffUtility,
@@ -48,13 +48,13 @@ pub struct ParamsSdiff {
     /// -s, --suppress-common-lines  do not output common lines
     pub suppress_common_lines: bool,
     /// --tabsize=NUM            tab stops at every NUM (default 8) print columns
-    pub tabsize: Option<usize>,
+    pub tabsize: usize,
     /// -a, --text                   treat all files as text
     pub text: bool,
     /// -v, --version                output version information and exit
     pub version: bool,
     /// -w, --width=NUM              output at most NUM (default 130) print columns
-    pub width: Option<usize>,
+    pub width: usize,
 }
 
 impl ParamsSdiff {
@@ -147,7 +147,7 @@ impl ParamsSdiff {
             Ok(w) => w,
             Err(_) => return Err(ParamsSdiffError::InvalidNumber(parsed_option.clone())),
         };
-        self.tabsize = Some(t);
+        self.tabsize = t;
 
         Ok(t)
     }
@@ -158,12 +158,42 @@ impl ParamsSdiff {
             Ok(w) => w,
             Err(_) => return Err(ParamsSdiffError::InvalidNumber(parsed_option.clone())),
         };
-        self.width = Some(w);
+        self.width = w;
 
         Ok(w)
     }
 }
 
+impl Default for ParamsSdiff {
+    fn default() -> Self {
+        Self {
+            util: DiffUtility::SDiff,
+            from: Default::default(),
+            to: Default::default(),
+            diff_program: Default::default(),
+            expand_tabs: Default::default(),
+            help: Default::default(),
+            ignore_all_space: Default::default(),
+            ignore_blank_lines: Default::default(),
+            ignore_case: Default::default(),
+            ignore_matching_lines: Default::default(),
+            ignore_space_change: Default::default(),
+            ignore_tab_expansion: Default::default(),
+            ignore_trailing_space: Default::default(),
+            left_column: Default::default(),
+            minimal: Default::default(),
+            output: Default::default(),
+            speed_large_files: Default::default(),
+            strip_trailing_cr: Default::default(),
+            suppress_common_lines: Default::default(),
+            tabsize: 8,
+            text: Default::default(),
+            version: Default::default(),
+            width: 130,
+        }
+    }
+}
+
 // Usually assert is used like assert_eq(test result, expected result).
 #[cfg(test)]
 mod tests {
@@ -269,10 +299,10 @@ mod tests {
             speed_large_files: true,
             strip_trailing_cr: true,
             suppress_common_lines: true,
-            tabsize: Some(2),
+            tabsize: 2,
             text: true,
             version: false,
-            width: Some(150),
+            width: 150,
         };
         assert_eq!(
             parse(

src/sdiff/params_sdiff.rs

@@ -8,7 +8,7 @@ use diff::Result;
 use std::{io::Write, vec};
 use unicode_width::UnicodeWidthStr;
 
-use crate::params::Params;
+use crate::sdiff::params_sdiff::ParamsSdiff;
 
 const GUTTER_WIDTH_MIN: usize = 3;
 
@@ -98,6 +98,34 @@ impl Config {
     }
 }
 
+/// Params for side_diff, so the functions can be used by multiple modules (diff and sdiff)
+#[derive(Default)]
+pub struct Params {
+    pub expand_tabs: bool,
+    pub tabsize: usize,
+    pub width: usize,
+}
+
+impl From<&crate::params::Params> for Params {
+    fn from(param: &crate::params::Params) -> Self {
+        Self {
+            expand_tabs: param.expand_tabs,
+            tabsize: param.tabsize,
+            width: param.width,
+        }
+    }
+}
+
+impl From<&ParamsSdiff> for Params {
+    fn from(param: &ParamsSdiff) -> Self {
+        Self {
+            expand_tabs: param.expand_tabs,
+            tabsize: param.tabsize,
+            width: param.width,
+        }
+    }
+}
+
 fn format_tabs_and_spaces<T: Write>(
     from: usize,
     to: usize,

src/side_diff.rs

@@ -4,7 +4,8 @@
 // files that was distributed with this source code.
 
 use regex::Regex;
-use std::{ffi::OsString, io::Write};
+use std::io::{self, Error, Read, Write};
+use std::{ffi::OsString, fs};
 use unicode_width::UnicodeWidthStr;
 
 /// Replace tabs by spaces in the input line.
@@ -87,15 +88,22 @@ pub fn format_failure_to_read_input_file(
     )
 }
 
-pub fn report_failure_to_read_input_file(
-    executable: &OsString,
-    filepath: &OsString,
-    error: &std::io::Error,
-) {
-    eprintln!(
-        "{}",
-        format_failure_to_read_input_file(executable, filepath, error)
-    );
+pub fn read_file_contents(filepath: &OsString) -> io::Result<Vec<u8>> {
+    if filepath == "-" {
+        let mut content = Vec::new();
+        io::stdin().read_to_end(&mut content).and(Ok(content))
+    } else {
+        fs::read(filepath)
+    }
+}
+
+pub fn read_both_files(
+    from: &OsString,
+    to: &OsString,
+) -> Result<(Vec<u8>, Vec<u8>), (OsString, Error)> {
+    let from_content = read_file_contents(from).map_err(|e| (from.clone(), e))?;
+    let to_content = read_file_contents(to).map_err(|e| (to.clone(), e))?;
+    Ok((from_content, to_content))
 }
 
 #[cfg(test)]