patchwork_csv_utils 0.1.17-x86_64-darwin → 0.1.19-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 439ab3bf8ec06c55a28602b5b64ece16308e0c9d568e067f7c1a541537e310c2
-  data.tar.gz: 953bc26c08024b45fbf3ca37f4b4d3b8c583497c58f7218933fe57a9238252d5
+  metadata.gz: c566f86e6b5f7dda3afb47413541a2ffa1d61c7f6223b4f1dfd7be6918b41e7c
+  data.tar.gz: 20efd8d7d1f58ae1331ad627efd6a6b236ed417c29d0248fb752e754cb2ea05b
 SHA512:
-  metadata.gz: d1fa09fa1933d6071fd402c3e34000d8fdd3697a13385e65a5b67659845fddaf93a0fdf629b21fe6ac3023412279fdb5f94d3b34d80ff84bf4af46607ae596cf
-  data.tar.gz: ce7a9d68c134d74e7296e38122976e5d0e3b10263d0e5cc538486e903ae2df479bf5e2d24a4dc765fa0b6ed0b4bb803f583d91423f4eb94e4550201cade08b0d
+  metadata.gz: d4363b4bcb7aa2fed0d3397484daf5e7ade8c2025890929d2ea5e932529c3ffefa135f3eeff57f47995072f3b88b4b931a21bb4a8420d66535e738f1c6b1dc4c
+  data.tar.gz: ac32b811b6f111fd4a295a46c57874fb4a41bcdbd796f14eed56a97c30ca2987516cb0e7452b97490768cc5eb099141ff6a3ea8a0c23950b6be331e05f25425b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    patchwork_csv_utils (0.1.17)
+    patchwork_csv_utils (0.1.19)
 
 GEM
   remote: https://rubygems.org/

data/ext/csv_utils/src/utils/mod.rs

@@ -65,6 +65,7 @@ fn create_header_map(headers: &Vec<String>) -> HashMap<String, usize> {
 
 pub trait FileExtension {
     fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool;
+    fn extension(&self) -> Option<&str>;
 }
 
 impl<P: AsRef<Path>> FileExtension for P {
@@ -77,5 +78,8 @@ impl<P: AsRef<Path>> FileExtension for P {
 
         false
     }
+    fn extension(&self) -> Option<&str> {
+        self.as_ref().extension().and_then(OsStr::to_str)
+    }
 }
 

data/ext/csv_utils/src/utils/xls.rs

@@ -2,8 +2,8 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::io::{BufWriter, Write};
 
-use calamine::{Data, open_workbook, Range, Reader, Xls};
-use chrono::{NaiveDateTime, Utc};
+use calamine::{Data, open_workbook, Range, Reader, Xls, open_workbook_auto};
+use chrono::{NaiveDateTime, Timelike, Utc};
 use magnus::{RArray, Ruby};
 
 use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error, check_mandatory_headers, missing_value, index_of_header_in_mandatory_list};
