patchwork_csv_utils 0.1.10-x86_64-darwin → 0.1.12-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72e35abdab7312e9c3545c6e9fff0da8039f09bffe97079b58d08a0d4a9ca628
-  data.tar.gz: '0921d2c89388526c85dd0d90f2acb7e8196c6a0092be4f3a7e2850250933d250'
+  metadata.gz: 6641485d47a1ac2560273f63ee4666a84648b03c2fd493fdbf822f71b95b5058
+  data.tar.gz: 1c0d98407df7fbd7b1d50a16457cc672a6542bf854655ac402b546ff58fed05c
 SHA512:
-  metadata.gz: 57f867bac3fb86038544d65e757d22ef61007ec26360717c11e9227cd60f936d5da945c05df7ad198c63743cbc0e1159e17abf630c106077cf5287f9d318db65
-  data.tar.gz: 8c8713f243205f6e751151d59276b0f7219d90dd4d5028d2539a7578f7c0951af79bb72eebbd99be20763da10fa9e38169a1db33012deb625881aba64e4ebe14
+  metadata.gz: d0e184033fa2e6ed8418ccafd4f7747aa8111e490167031295efbc147f5d1a12f991ff3934af269e65872c3f1d2ef2140c11160ce8fb6143b52e4f790c4ad5cf
+  data.tar.gz: d767afc020114a7ae899ac63e775f20e3bdc4547aecaae86199d6ca87d08c982a32397447d2340a6fd4aa3872f77624f46219803eaa186ad2cd37a286992b194

data/Gemfile.lock

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

data/README.md

