patchwork_csv_utils 0.1.11-arm64-darwin → 0.1.13-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb79f50a40c0b1913d133b410abe0133fb685d6de113b8fc61e56d6c75ebf179
-  data.tar.gz: 20c06b94ca3a083d599cfeff94118a3dc71aeac42df42cdcfe746153b74fbacf
+  metadata.gz: 54fc4d5750dd83ab95eebe09a6270e8b38e409cc0cf9ed2beb5fb0eeddd096ec
+  data.tar.gz: 7dc07de1618c260cb80c2feee25ace49fe9fba817c63b18f3dd2aa0fd0a4d2a2
 SHA512:
-  metadata.gz: 4f1a7b75c34fd0c38925fd23e709dc466ea46e7210d008f50320a37cab561d47c5d0213b014dacdddbe453b60e09fc79a00b8c993f0d3f3b00f81cffdefa9e68
-  data.tar.gz: 29429c06f1546fdff0cebb07e7e7ba6d3ed2a684f759bb34e4313d47fe3899edf0904d22c1170d952a7b6dd522f5594491350f5084ba7e237f439891da91b6f1
+  metadata.gz: 28050396ee306f0512d7f5c689b0a098f2df0fcacc0d6eda085eb070a6cfe2f8097cadb4508b2bc36a1a601f3f73755c6f528bee9b424f89c59af709b497b785
+  data.tar.gz: 7907c50d50888bcac36868296616ae741e9a5d8855ec9007733b45be2e227f1f96a4248df710e52897f97d197bfda0001cc5eb44e3e7954d5d31ae3e270c8dfd

data/Gemfile.lock

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

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

@@ -5,11 +5,11 @@ 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};
+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,) -> magnus::error::Result<()> {
+                     mandatory_headers: 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()));
     }
@@ -21,13 +21,13 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String,
     let mut csv: Reader<File> = 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"))?.clone();
-    let headers_list : Vec<String> = headers.iter().map(|h| h.to_string()).collect();
+    let headers_list: Vec<String> = headers.iter().map(|h| h.to_string()).collect();
 
     if let Some(value) =
         check_mandatory_headers(ruby, &headers_list, &mandatory_headers, "csv") { return value; }
 
-    let header_map: HashMap<String, usize> = create_header_map(&headers);
-    let inverse_header_map: HashMap<usize, String> = headers.iter().enumerate().map(|(i, h)| (i, h.to_string())).collect();
+    let header_map: HashMap<String, usize> = create_header_map(&mandatory_headers);
+    let inverse_header_map: HashMap<usize, String> = mandatory_headers.iter().enumerate().map(|(i, h)| (i, h.to_string())).collect();
 
     let csv_headers = headers_as_byte_record(mandatory_headers.clone());
     wtr.write_byte_record(&csv_headers).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
@@ -39,8 +39,9 @@ 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"))?;
 
