patchwork_csv_utils 0.1.10-aarch64-linux

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/csv_utils"]
+resolver = "2"

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in csv_utils.gemspec
+gemspec
+
+group :development do
+  gem 'rake', '~> 13.0'
+  gem 'rake-compiler'
+  gem 'rb_sys', '~> 0.9.98'
+  gem 'rspec', '~> 3.0'
+  gem 'rubocop', '~> 1.21'
+end

data/Gemfile.lock

@@ -0,0 +1,70 @@
+PATH
+  remote: .
+  specs:
+    patchwork_csv_utils (0.1.10)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.1)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    parallel (1.25.1)
+    parser (3.3.4.0)
+      ast (~> 2.4.1)
+      racc
+    racc (1.8.0)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    rake-compiler (1.2.7)
+      rake
+    rb_sys (0.9.98)
+    regexp_parser (2.9.2)
+    rexml (3.3.2)
+      strscan
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (1.65.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.4, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    ruby-progressbar (1.13.0)
+    strscan (3.1.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  arm64-darwin-22
+  arm64-darwin-23
+  x86_64-linux
+
+DEPENDENCIES
+  patchwork_csv_utils!
+  rake (~> 13.0)
+  rake-compiler
+  rb_sys (~> 0.9.98)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.4.10

data/README.md

@@ -0,0 +1,33 @@
+# CsvUtils
+
+* dedup: Given 2 CSV files, this gem will create a third CSV file that contains rows from the first CSV file that are not present in the second CSV file.
+* xls to csv: Given an XLS file, this gem will create a CSV file with the specified name.
+
+## Installation
+
+```bash
+gem install patchwork_csv_utils
+```
+
+## Usage
+
+```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']])
+```
+
+## Release
+
+* to release a new version, update the version number in `lib/patchwork_csv_utils/version.rb`
+* push the changes to github and then create a tag with the version number
+
+```bash
+git tag -a v0.1.0 -m "v0.1.0"
+git push origin --tags
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at http://github.com/patchworkhealth/csv_utils.

data/Rakefile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+require 'rb_sys/extensiontask'
+
+task build: :compile
+
+spec = Bundler.load_gemspec('patchwork_csv_utils.gemspec')
+
+Rake::ExtensionTask.new('csv_utils', spec) do |c|
+  c.lib_dir = 'lib/csv_utils'
+  c.cross_compile = true
+  c.cross_platform = %w[
+    aarch64-linux
+    arm64-darwin
+    x64-mingw-ucrt
+    x64-mingw32
+    x86_64-darwin
+    x86_64-linux
+    x86_64-linux-musl
+  ]
+end
+
+RbSys::ExtensionTask.new('csv_utils') do |ext|
+  ext.lib_dir = 'lib/csv_utils'
+end
+
+task default: %i[compile spec rubocop]

data/ext/csv_utils/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "csv_utils"
+version = "0.1.0"
+edition = "2021"
+authors = ["kingsley.hendrickse <kingsley.hendrickse@patchwork.health>"]
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.7.1" }
+csv = "1.3.0"
+calamine = {  version = "0.25.0", features = ["dates"] }
+chrono = "0.4.38"

data/ext/csv_utils/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('csv_utils/csv_utils')

data/ext/csv_utils/src/lib.rs

@@ -0,0 +1,15 @@
+use magnus::{define_module, function, prelude::*};
+use crate::utils::csv::transform_csv;
+use crate::utils::dedup::dedup;
+use crate::utils::xls::to_csv;
+
+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))?;
+    Ok(())
+}

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

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+use std::fs::File;
+
+use chrono::{NaiveDate, NaiveDateTime, NaiveTime, Utc};
+use csv::{StringRecord, Writer};
+use magnus::{Error, RArray, Ruby};
+
+use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error};
+
+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 column_name = get_column_name(&inverse_header_map, &i);
+                process_datetime(ruby, ri, date_value, c, &column_name)
+            } 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 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 {
+        return Ok(correct.to_string());
+    }
+
+    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())
+}
+
+fn get_column_name(inverse_header_map: &HashMap<usize, String>, i: &usize) -> String {
+    let unknown = "Unknown".to_string();
+    let column_name = inverse_header_map.get(&i).unwrap_or(&unknown);
+    column_name.to_string()
+}
+
+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> {
+    let maybe_correct = correct_datetime(s);
+    if maybe_correct.is_some() { return maybe_correct; }
+
+    NaiveDate::parse_from_str(s, "%d-%b-%y").ok().map(|d| d.and_hms_opt(0, 0, 0)).flatten()
+}
+
+fn correct_datetime(s: &str) -> Option<NaiveDateTime> {
+    NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S").ok()
+}
+
+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 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

@@ -0,0 +1,69 @@
+use std::fs::File;
+
+use csv::{StringRecord, Writer};
+use magnus::Ruby;
+
+use crate::utils::{FileExtension, magnus_err};
+
+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()));
+    }
+
+    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 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"))?;
+
+    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"))?;
+
+    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 has_empty_row_skip(&previous_record) { continue; }
+        if has_empty_first_col_skip_row(&previous_record) { continue; }
+
+        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"))?;
+
+        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) {
+            wtr.write_byte_record(new_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 has_empty_first_col_skip_row(previous_record: &StringRecord) -> bool {
+    previous_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/mod.rs

@@ -0,0 +1,36 @@
+use std::error::Error;
+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()))
+}
+
+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))
+}
+
+pub trait FileExtension {
+    fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool;
+}
+
+impl<P: AsRef<Path>> FileExtension for P {
+    fn has_extension<S: AsRef<str>>(&self, extensions: &[S]) -> bool {
+        if let Some(ref extension) = self.as_ref().extension().and_then(OsStr::to_str) {
+            return extensions
+                .iter()
+                .any(|x| x.as_ref().eq_ignore_ascii_case(extension));
+        }
+
+        false
+    }
+}

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

@@ -0,0 +1,114 @@
+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 magnus::{RArray, Ruby};
+
+use crate::utils::{FileExtension, magnus_err, missing_header, to_datetime_error};
+
+pub fn to_csv(ruby: &Ruby, xls_path: String, target_path: String, exclusions: 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 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()))
+        .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 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)
+}
+
+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(&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() {
+            match *c {
+                Data::Empty => Ok(()),
+                Data::String(ref s) | Data::DateTimeIso(ref s) | Data::DurationIso(ref s) => {
+                    handle_commas(dest, s)
+                }
+                Data::Float(ref f) => write!(dest, "{}", f),
+                Data::DateTime(ref d) => {
+                    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 {
+                        current = transform_time_to_datetime(date_value, current);
+                    }
+                    write!(dest, "{}", current)
+                }
+                Data::Int(ref i) => write!(dest, "{}", i),
+                Data::Error(ref e) => write!(dest, "{:?}", e),
+                Data::Bool(ref b) => write!(dest, "{}", b),
+            }.map_err(|e| magnus_err(ruby, e, format!("error writing xls row: {}, column: {}", ri, i).as_str()))?;
+            if i != n {
+                write!(dest, ",").map_err(|e| magnus_err(ruby, e, format!("error writing csv comma for row: {}, column: {}", ri, i).as_str()))?;
+            }
+        }
+        write!(dest, "\r\n").map_err(|e| magnus_err(ruby, e, format!("error writing end of line for row: {}", ri).as_str()))?;
+    }
+    Ok(())
+}
+
+fn date_value_is_not_present(date: &usize, r: &[Data]) -> bool {
+    r[*date] == Data::Empty
+}
+
+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_empty_rows(r: &[Data]) -> bool {
+    r.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 transform_time_to_datetime(t1: NaiveDateTime, t2: NaiveDateTime) -> NaiveDateTime {
+    NaiveDateTime::new(t1.date(), t2.time())
+}
+
+fn handle_commas<W: Write>(dest: &mut W, s: &str) -> std::io::Result<()> {
+    if s.contains(",") {
+        write!(dest, "{:?}", clean_strings(s).trim_end())
+    } else {
+        write!(dest, "{}", clean_strings(s).trim_end())
+    }
+}
+
+fn clean_strings(s: &str) -> String {
+    s.replace("\n", " ")
+        .replace("\r", " ")
+        .replace("\"", "")
+        .replace("'", "")
+}

data/lib/csv_utils/version.rb

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

data/lib/csv_utils.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# load native extension
+begin
+  ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
+  require_relative "csv_utils/#{ruby_version}/csv_utils"
+rescue LoadError
+  require_relative 'csv_utils/csv_utils'
+end
+
+require_relative 'csv_utils/version'
+
+module CsvUtils
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: patchwork_csv_utils
+version: !ruby/object:Gem::Version
+  version: 0.1.10
+platform: aarch64-linux
+authors:
+- kingsley.hendrickse
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-08-09 00:00:00.000000000 Z
+dependencies: []
+description: Deduplication of CSV files and XLS to CSV conversion.
+email:
+- kingsley.hendrickse@patchwork.health
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- Cargo.lock
+- Cargo.toml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- 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
+- lib/csv_utils.rb
+- lib/csv_utils/2.7/csv_utils.so
+- lib/csv_utils/3.0/csv_utils.so
+- lib/csv_utils/3.1/csv_utils.so
+- lib/csv_utils/3.2/csv_utils.so
+- lib/csv_utils/version.rb
+homepage: http://github.com/patchworkhealth/csv_utils
+licenses: []
+metadata:
+  homepage_uri: http://github.com/patchworkhealth/csv_utils
+  source_code_uri: http://github.com/patchworkhealth/csv_utils
+  rubygems_mfa_required: 'false'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.3.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.4
+signing_key: 
+specification_version: 4
+summary: Fast CSV utils
+test_files: []