@@ -13,9 +13,9 @@ 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', ['request_ids_to_skip']])
-CsvUtils.transform_csv('file1.xls', 'output_file1.csv', ['request_ids_to_skip']])
+CsvUtils.dedup('file1.csv', 'file2.csv', 'output.csv', ['mandatory_headers'])
+CsvUtils.to_csv('file1.xls', 'output_file1.csv', ['request_ids_to_skip'], ['mandatory_headers'])
+CsvUtils.transform_csv('file1.xls', 'output_file1.csv', ['request_ids_to_skip'], ['mandatory_headers'])
 ```
 
 ## Release

data/ext/csv_utils/src/lib.rs

@@ -8,8 +8,8 @@ pub mod utils;
 #[magnus::init]
 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))?;
+    module.define_singleton_method("dedup", function!(dedup, 4))?;
+    module.define_singleton_method("to_csv", function!(to_csv, 4))?;
+    module.define_singleton_method("transform_csv", function!(transform_csv, 4))?;
     Ok(())
 }

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

@@ -2,26 +2,35 @@ use std::collections::HashMap;
 use std::fs::File;
 
 use chrono::{NaiveDate, NaiveDateTime, NaiveTime, Utc};
-use csv::{StringRecord, Writer};
+use csv::{Reader, StringRecord, Writer};
 use magnus::{Error, RArray, Ruby};
 
-use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error};
+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) -> magnus::error::Result<()> {
+pub fn transform_csv(ruby: &Ruby, csv_path: String,
+                     target_path: String, exclusions: RArray,
+                     mandatory_headers: 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()));
+        return Err(Error::new(ruby.exception_standard_error(), "csv_path must be a csv file".to_string()));
     }
 
     let exclusions = RArray::to_vec(exclusions)?;
+    let mandatory_headers: Vec<String> = RArray::to_vec(mandatory_headers)?;
 
     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 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"))?;
-    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();
+    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();
 
-    wtr.write_byte_record(headers.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
+    if let Some(value) =
+        check_mandatory_headers(ruby, &headers_list, &mandatory_headers, "csv") { return value; }
+
+    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"))?;
 
     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"))?;
@@ -30,8 +39,9 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String, target_path: String, exclusi
     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; }
@@ -39,22 +49,29 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String, target_path: String, exclusi
 
         let mut date_value = Utc::now().naive_utc();
 
-        let record = record.iter().enumerate().map(|(i, c)| {
-            let c = c.trim_end();
+        let mut columns = vec![];
+        for (i, column) in mandatory_headers.iter().enumerate() {
+            let column_index = header_map.get(column).ok_or(missing_header(ruby, column))?;
+            let column_value = record.get(*column_index).ok_or(missing_value(ruby, column))?;
+            let column_value = column_value.trim_end();
+
             if i == *date {
-                let current = string_to_datetime(c).ok_or(to_datetime_error(ruby, c, ri, "Date"))?;
+                let current = string_to_datetime(column_value).ok_or(to_datetime_error(ruby, column_value, ri, "Date"))?;
                 date_value = current;
-                Ok(current.to_string())
+                columns.push(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 column_name = get_column_name(&inverse_header_map, &i);
-                process_datetime(ruby, ri, date_value, c, &column_name)
+                if column_value.is_empty() {
+                    columns.push(column_value.to_string());
+                } else {
+                    let column_name = get_column_name(&inverse_header_map, &i);
+                    let current = process_datetime(ruby, ri, date_value, column_value, &column_name)?;
+                    columns.push(current);
+                }
             } else {
-                Ok(c.to_string())
+                columns.push(column_value.to_string());
             }
-        }).collect::<Result<StringRecord, magnus::Error>>()?;
-
-        let record = record.into_iter().map(|r| r.trim_end()).collect::<StringRecord>();
+        }
+        let record = columns.into_iter().collect::<StringRecord>();
         wtr.write_byte_record(record.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
     }
 
@@ -63,6 +80,28 @@ pub fn transform_csv(ruby: &Ruby, csv_path: String, target_path: String, exclusi
     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 {
@@ -110,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

@@ -1,54 +1,51 @@
 use std::fs::File;
 
-use csv::{StringRecord, Writer};
-use magnus::Ruby;
+use csv::{Reader, StringRecord, Writer};
+use magnus::{RArray, Ruby};
 
-use crate::utils::{FileExtension, magnus_err};
+use crate::utils::{FileExtension, magnus_err, check_mandatory_headers, create_header_map, missing_header, missing_value, headers_as_byte_record};
 
-pub fn dedup(ruby: &Ruby, previous_csv_path: String, new_csv_path: String, target_path: String) -> magnus::error::Result<()> {
-    if !previous_csv_path.has_extension(&["csv"]) {
-        return Err(magnus::Error::new(ruby.exception_standard_error(), "previous_csv_path must be a csv file".to_string()));
-    }
-    if !new_csv_path.has_extension(&["csv"]) {
-        return Err(magnus::Error::new(ruby.exception_standard_error(), "new_csv_path must be a csv file".to_string()));
-    }
+pub fn dedup(ruby: &Ruby, previous_csv_path: String,
+             new_csv_path: String,
+             target_path: String,
+             mandatory_headers: RArray,
+) -> magnus::error::Result<()> {
+    if let Some(value) =
+        check_file_extension(ruby, &previous_csv_path, "previous_csv_path") { return value; }
+
+    if let Some(value) =
+        check_file_extension(ruby, &new_csv_path, "new_csv_path") { return value; }
 
     let csv1 = File::open(previous_csv_path).map_err(|e| magnus_err(ruby, e, "previous_csv_path"))?;
     let csv2 = File::open(new_csv_path).map_err(|e| magnus_err(ruby, e, "new_csv_path"))?;
 
+    let mandatory_headers: Vec<String> = RArray::to_vec(mandatory_headers)?;
+
     let mut previous_csv: csv::Reader<File> = csv::Reader::from_reader(csv1);
     let mut new_csv: csv::Reader<File> = csv::Reader::from_reader(csv2);
 
     let mut wtr = Writer::from_path(target_path).map_err(|e| magnus_err(ruby, e, "target_path"))?;
 
-    let previous_headers = previous_csv.headers().map_err(|e| magnus_err(ruby, e, "previous_csv_path headers"))?;
-    let new_headers = new_csv.headers().map_err(|e| magnus_err(ruby, e, "new_csv_path headers"))?;
+    let previous_headers = previous_csv.headers().map_err(|e| magnus_err(ruby, e, "previous_csv"))?.clone();
+    let previous_headers_list : Vec<String> = previous_headers.iter().map(|h| h.to_string()).collect();
+    let new_headers = new_csv.headers().map_err(|e| magnus_err(ruby, e, "new_csv"))?.clone();
+    let new_headers_list : Vec<String> = new_headers.iter().map(|h| h.to_string()).collect();
 
-    if previous_headers != new_headers {
-        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()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
+    if let Some(value) =
+        check_mandatory_headers(ruby, &previous_headers_list, &mandatory_headers, "previous_csv") { return value; }
 
-    let mut previous_records = vec![];
-    for previous_record in previous_csv.records() {
-        let previous_record = previous_record.map_err(|e| magnus_err(ruby, e, "previous_record"))?;
+    if let Some(value) =
+        check_mandatory_headers(ruby, &new_headers_list, &mandatory_headers, "new_csv") { return value; }
 
-        if has_empty_row_skip(&previous_record) { continue; }
-        if has_empty_first_col_skip_row(&previous_record) { continue; }
+    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_record = previous_record.into_iter().map(|r| r.trim_end()).collect::<StringRecord>();
-        previous_records.push(previous_record)
-    }
-
-    for new_record in new_csv.records() {
-        let new_record = new_record.map_err(|e| magnus_err(ruby, e, "new_record"))?;
+    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)?;
 
-        if has_empty_row_skip(&new_record) { continue; }
-        if has_empty_first_col_skip_row(&new_record) { continue; }
-
-        let new_record = new_record.into_iter().map(|r| r.trim_end()).collect::<StringRecord>();
-        if !previous_records.contains(&new_record) {
+    for new_record in new_mandatory_records {
+        if !previous_mandatory_records.contains(&new_record) {
             wtr.write_byte_record(new_record.as_byte_record()).map_err(|e| magnus_err(ruby, e, "write_byte_record"))?;
         }
     }
@@ -58,6 +55,34 @@ pub fn dedup(ruby: &Ruby, previous_csv_path: String, new_csv_path: String, targe
     Ok(())
 }
 
+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() {
+        let record = record.map_err(|e| magnus_err(ruby, e, "record error"))?;
+
+        if has_empty_row_skip(&record) { continue; }
+        if has_empty_first_col_skip_row(&record) { continue; }
+
+        let mut columns = vec![];
+        for column in headers.iter() {
+            let column_index = header_map.get(column).ok_or(missing_header(ruby, column))?;
+            let column_value = record.get(*column_index).ok_or(missing_value(ruby, column))?;
+            columns.push(column_value.trim_end());
+        }
+        let columns = columns.into_iter().collect::<StringRecord>();
+        records.push(columns);
+    }
+    Ok(records)
+}
+
+fn check_file_extension(ruby: &Ruby, csv_path: &String, message: &str) -> Option<magnus::error::Result<()>> {
+    if !csv_path.has_extension(&["csv"]) {
+        return Some(Err(magnus::Error::new(ruby.exception_standard_error(), format!("{} must be a csv file", message))));
+    }
+    None
+}
+
 fn has_empty_first_col_skip_row(previous_record: &StringRecord) -> bool {
     previous_record[0].is_empty()
 }

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

@@ -1,6 +1,8 @@
+use std::collections::{HashMap, HashSet};
 use std::error::Error;
 use std::ffi::OsStr;
 use std::path::Path;
+use ::csv::{ByteRecord, StringRecord};
 use magnus::Ruby;
 
 pub mod csv;
@@ -11,6 +13,15 @@ fn missing_header(ruby: &Ruby, header: &str) -> magnus::Error {
     magnus::Error::new(ruby.exception_standard_error(), format!("Missing '{}' header", header))
 }
 
+fn missing_value(ruby: &Ruby, header: &str) -> magnus::Error {
+    magnus::Error::new(ruby.exception_standard_error(), format!("Missing value for '{}' header", header))
+}
+
+fn headers_as_byte_record(headers: Vec<String>) -> ByteRecord {
+    let string_record = headers.into_iter().collect::<StringRecord>();
+    string_record.as_byte_record().clone()
+}
+
 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()))
 }
@@ -19,6 +30,39 @@ fn to_datetime_error(ruby: &Ruby, value: &str, row: usize, col: &str) -> magnus:
     magnus::Error::new(ruby.exception_standard_error(), format!("Could not parse datetime '{}', row: {}, col: {}", value, row, col))
 }
 
+fn check_mandatory_headers(ruby: &Ruby, headers: &Vec<String>, mandatory_headers: &Vec<String>, message: &str) -> Option<magnus::error::Result<()>> {
+    let csv_mandatory_headers = filter_headers(headers, mandatory_headers);
+
+    if csv_mandatory_headers.is_empty() {
+        return Some(Err(magnus::Error::new(ruby.exception_standard_error(), format!("{} has no mandatory headers", message))));
+    }
+
+    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: &Vec<String>) -> HashMap<String, usize> {
+    headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).collect()
+}
+
 pub trait FileExtension {
     fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool;
 }
@@ -33,4 +77,5 @@ impl<P: AsRef<Path>> FileExtension for P {
 
         false
     }
-}
+}
+

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

@@ -6,14 +6,19 @@ 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};
+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) -> magnus::error::Result<()> {
+pub fn to_csv(ruby: &Ruby, xls_path: String,
+              target_path: String,
+              exclusions: RArray,
+              mandatory_headers: RArray
+) -> 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()));
     }
 
     let exclusions = RArray::to_vec(exclusions)?;
+    let mandatory_headers: Vec<String> = RArray::to_vec(mandatory_headers)?;
 
     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)
@@ -21,14 +26,22 @@ pub fn to_csv(ruby: &Ruby, xls_path: String, target_path: String, exclusions: RA
         .and_then(|r| r.map_err(|e| magnus_err(ruby, e, "could not read worksheet range")))?;
 
     let headers = range.headers().ok_or(magnus::Error::new(ruby.exception_standard_error(), "no headers found in xls".to_string()))?;
-    let header_map: HashMap<String, usize> = headers.iter().enumerate().map(|(i, h)| (h.to_string(), i)).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> = 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)
+    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>) -> magnus::error::Result<()> {
+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>) -> 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"))?;
@@ -38,17 +51,23 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>, header_ma
     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)));
         }
 
-        for (i, c) in r.iter().enumerate() {
+        for (i, c) in mandatory_headers.iter().enumerate() {
+
+            let column_index = header_map.get(c).ok_or(missing_header(ruby, c))?;
+            let c = r.get(*column_index).ok_or(missing_value(ruby, c))?;
+
             match *c {
                 Data::Empty => Ok(()),
                 Data::String(ref s) | Data::DateTimeIso(ref s) | Data::DurationIso(ref s) => {
@@ -77,21 +96,42 @@ fn write_csv<W: Write>(ruby: &Ruby, dest: &mut W, range: &Range<Data>, header_ma
     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 skip_excluded_rows(request_id: &usize, r: &[Data], exclusions: &Vec<String>) -> bool {
+fn date_value_is_not_present(date: &usize, r: &Vec<&Data>) -> bool {
+    r[*date] == &Data::Empty
+}
+
+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 {
@@ -111,4 +151,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.10'
+  VERSION = '0.1.12'
 end

metadata

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