patchwork_csv_utils 0.1.16-x86_64-linux → 0.1.18-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccd0a5a1fac5fc48723b28f4b0922ee10468b2bcf26bb6da77a7abdcb9c3882f
-  data.tar.gz: b9be825c7c520ef319c940814863f71e71c41d0ed2be062179e665110dfcb0d6
+  metadata.gz: c53dcc394dd22b4c32d7201914e7c9fd1d94f668365c45b5a0466bc9820e9bf2
+  data.tar.gz: 85f24589e760b680d325a8900c2123ce52c8602bef9ed4b3db82561238924b8b
 SHA512:
-  metadata.gz: f2419b94893570ef960dd9be99ed2d530b3b8d201b05a8373dd8a5a2b679e6c9f078e26ebc6f8a43f649158e2984ed9c10dad5d8c7ebac80ffe6b927ca2250fc
-  data.tar.gz: bb87188b17f9e95e3cdf7db797cf9ae067bb322151069f70b6caaa7c8749ec9c2ecdb068136c55c0a010a0f67b5de9990192b4ca94fd6ec5b8e0d73da71a2ed9
+  metadata.gz: 36306ea0ff3606f5325f3d97d1ef8a84e93f3879b4652574e8226781ae01aeaef79448be87edb3a305a44290581d0c8ebbb8d8c677395758750b1a0af680a5c4
+  data.tar.gz: b236321552dcc55a1a2d05772f0272fc21c65a707f94b4f67ebd068b948a9dd66d001097cbf965d302cc71202e8dbad67e632323a7ee68c46c4cc865965e20a4

data/Gemfile.lock

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

data/ext/csv_utils/src/lib.rs

@@ -9,7 +9,7 @@ pub mod utils;
 fn init() -> Result<(), magnus::Error> {
     let module = define_module("CsvUtils")?;
     module.define_singleton_method("dedup", function!(dedup, 4))?;
-    module.define_singleton_method("to_csv", function!(to_csv, 6))?;
-    module.define_singleton_method("transform_csv", function!(transform_csv, 6))?;
+    module.define_singleton_method("to_csv", function!(to_csv, 5))?;
+    module.define_singleton_method("transform_csv", function!(transform_csv, 5))?;
     Ok(())
 }

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

@@ -4,13 +4,12 @@ use chrono::{NaiveDate, NaiveDateTime, NaiveTime, Utc};
 use csv::{Reader, StringRecord, Writer};
 use magnus::{Error, RArray, Ruby};
 