-    for (ri, record) in csv.records().enumerate() {
-        let record = record.map_err(|e| magnus_err(ruby, e, "record"))?;
+    let mandatory_records = get_mandatory_records(&ruby, &mut csv, &headers_list, &mandatory_headers)?;
+
+    for (ri, record) in mandatory_records.iter().enumerate() {
 
         if skip_excluded_rows(request_id, &record, &exclusions) { continue; }
         if has_empty_row_skip(&record) { continue; }
@@ -79,6 +80,28 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String,
     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();
+
+    let mut records = vec![];
+    for row in csv.records() {
+        let row = row.map_err(|e| magnus_err(ruby, e, "record error"))?;
+        let mut columns = vec![];
+        for (i, column_value) in row.iter().enumerate() {
+            let column_name = inverse_header_map.get(&i).ok_or(missing_header(ruby, &i.to_string()))?;
+            if mandatory_headers_list.contains(column_name) {
+                let index = index_of_header_in_mandatory_list(mandatory_headers_list.clone(), column_name.to_string()).unwrap();
+                columns.push(CsvMandatoryColumn::new(column_value.to_string(), index));
+            }
+        }
+        columns.sort_by(|a, b| a.index.cmp(&b.index));
+        let columns = columns.iter().map(|c| c.value.to_string()).collect::<StringRecord>();
+        records.push(columns);
+    }
+
+    Ok(records)
+}
+
 fn process_datetime(ruby: &Ruby, ri: usize, date_value: NaiveDateTime, c: &str, column_name: &String) -> magnus::error::Result<String> {
     let maybe_correct = correct_datetime(c);
     if let Some(correct) = maybe_correct {
@@ -126,4 +149,16 @@ fn has_empty_first_col_skip_row(record: &StringRecord) -> bool {
 
 fn has_empty_row_skip(record: &StringRecord) -> bool {
     record.iter().all(|r| r.is_empty())
+}
+
+#[derive(Debug, PartialOrd, PartialEq, Eq, Ord)]
+struct CsvMandatoryColumn {
+    value: String,
+    index: usize,
+}
+
+impl CsvMandatoryColumn {
+    fn new(value: String, index: usize) -> Self {
+        CsvMandatoryColumn { value, index }
+    }
 }

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

@@ -41,8 +41,8 @@ pub fn dedup(ruby: &Ruby, previous_csv_path: String,
     let csv_headers = headers_as_byte_record(mandatory_headers.clone());
     wtr.write_byte_record(&csv_headers).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
 
-    let previous_mandatory_records = get_records(ruby, &mut previous_csv, &previous_headers, &mandatory_headers)?;
-    let new_mandatory_records = get_records(ruby, &mut new_csv, &new_headers, &mandatory_headers)?;
+    let previous_mandatory_records = get_records(ruby, &mut previous_csv, previous_headers_list, &mandatory_headers)?;
+    let new_mandatory_records = get_records(ruby, &mut new_csv, new_headers_list, &mandatory_headers)?;
 
     for new_record in new_mandatory_records {
         if !previous_mandatory_records.contains(&new_record) {
@@ -55,7 +55,7 @@ pub fn dedup(ruby: &Ruby, previous_csv_path: String,
     Ok(())
 }
 
-fn get_records(ruby: &Ruby, csv: &mut Reader<File>, csv_headers: &StringRecord, headers: &Vec<String>) -> magnus::error::Result<Vec<StringRecord>> {
+fn get_records(ruby: &Ruby, csv: &mut Reader<File>, csv_headers: Vec<String>, headers: &Vec<String>) -> magnus::error::Result<Vec<StringRecord>> {
     let header_map = create_header_map(&csv_headers);
     let mut records = vec![];
     for record in csv.records() {

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

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::error::Error;
 use std::ffi::OsStr;
 use std::path::Path;
@@ -37,18 +37,29 @@ fn check_mandatory_headers(ruby: &Ruby, headers: &Vec<String>, mandatory_headers
         return Some(Err(magnus::Error::new(ruby.exception_standard_error(), format!("{} has no mandatory headers", message))));
     }
 
-    if &csv_mandatory_headers != mandatory_headers {
-        let missing_headers = mandatory_headers.into_iter().filter(|h| !csv_mandatory_headers.contains(h)).map(|v| v.to_string()).collect::<Vec<String>>();
+    let csv_mandatory_headers = csv_mandatory_headers.to_owned().clone();
+    let mandatory_headers = mandatory_headers.to_owned().clone();
+
+    let set1 = csv_mandatory_headers.iter().collect::<HashSet<_>>();
+    let set2 = mandatory_headers.iter().collect::<HashSet<_>>();
+    let difference = set2.difference(&set1).collect::<Vec<_>>();
+
+    if !difference.is_empty() {
+        let missing_headers = difference.iter().map(|h| h.to_string()).collect::<Vec<String>>();
         return Some(Err(magnus::Error::new(ruby.exception_standard_error(), format!("{} is missing mandatory headers: {}", message, missing_headers.join(", ")))));
     }
     None
 }
 
+fn index_of_header_in_mandatory_list(mandatory_headers_list: Vec<String>, column_name: String) -> Option<usize> {
+    mandatory_headers_list.iter().position(|h| h.to_string() == column_name)
+}
+
 fn filter_headers(csv_headers: &Vec<String>, expected_headers: &Vec<String>) -> Vec<String> {
     csv_headers.iter().map(|v| v.to_string()).filter(|h| expected_headers.contains(h)).collect::<Vec<String>>()
 }
 
-fn create_header_map(headers: &StringRecord) -> HashMap<String, usize> {
+fn create_header_map(headers: &Vec<String>) -> HashMap<String, usize> {
     headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).collect()
 }
 
@@ -66,4 +77,5 @@ impl<P: AsRef<Path>> FileExtension for P {
 
         false
     }
-}
+}
+

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

@@ -6,7 +6,7 @@ use calamine::{Data, open_workbook, Range, Reader, Xls};
 use chrono::{NaiveDateTime, Utc};
 use magnus::{RArray, Ruby};
 
-use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error, check_mandatory_headers, missing_value};
+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,
@@ -31,17 +31,18 @@ pub fn to_csv(ruby: &Ruby, xls_path: String,
     if let Some(value) =
         check_mandatory_headers(ruby, &headers_list, &mandatory_headers, "csv") { return value; }
 
-    let header_map: HashMap<String, usize> = headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).collect();
+    let header_map: HashMap<String, usize> = mandatory_headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).collect();
     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)
+    write_csv(ruby, &mut dest, &range, header_map, exclusions, mandatory_headers, headers_list)
 }
 
 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>) -> magnus::error::Result<()> {
-    let n = range.get_size().1 - 1;
-
+                       header_map: HashMap<String, usize>, exclusions: Vec<String>,
+                       mandatory_headers: Vec<String>,
+                       headers_list: 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"))?;
     let start = header_map.get("Start").ok_or(missing_header(ruby, "Start"))?;
@@ -49,13 +50,15 @@ 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"))?;
 
-    for (ri, r) in range.rows().enumerate() {
+    let mandatory_rows = get_mandatory_records(ruby, range, &headers_list, &mandatory_headers)?;
+
+    for (ri, r) in mandatory_rows.into_iter().enumerate() {
         let mut date_value = Utc::now().naive_utc();
 
-        if skip_excluded_rows(&request_id, r, &exclusions) { continue; }
-        if skip_empty_rows(r) { continue; }
-        if skip_rows_with_no_request_id(&request_id, r) { continue; }
-        if date_value_is_not_present(&date, r) {
+        if skip_excluded_rows(&request_id, &r, &exclusions) { continue; }
+        if skip_empty_rows(&r) { continue; }
+        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)));
         }
 
@@ -92,21 +95,42 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>,
     Ok(())
 }
 
-fn date_value_is_not_present(date: &usize, r: &[Data]) -> bool {
-    r[*date] == Data::Empty
+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();
+
+    let mut records = vec![];
+    for row in range.rows() {
+        let mut columns = vec![];
+        for (i, column_value) in row.iter().enumerate() {
+            let column_name = inverse_header_map.get(&i).ok_or(missing_header(ruby, &i.to_string()))?;
+            if mandatory_headers_list.contains(column_name) {
+                let index = index_of_header_in_mandatory_list(mandatory_headers_list.clone(), column_name.to_string()).unwrap();
+                columns.push(XlsMandatoryColumn::new(column_value, index));
+            }
+        }
+        columns.sort_by(|a, b| a.index.cmp(&b.index));
+        let columns = columns.iter().map(|c| c.value).collect::<Vec<&Data>>();
+        records.push(columns);
+    }
+
+    Ok(records)
+}
+
+fn date_value_is_not_present(date: &usize, r: &Vec<&Data>) -> bool {
+    r[*date] == &Data::Empty
 }
 
-fn skip_excluded_rows(request_id: &usize, r: &[Data], exclusions: &Vec<String>) -> bool {
+fn skip_excluded_rows(request_id: &usize, r: &Vec<&Data>, exclusions: &Vec<String>) -> bool {
     let value = r[*request_id].to_string();
     exclusions.contains(&value.to_string())
 }
 
-fn skip_empty_rows(r: &[Data]) -> bool {
-    r.iter().all(|c| c == &Data::Empty)
+fn skip_empty_rows(r: &Vec<&Data>) -> bool {
+    r.into_iter().all(|c| c == &&Data::Empty)
 }
 
-fn skip_rows_with_no_request_id(request_id: &usize, r: &[Data]) -> bool {
-    r[*request_id] == Data::Empty
+fn skip_rows_with_no_request_id(request_id: &usize, r: &Vec<&Data>) -> bool {
+    r[*request_id] == &Data::Empty
 }
 
 fn transform_time_to_datetime(t1: NaiveDateTime, t2: NaiveDateTime) -> NaiveDateTime {
@@ -126,4 +150,15 @@ fn clean_strings(s: &str) -> String {
         .replace("\r", " ")
         .replace("\"", "")
         .replace("'", "")
-}
+}
+
+struct XlsMandatoryColumn<'a> {
+    value: &'a Data,
+    index: usize,
+}
+
+impl<'a> XlsMandatoryColumn<'a> {
+    fn new(value: &'a Data, index: usize) -> Self {
+        XlsMandatoryColumn { value, index }
+    }
+}

data/lib/csv_utils/version.rb

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

metadata

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