Added support for summing floats

Author: devjgm

src/lib.rs

@@ -1,37 +1,44 @@
+use std::fmt;
+use std::ops::Add;
+
 /// This enum represents the sum of a sequence of numbers that may be integers or floating point.
 /// Integer is the default. When a floating point number is added to the sum, the type is converted
 /// to Float.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum Sum {
     Integer(i128),
     Float(f64),
 }
 
-impl Sum {
-    fn new() -> Self {
-        Self::Integer(0)
-    }
+impl Add for Sum {
+    type Output = Self;
 
-    /// Adds `n` to the sum. The type (Integer or Float) of the Sum is unchanged.
-    fn add_integer(&mut self, n: i128) {
-        *self = match *self {
-            Sum::Integer(i) => Sum::Integer(i + n),
-            Sum::Float(f) => Sum::Float(f + n as f64),
-        };
+    /// Adds two Sums. If either is a Float, the result will be a Float.
+    fn add(self, other: Self) -> Self {
+        match (self, other) {
+            (Sum::Integer(a), Sum::Integer(b)) => Sum::Integer(a + b),
+            (Sum::Float(a), Sum::Float(b)) => Sum::Float(a + b),
+            (Sum::Integer(a), Sum::Float(b)) => Sum::Float(a as f64 + b),
+            (Sum::Float(a), Sum::Integer(b)) => Sum::Float(a + b as f64),
+        }
     }
+}
 
-    /// Adds `n` to the sum. If the type is Intger, it's changed to Float after this operation.
-    fn add_float(&mut self, n: f64) {
-        *self = match *self {
-            Sum::Integer(i) => Sum::Float(i as f64 + n),
-            Sum::Float(f) => Sum::Float(f + n),
-        };
+impl fmt::Display for Sum {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Sum::Integer(n) => write!(f, "{n}"),
+            Sum::Float(n) => write!(f, "{n}"),
+        }
     }
 }
 
-impl Default for Sum {
-    fn default() -> Self {
-        Self::new()
+impl fmt::UpperHex for Sum {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Sum::Integer(n) => fmt::UpperHex::fmt(n, f),
+            Sum::Float(n) => fmt::Display::fmt(n, f),
+        }
     }
 }
 
@@ -40,30 +47,24 @@ mod tests {
     use super::*;
 
     #[test]
-    fn default_works() {
-        assert_eq!(Sum::new(), Default::default());
-    }
-
-    #[test]
-    fn integer_sum_works() {
-        let mut sum = Sum::Integer(0);
-        assert_eq!(sum, Sum::Integer(0));
-        sum.add_integer(2);
-        assert_eq!(sum, Sum::Integer(2));
+    fn sum_integer_works() {
+        let a = Sum::Integer(1);
+        let b = Sum::Integer(2);
+        assert_eq!(a + b, Sum::Integer(3));
     }
 
     #[test]
-    fn float_sum_works() {
-        let mut sum = Sum::Float(1.2);
-        assert_eq!(sum, Sum::Float(1.2));
-        sum.add_float(0.7);
-        assert_eq!(sum, Sum::Float(1.9));
+    fn sum_float_works() {
+        let a = Sum::Float(0.2);
+        let b = Sum::Float(0.8);
+        assert_eq!(a + b, Sum::Float(1.0));
     }
 
     #[test]
-    fn mixed_sum_works() {
-        let mut sum = Sum::Integer(1);
-        sum.add_float(0.2);
-        assert_eq!(sum, Sum::Float(1.2));
+    fn sum_mixed_works() {
+        let a = Sum::Integer(1);
+        let b = Sum::Float(0.2);
+        assert_eq!(a + b, Sum::Float(1.2));
+        assert_eq!(b + a, Sum::Float(1.2));
     }
 }

src/main.rs

@@ -3,6 +3,7 @@ use env_logger::Env;
 use regex::Regex;
 use std::fs;
 use std::io::{self, BufRead, BufReader};
+use sumcol::Sum;
 
 #[derive(Parser, Debug)]
 #[command(version, about)]
@@ -41,7 +42,7 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
         v
     };
 
-    let mut sum = 0i128;
+    let mut sum = Sum::Integer(0);
     for reader in readers {
         for (i, line) in reader.lines().enumerate() {
             let line = line?.trim().to_string();
@@ -59,17 +60,26 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
                 None => (col, default_radix),
             };
             let n = match i128::from_str_radix(col, radix) {
-                Ok(n) => n,
+                Ok(n) => Sum::Integer(n),
                 Err(e) => {
-                    log::info!("{e:?}, col={col:?}. Using 0 instead.");
-                    // If it parses as hex, warn the user that they may want to use -x.
-                    if i128::from_str_radix(col, 16).is_ok() {
-                        log::warn!("Failed to parse {col:?}. Consider using -x");
+                    log::info!("Not integer. {e:?}, col={col:?}, radix={radix:?}.");
+                    // Try parsing as a float
+                    match col.parse::<f64>() {
+                        Ok(n) => Sum::Float(n),
+                        Err(e) => {
+                            log::info!("Not float. {e:?}, col={col:?}.");
+                            // If it parses as hex, warn the user that they may want to use -x.
+                            if i128::from_str_radix(col, 16).is_ok() {
+                                log::warn!(
+                                    "Failed to parse {col:?}, but it may be hex. Consider using -x"
+                                );
+                            }
+                            Sum::Integer(0)
+                        }
                     }
-                    0
                 }
             };
-            sum += n;
+            sum = sum + n;
             log::debug!("{i}: col={col:?}, n={n:?}, sum={sum:?}");
         }
     }

tests/cli.rs

@@ -142,3 +142,71 @@ fn sum_mixed_column_looks_like_number() -> TestResult {
         .stderr(predicate::str::contains("Consider using"));
     Ok(())
 }
+
+#[test]
+fn sum_float() -> TestResult {
+    let mut cmd = Command::cargo_bin("sumcol")?;
+    let input = r"
+    hello 2 blah
+    hello 1.0 foo
+    hello 2.2 oo
+    blah 3e0 mumble
+    ";
+    cmd.write_stdin(input)
+        .args(["-f=2"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("8.2"));
+
+    // With -x, 3e0 will be parsed as 0x3e0 (decimal 992)
+    let mut cmd = Command::cargo_bin("sumcol")?;
+    cmd.write_stdin(input)
+        .args(["-f=2", "-x"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("997.2"));
+    Ok(())
+}
+
+#[test]
+fn sum_float_0xhex() -> TestResult {
+    let mut cmd = Command::cargo_bin("sumcol")?;
+    let input = r"
+    hello 2 blah
+    hello 0xA blah
+    hello 1.0 foo
+    hello 2.2 oo
+    ";
+    cmd.write_stdin(input)
+        .args(["-f=2"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("15.2"));
+    Ok(())
+}
+
+#[test]
+fn sum_float_hex_flag() -> TestResult {
+    let mut cmd = Command::cargo_bin("sumcol")?;
+    let input = r"
+    hello 2 blah
+    hello A blah
+    hello 1.0 foo
+    hello 2.2 oo
+    ";
+    // Without the -x flag, the A in the second line will be ignored.
+    cmd.write_stdin(input)
+        .args(["-f=2"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("5.2"));
+
+    // With -x, A will be treated as 0xA
+    let mut cmd = Command::cargo_bin("sumcol")?;
+    cmd.write_stdin(input)
+        .args(["-f=2", "-x"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("15.2"));
+    Ok(())
+}