@@ -15,15 +15,17 @@ pub fn to_csv(ruby: &Ruby, xls_path: String,
               status_exclusions: RArray,
               expected_trust_name: String,
 ) -> magnus::error::Result<()> {
-    if !xls_path.has_extension(&["xls"]) {
-        return Err(magnus::Error::new(ruby.exception_standard_error(), "xls_path must be an xls file".to_string()));
+    if !xls_path.has_extension(&["xls","xlsx"]) {
+        return Err(magnus::Error::new(ruby.exception_standard_error(), "xls_path must be an xls or xlsx file".to_string()));
     }
 
     let exclusions = RArray::to_vec(exclusions)?;
     let mandatory_headers: Vec<String> = RArray::to_vec(mandatory_headers)?;
     let status_exclusions = RArray::to_vec(status_exclusions)?;
 
-    let mut workbook: Xls<_> = open_workbook(xls_path.clone()).map_err(|e| magnus_err(ruby, e, format!("could not open xls: {}", xls_path).as_str()))?;
+    let mut workbook = open_workbook_auto(&xls_path)
+        .map_err(|e| magnus_err(ruby, e, format!("could not open workbook: {}", xls_path).as_str()))?;
+
     let range = workbook.worksheet_range_at(0)
         .ok_or(magnus::Error::new(ruby.exception_standard_error(), "no worksheet found in xls".to_string()))
         .and_then(|r| r.map_err(|e| magnus_err(ruby, e, "could not read worksheet range")))?;
@@ -77,10 +79,49 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
 
             match *c {
                 Data::Empty => Ok(()),
-                Data::String(ref s) | Data::DateTimeIso(ref s) | Data::DurationIso(ref s) => {
+                Data::String(ref s) | Data::DurationIso(ref s) => {
                     handle_commas(dest, s)
                 }
                 Data::Float(ref f) => write!(dest, "{}", f),
+                Data::DateTimeIso(ref s) => {
+                    // Normalize the string to ensure manageable precision
+                    let normalized_s = if s.contains('.') {
+                        let parts: Vec<&str> = s.split('.').collect();
+                        format!("{}.{}", parts[0], &parts[1][..std::cmp::min(parts[1].len(), 6)]) // Keep up to 6 fractional seconds
+                    } else {
+                        s.to_string()
+                    };
+
+                    // Attempt to parse the normalized string as a full datetime
+                    let mut current = NaiveDateTime::parse_from_str(&normalized_s, "%Y-%m-%dT%H:%M:%S%.f")
+                        .or_else(|_| {
+                            // If parsing as datetime fails, try parsing as date-only
+                            NaiveDateTime::parse_from_str(&format!("{}T00:00:00", normalized_s), "%Y-%m-%dT%H:%M:%S%.f")
+                        })
+                        .or_else(|_| {
+                            // If parsing as time-only fails, try parsing as time-only
+                            NaiveDateTime::parse_from_str(&format!("1970-01-01T{}", normalized_s), "%Y-%m-%dT%H:%M:%S%.f")
+                        })
+                        .map_err(|_| to_datetime_error(ruby, s, ri, "Date or Time"))?;
+
+                    // Apply the same logic as for Data::DateTime
+                    if i == *date {
+                        date_value = current;
+                    } else if i == *start || i == *end || i == *actual_start || i == *actual_end {
+                        current = transform_time_to_datetime(date_value, current);
+                    }
+
+                    // Round up to the next second if we have any fractional seconds
+                    let adjusted_time = if current.nanosecond() > 0 {
+                        current + chrono::Duration::seconds(1) - chrono::Duration::nanoseconds(current.nanosecond() as i64)
+                    } else {
+                        current
+                    };
+
+                    // Format the output to ensure consistent precision
+                    let formatted_output = adjusted_time.format("%Y-%m-%d %H:%M:%S").to_string();
+                    write!(dest, "{}", formatted_output)
+                }
                 Data::DateTime(ref d) => {
                     let mut current = d.as_datetime().ok_or(to_datetime_error(ruby, &d.to_string(), ri, "Date"))?;
                     if i == *date {
@@ -171,7 +212,7 @@ fn handle_commas<W: Write>(dest: &mut W, s: &str) -> std::io::Result<()> {
 
 fn clean_strings(s: &str) -> String {
     s.replace("\n", " ")
-        .replace("\r", " ")
+        .replace("\r", "")
         .replace("\"", "")
 }
 

data/lib/csv_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CsvUtils
-  VERSION = '0.1.17'
+  VERSION = '0.1.19'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patchwork_csv_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.19
 platform: x86_64-darwin
 authors:
 - kingsley.hendrickse
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-26 00:00:00.000000000 Z
+date: 2024-12-04 00:00:00.000000000 Z
 dependencies: []
 description: Deduplication of CSV files and XLS to CSV conversion.
 email: