patchwork_csv_utils 0.1.6-arm64-darwin → 0.1.8-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29f014ebb0d7fe82e824325e564767deb1cfed92e24c1f487171457214316ac2
-  data.tar.gz: 608a2edb81ccedebc584762b5c30a2eb24e2c002fae1d28190cf7cf307cc23b3
+  metadata.gz: cee57c41f3e282435e1d7de609e9674dfd8f12b3b58a800ec5d5208c4563956f
+  data.tar.gz: 1c14864e23f63a738cb88f077d272a15d6efdba60ee0ed086cd7f3e99cd6ccc1
 SHA512:
-  metadata.gz: de08a499be3bd3106978ba9b56b81afd3b1bfb634262405aefae74cab36543390d9f825e2bcdf2d25601bbdcea2fec3f4853bff470a39a89a484846477b2dd59
-  data.tar.gz: 6b25c5917e837b3de71570f0d12c14d92cf3ef588d36ca660611fbae4a6ca17cc2c04af641304f7dc755cb69ea57b5a38c324ca09b9322af62dd8d0900659718
+  metadata.gz: d54494b5517a1624c2904ca9ff74a1d66ae64cefb3cd3eabd2452c0daa034e69af6292b307629ad7075974e5cb59aff44a2843d5d7f2c18e0c08e604481d1d32
+  data.tar.gz: 25837083730e79c5f161ef4a5cef157659662f639d5c3c6cd0601cbd53fdabf8a8c303458927071163a2ff7e8b15ecdf07d04d01aefebf797f83e96d43a0d2b3

data/Gemfile.lock

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

data/README.md

@@ -14,7 +14,8 @@ gem install patchwork_csv_utils
 ```irb
 require 'csv_utils'
 CsvUtils.dedup('file1.csv', 'file2.csv', 'output.csv')
-CsvUtils.to_csv('file1.xls', 'output_file1.csv', 'sheet_name')
+CsvUtils.to_csv('file1.xls', 'output_file1.csv', ['request_ids_to_skip']])
+CsvUtils.transform_csv('file1.xls', 'output_file1.csv', ['request_ids_to_skip']])
 ```
 
 ## Release

data/ext/csv_utils/src/lib.rs

@@ -1,4 +1,5 @@
 use magnus::{define_module, function, prelude::*};
+use crate::utils::csv::transform_csv;
 use crate::utils::dedup::dedup;
 use crate::utils::xls::to_csv;
 
@@ -9,5 +10,6 @@ fn init() -> Result<(), magnus::Error> {
     let module = define_module("CsvUtils")?;
     module.define_singleton_method("dedup", function!(dedup, 3))?;
     module.define_singleton_method("to_csv", function!(to_csv, 3))?;
+    module.define_singleton_method("transform_csv", function!(transform_csv, 3))?;
     Ok(())
 }

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

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+use std::fs::File;
+
+use chrono::{NaiveDate, NaiveDateTime, NaiveTime, Utc};
+use csv::{StringRecord, Writer};
+use magnus::{RArray, Ruby};
+
+use crate::utils::{FileExtension, magnus_err, missing_header};
+
+pub fn transform_csv(ruby: &Ruby, csv_path: String, target_path: String, exclusions: RArray) -> magnus::error::Result<()> {
+    if !csv_path.has_extension(&["csv"]) {
+        return Err(magnus::Error::new(ruby.exception_standard_error(), "csv_path must be a csv file".to_string()));
+    }
+
+    let exclusions = RArray::to_vec(exclusions)?;
+
+    let csv_file = File::open(csv_path).map_err(|e| magnus_err(ruby, e, "csv_path"))?;
+    let mut csv: csv::Reader<File> = csv::Reader::from_reader(csv_file);
+    let mut wtr = Writer::from_path(target_path).map_err(|e| magnus_err(ruby, e, "target_path"))?;
+    let headers = csv.headers().map_err(|e| magnus_err(ruby, e, "csv_path headers"))?;
+    let header_map: HashMap<String, usize> = headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).collect();
+    let inverse_header_map: HashMap<usize, String> = headers.iter().enumerate().map(|(i, h)| (i, h.to_string())).collect();
+
+    wtr.write_byte_record(headers.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
+
+    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"))?;
+    let start = header_map.get("Start").ok_or(missing_header(ruby, "Start"))?;
+    let end = header_map.get("End").ok_or(missing_header(ruby, "End"))?;
+    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"))?;
+
+    for (ri, record) in csv.records().enumerate() {
+        let record = record.map_err(|e| magnus_err(ruby, e, "record"))?;
+
+        if skip_excluded_rows(request_id, &record, &exclusions) { continue; }
+        if has_empty_row_skip(&record) { continue; }
+        if has_empty_first_col_skip_row(&record) { continue; }
+
+        let mut date_value = Utc::now().naive_utc();
+
+        let record = record.iter().enumerate().map(|(i, c)| {
+            let c = c.trim_end();
+            if i == *date {
+                let current = string_to_datetime(c).ok_or(to_datetime_error(ruby, c, ri, "Date"))?;
+                date_value = current;
+                Ok(current.to_string())
+            } else if i == *start || i == *end || i == *actual_start || i == *actual_end {
+                if c.is_empty() { return Ok(c.to_string()); }
+                let unknown = "Unknown".to_string();
+                let column_name = inverse_header_map.get(&i).unwrap_or(&unknown);
+                let current_time = string_to_time(c).ok_or(to_datetime_error(ruby, c, ri, column_name))?;
+                let datetime = transform_time_to_datetime(date_value, current_time);
+                Ok(datetime.to_string())
+            } else {
+                Ok(c.to_string())
+            }
+        }).collect::<Result<StringRecord, magnus::Error>>()?;
+
+        let record = record.into_iter().map(|r| r.trim_end()).collect::<StringRecord>();
+        wtr.write_byte_record(record.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
+    }
+
+    wtr.flush().map_err(|e| magnus_err(ruby, e, "flush"))?;
+
+    Ok(())
+}
+
+fn skip_excluded_rows(request_id: &usize, r: &StringRecord, exclusions: &Vec<String>) -> bool {
+    let value = r.get(*request_id).unwrap_or_default();
+    exclusions.contains(&value.to_string())
+}
+
+fn string_to_datetime(s: &str) -> Option<NaiveDateTime> {
+    NaiveDate::parse_from_str(s, "%d-%b-%y").ok().map(|d| d.and_hms_opt(0, 0, 0)).flatten()
+}
+
+fn string_to_time(s: &str) -> Option<NaiveTime> {
+    NaiveTime::parse_from_str(s, "%H:%M").ok()
+}
+
+fn transform_time_to_datetime(t1: NaiveDateTime, t2: NaiveTime) -> NaiveDateTime {
+    NaiveDateTime::new(t1.date(), t2)
+}
+
+fn to_datetime_error(ruby: &Ruby, value: &str, row: usize, col: &str) -> magnus::Error {
+    magnus::Error::new(ruby.exception_standard_error(), format!("Could not parse datetime '{}', row: {}, col: {}", value, row, col))
+}
+
+fn has_empty_first_col_skip_row(record: &StringRecord) -> bool {
+    record[0].is_empty()
+}
+
+fn has_empty_row_skip(record: &StringRecord) -> bool {
+    record.iter().all(|r| r.is_empty())
+}

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

@@ -28,7 +28,7 @@ pub fn dedup(ruby: &Ruby, previous_csv_path: String, new_csv_path: String, targe
         return Err(magnus::Error::new(ruby.exception_standard_error(), "headers of both csv files must be the same".to_string()));
     }
 
-    wtr.write_byte_record(previous_headers.as_byte_record()).unwrap();
+    wtr.write_byte_record(previous_headers.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
 
     let mut previous_records = vec![];
     for previous_record in previous_csv.records() {
@@ -49,27 +49,21 @@ pub fn dedup(ruby: &Ruby, previous_csv_path: String, new_csv_path: String, targe
 
         let new_record = new_record.into_iter().map(|r| r.trim_end()).collect::<StringRecord>();
         if !previous_records.contains(&new_record) {
-            wtr.write_byte_record(new_record.as_byte_record()).unwrap();
+            wtr.write_byte_record(new_record.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
         }
     }
 
-    wtr.flush().unwrap();
+    wtr.flush().map_err(|e| magnus_err(ruby, e, "flush"))?;
 
     Ok(())
 }
 
 fn has_empty_first_col_skip_row(previous_record: &StringRecord) -> bool {
-    if previous_record[0].is_empty() {
-        return true;
-    }
-    false
+    previous_record[0].is_empty()
 }
 
 fn has_empty_row_skip(record: &StringRecord) -> bool {
-    if record.iter().all(|r| r.is_empty()) {
-        return true;
-    }
-    false
+    record.iter().all(|r| r.is_empty())
 }
 
 

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

@@ -3,9 +3,14 @@ use std::ffi::OsStr;
 use std::path::Path;
 use magnus::Ruby;
 
+pub mod csv;
 pub mod dedup;
 pub mod xls;
 
+fn missing_header(ruby: &Ruby, header: &str) -> magnus::Error {
+    magnus::Error::new(ruby.exception_standard_error(), format!("Missing '{}' header", header))
+}
+
 fn magnus_err<E: Error>(ruby: &Ruby, e: E, msg: &str) -> magnus::Error {
     magnus::Error::new(ruby.exception_standard_error(), format!("{}: {}", msg, e.to_string()))
 }

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

@@ -6,19 +6,15 @@ use calamine::{Data, open_workbook, Range, Reader, Xls};
 use chrono::{NaiveDateTime, Utc};
 use magnus::{RArray, Ruby};
 
-use crate::utils::{FileExtension, magnus_err};
+use crate::utils::{FileExtension, magnus_err, missing_header};
 
 pub fn to_csv(ruby: &Ruby, xls_path: String, target_path: String, exclusions: RArray) -> magnus::error::Result<()> {
-    let exclusions = RArray::to_vec(exclusions)?;
-
-    println!("xls_path: {:?}", xls_path);
-    println!("target_path: {:?}", target_path);
-    println!("exclusions: {:?}", exclusions);
-
     if !xls_path.has_extension(&["xls"]) {
         return Err(magnus::Error::new(ruby.exception_standard_error(), "xls_path must be an xls file".to_string()));
     }
 
+    let exclusions = RArray::to_vec(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 range = workbook.worksheet_range_at(0)
         .ok_or(magnus::Error::new(ruby.exception_standard_error(), "no worksheet found in xls".to_string()))
@@ -34,18 +30,23 @@ pub fn to_csv(ruby: &Ruby, xls_path: String, target_path: String, exclusions: RA
 
 fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>, header_map: HashMap<String, usize>, exclusions: Vec<String>) -> magnus::error::Result<()> {
     let n = range.get_size().1 - 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"))?;
+    let start = header_map.get("Start").ok_or(missing_header(ruby, "Start"))?;
+    let end = header_map.get("End").ok_or(missing_header(ruby, "End"))?;
+    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"))?;
+
     for (ri, r) in range.rows().enumerate() {
         let mut date_value = Utc::now().naive_utc();
 
-        if skip_excluded_rows(&header_map, r, &exclusions) { continue; }
+        if skip_excluded_rows(&request_id, r, &exclusions) { continue; }
         if skip_empty_rows(r) { continue; }
-        if skip_rows_with_no_request_id(&header_map, r) { continue; }
-
-        let date = header_map.get("Date").ok_or(missing_header(ruby, "Date"))?;
-        let start = header_map.get("Start").ok_or(missing_header(ruby, "Start"))?;
-        let end = header_map.get("End").ok_or(missing_header(ruby, "End"))?;
-        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"))?;
+        if skip_rows_with_no_request_id(&request_id, r) { continue; }
+        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)));
+        }
 
         for (i, c) in r.iter().enumerate() {
             match *c {
@@ -55,7 +56,7 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>, header_ma
                 }
                 Data::Float(ref f) => write!(dest, "{}", f),
                 Data::DateTime(ref d) => {
-                    let mut current = d.as_datetime().unwrap_or_default();
+                    let mut current = d.as_datetime().ok_or(to_datetime_error(ruby, &d.to_string(), ri, "Date"))?;
                     if i == *date {
                         date_value = current;
                     } else if i == *start || i == *end || i == *actual_start || i == *actual_end {
@@ -76,40 +77,31 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>, header_ma
     Ok(())
 }
 
-fn skip_excluded_rows(header_map: &HashMap<String, usize>, r: &[Data], exclusions: &Vec<String>) -> bool {
-    if let Some(request_id) = header_map.get("Request Id") {
-        let value = r[*request_id].to_string();
-        if exclusions.contains(&value) {
-            return true;
-        }
-    }
-    false
+fn date_value_is_not_present(date: &usize, r: &[Data]) -> bool {
+    r[*date] == Data::Empty
 }
 
-fn skip_empty_rows(r: &[Data]) -> bool {
-    if r.iter().all(|c| c == &Data::Empty) {
-        return true;
-    }
-    false
+fn skip_excluded_rows(request_id: &usize, r: &[Data], exclusions: &Vec<String>) -> bool {
+    let value = r[*request_id].to_string();
+    exclusions.contains(&value.to_string())
 }
 
-fn skip_rows_with_no_request_id(header_map: &HashMap<String, usize>, r: &[Data]) -> bool {
-    if let Some(request_id) = header_map.get("Request Id") {
-        if r[*request_id] == Data::Empty {
-            return true;
-        }
-    }
-    false
+fn skip_empty_rows(r: &[Data]) -> bool {
+    r.iter().all(|c| c == &Data::Empty)
 }
 
-fn missing_header(ruby: &Ruby, header: &str) -> magnus::Error {
-    magnus::Error::new(ruby.exception_standard_error(), format!("Missing '{}' header in xls", header))
+fn skip_rows_with_no_request_id(request_id: &usize, r: &[Data]) -> bool {
+    r[*request_id] == Data::Empty
 }
 
 fn transform_time_to_datetime(t1: NaiveDateTime, t2: NaiveDateTime) -> NaiveDateTime {
     NaiveDateTime::new(t1.date(), t2.time())
 }
 
+fn to_datetime_error(ruby: &Ruby, value: &str, row: usize, col: &str) -> magnus::Error {
+    magnus::Error::new(ruby.exception_standard_error(), format!("Could not parse datetime '{}', row: {}, col: {}", value, row, col))
+}
+
 fn handle_commas<W: Write>(dest: &mut W, s: &str) -> std::io::Result<()> {
     if s.contains(",") {
         write!(dest, "{:?}", clean_strings(s).trim_end())

data/lib/csv_utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patchwork_csv_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: arm64-darwin
 authors:
 - kingsley.hendrickse
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-06 00:00:00.000000000 Z
+date: 2024-08-07 00:00:00.000000000 Z
 dependencies: []
 description: Deduplication of CSV files and XLS to CSV conversion.
 email:
@@ -28,6 +28,7 @@ files:
 - ext/csv_utils/Cargo.toml
 - ext/csv_utils/extconf.rb
 - ext/csv_utils/src/lib.rs
+- ext/csv_utils/src/utils/csv.rs
 - ext/csv_utils/src/utils/dedup.rs
 - ext/csv_utils/src/utils/mod.rs
 - ext/csv_utils/src/utils/xls.rs