-use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error, check_mandatory_headers, create_header_map, missing_value, headers_as_byte_record, index_of_header_in_mandatory_list, validate_trust_name};
+use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error, check_mandatory_headers, create_header_map, missing_value, headers_as_byte_record, index_of_header_in_mandatory_list};
 
 pub fn transform_csv(ruby: &Ruby, csv_path: String,
                      target_path: String, exclusions: RArray,
                      mandatory_headers: RArray,
-                     status_exclusions: RArray,
-                     expected_trust_name: String,) -> magnus::error::Result<()> {
+                     status_exclusions: RArray) -> magnus::error::Result<()> {
     if !csv_path.has_extension(&["csv"]) {
         return Err(Error::new(ruby.exception_standard_error(), "csv_path must be a csv file".to_string()));
     }
@@ -41,7 +40,6 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String,
     let actual_start = header_map.get("Actual Start").ok_or(missing_header(ruby, "Actual Start"))?;
     let actual_end = header_map.get("Actual End").ok_or(missing_header(ruby, "Actual End"))?;
     let status = header_map.get("Status");
-    let trust_name = header_map.get("Trust").ok_or(missing_header(ruby, "Trust"))?;
 
     let mandatory_records = get_mandatory_records(&ruby, &mut csv, &headers_list, &mandatory_headers)?;
 
@@ -60,8 +58,6 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String,
             let column_value = record.get(*column_index).ok_or(missing_value(ruby, column))?;
             let column_value = column_value.trim_end();
 
-            validate_trust_name(ruby, &expected_trust_name, trust_name, ri, i, &column_value.to_string())?;
-
             if i == *date {
                 let current = string_to_datetime(column_value).ok_or(to_datetime_error(ruby, column_value, ri, "Date"))?;
                 date_value = current;
@@ -87,6 +83,16 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String,
     Ok(())
 }
 
+
+fn validate_trust_name(ruby: &Ruby, expected_trust_name: &String, trust_name: &usize, ri: usize, i: usize, s: &String) -> magnus::error::Result<()> {
+    if i == *trust_name {
+        if s != &expected_trust_name.clone() {
+            return Err(magnus::Error::new(ruby.exception_standard_error(), format!("Trust actual name: '{}' is not as expected: '{}'", s, expected_trust_name)));
+        }
+    }
+    Ok(())
+}
+
 fn get_mandatory_records(ruby: &Ruby, csv: &mut Reader<File>, csv_header_list: &Vec<String>, mandatory_headers_list: &Vec<String>) -> magnus::error::Result<Vec<StringRecord>> {
     let inverse_header_map: HashMap<usize, String> = csv_header_list.iter().enumerate().map(|(i, h)| (i, h.to_string())).collect();
 

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

@@ -9,15 +9,6 @@ pub mod csv;
 pub mod dedup;
 pub mod xls;
 
-fn validate_trust_name(ruby: &Ruby, expected_trust_name: &String, trust_name: &usize, ri: usize, i: usize, s: &String) -> magnus::error::Result<()> {
-    if ri > 0 && i == *trust_name {
-        if s != &expected_trust_name.clone() {
-            return Err(magnus::Error::new(ruby.exception_standard_error(), format!("Trust actual name: '{}' is not as expected: '{}'", s, expected_trust_name)));
-        }
-    }
-    Ok(())
-}
-
 fn missing_header(ruby: &Ruby, header: &str) -> magnus::Error {
     magnus::Error::new(ruby.exception_standard_error(), format!("Missing '{}' header", header))
 }
@@ -74,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 {
@@ -86,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,28 +2,31 @@ 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, validate_trust_name};
+use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error, check_mandatory_headers, missing_value, index_of_header_in_mandatory_list};
 
 pub fn to_csv(ruby: &Ruby, xls_path: String,
               target_path: String,
               exclusions: RArray,
               mandatory_headers: RArray,
               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")))?;
@@ -38,15 +41,14 @@ pub fn to_csv(ruby: &Ruby, xls_path: String,
     let csv_out_file = File::create(target_path.clone()).map_err(|e| magnus_err(ruby, e, format!("could not create csv file: {}", target_path).as_str()))?;
     let mut dest = BufWriter::new(csv_out_file);
 
-    write_csv(ruby, &mut dest, &range, header_map, exclusions, mandatory_headers, headers_list, status_exclusions, expected_trust_name)
+    write_csv(ruby, &mut dest, &range, header_map, exclusions, mandatory_headers, headers_list, status_exclusions)
 }
 
 fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
                        header_map: HashMap<String, usize>, exclusions: Vec<String>,
                        mandatory_headers: Vec<String>,
                        headers_list: Vec<String>,
-                       status_exclusions: Vec<String>,
-                       expected_trust_name: String) -> magnus::error::Result<()> {
+                       status_exclusions: Vec<String>) -> magnus::error::Result<()> {
     let n = mandatory_headers.len() - 1;
     let request_id = header_map.get("Request Id").ok_or(missing_header(ruby, "Request Id"))?;
     let date = header_map.get("Date").ok_or(missing_header(ruby, "Date"))?;
@@ -55,7 +57,6 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
     let actual_start = header_map.get("Actual Start").ok_or(missing_header(ruby, "Actual Start"))?;
     let actual_end = header_map.get("Actual End").ok_or(missing_header(ruby, "Actual End"))?;
     let status = header_map.get("Status");
-    let trust_name = header_map.get("Trust").ok_or(missing_header(ruby, "Trust"))?;
 
     let mandatory_rows = get_mandatory_records(ruby, range, &headers_list, &mandatory_headers)?;
 
@@ -69,6 +70,7 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
         if date_value_is_not_present(&date, &r) {
             return Err(magnus::Error::new(ruby.exception_standard_error(), format!("Date value is not present in row: {}", ri)));
         }
+        // validate_trust_name(ruby, &expected_trust_name, trust_name, ri, &r)?;
 
         for (i, c) in mandatory_headers.iter().enumerate() {
             let column_index = header_map.get(c).ok_or(missing_header(ruby, c))?;
@@ -76,11 +78,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) => {
-                    validate_trust_name(ruby, &expected_trust_name, trust_name, ri, i, 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 {
@@ -103,6 +143,16 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
     Ok(())
 }
 
+fn validate_trust_name(ruby: &Ruby, expected_trust_name: &String, trust_name: &usize, ri: usize, r: &Vec<&Data>) -> magnus::error::Result<()> {
+    if ri > 0 {
+        let s = r[*trust_name].to_string();
+        if s != expected_trust_name.clone() {
+            return Err(magnus::Error::new(ruby.exception_standard_error(), format!("Trust actual name: '{}' is not as expected: '{}'", s, expected_trust_name)));
+        }
+    }
+    Ok(())
+}
+
 fn get_mandatory_records<'a>(ruby: &Ruby, range: &'a Range<Data>, csv_header_list: &Vec<String>, mandatory_headers_list: &Vec<String>) -> magnus::error::Result<Vec<Vec<&'a Data>>> {
     let inverse_header_map: HashMap<usize, String> = csv_header_list.iter().enumerate().map(|(i, h)| (i, h.to_string())).collect();
 
@@ -161,7 +211,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.16'
+  VERSION = '0.1.18'
 end

metadata

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