osv 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17db543fc59ce3ec7b4ea87a0d403b82a628860ca01ba03eaea39438790b7863
-  data.tar.gz: 3d54507b6097b7b9e0a771f5a3c72d7605b27c5307528bf0707cd0f7ba29b474
+  metadata.gz: 9a6579b30fb8761382666c3fcfa434d9234c3ebf508cad7b3045b9f4ebc2f8b7
+  data.tar.gz: afb793b1df201e876e955ed75904c729aa353bdee3ae374085902efdd4601603
 SHA512:
-  metadata.gz: 975e4e16a32d1c2d5678f1c4ede658165fcf247f563c166fa167bff7d9bfd95c34937f894207693df2e6716b61fce8c315b6bb4dad7a29d68161ab842768eca1
-  data.tar.gz: 9176674f894855098875df2c3287b4370b42193f84d7bdf20d13fa8ea9de9330a431c3070a00652458bbb0a8061866e69b4849a6ee71c1b90718e811d1ed7172
+  metadata.gz: 4318353ec8b32f026d3a3c8675a26b6a6545faba213bba28ada9b0ab7d978ea8d7dd6a8e202aaefb765040cc0d54990fd94f8263bbf4ecd6a4150ab9f48e7cc6
+  data.tar.gz: d0c590105f070773f82a2e00c0c069439c55055cfe958e7eb3bcf443a83fb1d3dd1f099b93f2835a30797024451666e42f18aeaa361432824d18f77cfaa4748f

data/README.md

@@ -1,13 +1,13 @@
 # OSV
 
+[![Gem Version](https://badge.fury.io/rb/osv.svg)](https://badge.fury.io/rb/osv)
+
 OSV is a high-performance CSV parser for Ruby, implemented in Rust. It wraps BurntSushi's excellent [csv-rs](https://github.com/BurntSushi/rust-csv) crate.
 
 It provides a simple interface for reading CSV files with support for both hash-based and array-based row formats.
 
 The array-based mode is faster than the hash-based mode, so if you don't need the hash keys, use the array-based mode.
 
-I have yet to figure out how to get rust to accept an implementation of this as one method with different return types, so I've had to implement two methods.
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -53,7 +53,7 @@ rows.each { |row| puts row["name"] }
 If you prefer working with arrays instead of hashes, use `for_each_compat`:
 
 ```ruby
-OSV.for_each_compat("path/to/file.csv") do |row|
+OSV.for_each("path/to/file.csv", result_type: :array) do |row|
   # row is an Array like ["John", "25"]
   puts row[0]
 end
@@ -64,11 +64,11 @@ end
 Both methods support the following options:
 
 - `has_headers`: Boolean indicating if the first row contains headers (default: true)
-- `delimiter`: String specifying the field separator (default: ",")
+- `col_sep`: String specifying the field separator (default: ",")
 
 ```ruby
 # Reading TSV files
-OSV.for_each("path/to/file.tsv", delimiter: "\t") do |row|
+OSV.for_each("path/to/file.tsv", col_sep: "\t") do |row|
   puts row["name"]
 end
 
@@ -111,7 +111,3 @@ OSV.for_each(data) { |row| puts row["name"] }
 ## Performance
 
 This library is faster than the standard Ruby CSV library, and is comparable to the fastest CSV parser gems I've used.
-
-## License
-
-This gem is not currently licensed for public use.

data/ext/osv/src/csv/builder.rs

@@ -0,0 +1,112 @@
+use super::{
+    parser::RecordParser,
+    reader::{ReadImpl, RecordReader},
+};
+use magnus::{rb_sys::AsRawValue, value::ReprValue, Error, RString, Ruby, Value};
+use std::{fs::File, io::Read, marker::PhantomData, os::fd::FromRawFd, thread};
+
+pub struct RecordReaderBuilder<'a, T: RecordParser + Send + 'static> {
+    ruby: &'a Ruby,
+    to_read: Value,
+    has_headers: bool,
+    delimiter: u8,
+    quote_char: u8,
+    null_string: String,
+    buffer: usize,
+    _phantom: PhantomData<T>,
+}
+
+impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
+    pub fn new(ruby: &'a Ruby, to_read: Value) -> Self {
+        Self {
+            ruby,
+            to_read,
+            has_headers: true,
+            delimiter: b',',
+            quote_char: b'"',
+            null_string: String::new(),
+            buffer: 1000,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn has_headers(mut self, has_headers: bool) -> Self {
+        self.has_headers = has_headers;
+        self
+    }
+
+    pub fn delimiter(mut self, delimiter: u8) -> Self {
+        self.delimiter = delimiter;
+        self
+    }
+
+    pub fn quote_char(mut self, quote_char: u8) -> Self {
+        self.quote_char = quote_char;
+        self
+    }
+
+    pub fn null_string(mut self, null_string: String) -> Self {
+        self.null_string = null_string;
+        self
+    }
+
+    pub fn buffer(mut self, buffer: usize) -> Self {
+        self.buffer = buffer;
+        self
+    }
+
+    fn get_reader(&self) -> Result<Box<dyn Read + Send + 'static>, Error> {
+        let string_io: magnus::RClass = self.ruby.eval("StringIO")?;
+
+        if self.to_read.is_kind_of(string_io) {
+            let string: RString = self.to_read.funcall("string", ())?;
+            let content = string.to_string()?;
+            Ok(Box::new(std::io::Cursor::new(content)))
+        } else if self.to_read.is_kind_of(self.ruby.class_io()) {
+            let fd = unsafe { rb_sys::rb_io_descriptor(self.to_read.as_raw()) };
+            let file = unsafe { File::from_raw_fd(fd) };
+            Ok(Box::new(file))
+        } else {
+            let path = self.to_read.to_r_string()?.to_string()?;
+            let file = std::fs::File::open(&path).map_err(|e| {
+                Error::new(
+                    self.ruby.exception_runtime_error(),
+                    format!("Failed to open file: {e}"),
+                )
+            })?;
+            Ok(Box::new(file))
+        }
+    }
+
+    pub fn build(self) -> Result<RecordReader<T>, Error> {
+        let readable = self.get_reader()?;
+        let mut reader = csv::ReaderBuilder::new()
+            .has_headers(self.has_headers)
+            .delimiter(self.delimiter)
+            .quote(self.quote_char)
+            .from_reader(readable);
+
+        let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;
+        let null_string = self.null_string;
+
+        let (sender, receiver) = kanal::bounded(self.buffer);
+        let handle = thread::spawn(move || {
+            let mut record = csv::StringRecord::new();
+            while let Ok(true) = reader.read_record(&mut record) {
+                let row = T::parse(&headers, &record, &null_string);
+                if sender.send(row).is_err() {
+                    break;
+                }
+            }
+            let file_to_forget = reader.into_inner();
+            std::mem::forget(file_to_forget);
+        });
+
+        Ok(RecordReader {
+            reader: ReadImpl::MultiThreaded {
+                receiver,
+                handle: Some(handle),
+            },
+        })
+    }
+}

data/ext/osv/src/csv/mod.rs

@@ -0,0 +1,8 @@
+mod builder;
+mod parser;
+mod reader;
+mod record;
+
+pub use builder::RecordReaderBuilder;
+pub use record::CsvRecord;
+

data/ext/osv/src/csv/parser.rs

@@ -0,0 +1,51 @@
+use std::collections::HashMap;
+
+pub trait RecordParser {
+    type Output;
+    fn parse<'a>(
+        headers: &'a [String],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output;
+}
+
+impl RecordParser for HashMap<String, Option<String>> {
+    type Output = Self;
+    fn parse<'a>(
+        headers: &'a [String],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output {
+        let mut map = HashMap::with_capacity(headers.len());
+        for (header, field) in headers.iter().zip(record.iter()) {
+            map.insert(
+                header.clone(),
+                if field == null_string {
+                    None
+                } else {
+                    Some(field.to_string())
+                },
+            );
+        }
+        map
+    }
+}
+
+impl RecordParser for Vec<Option<String>> {
+    type Output = Self;
+    fn parse<'a>(
+        _headers: &'a [String],
+        record: &csv::StringRecord,
+        null_string: &str,
+    ) -> Self::Output {
+        let mut vec = Vec::with_capacity(record.len());
+        for field in record.iter() {
+            vec.push(if field == null_string {
+                None
+            } else {
+                Some(field.to_string())
+            });
+        }
+        vec
+    }
+}

data/ext/osv/src/csv/reader.rs

@@ -0,0 +1,73 @@
+use super::parser::RecordParser;
+use magnus::{Error, Ruby};
+use std::{io::Read, thread};
+
+pub struct RecordReader<T: RecordParser> {
+    pub(crate) reader: ReadImpl<T>,
+}
+
+#[allow(dead_code)]
+pub enum ReadImpl<T: RecordParser> {
+    SingleThreaded {
+        reader: csv::Reader<Box<dyn Read + Send + 'static>>,
+        headers: Vec<String>,
+        null_string: String,
+    },
+    MultiThreaded {
+        receiver: kanal::Receiver<T::Output>,
+        handle: Option<thread::JoinHandle<()>>,
+    },
+}
+
+impl<T: RecordParser> RecordReader<T> {
+    pub(crate) fn get_headers(
+        ruby: &Ruby,
+        reader: &mut csv::Reader<impl Read>,
+        has_headers: bool,
+    ) -> Result<Vec<String>, Error> {
+        let first_row = reader
+            .headers()
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to read headers: {e}"),
+                )
+            })?
+            .clone();
+
+        Ok(if has_headers {
+            first_row.iter().map(String::from).collect()
+        } else {
+            (0..first_row.len()).map(|i| format!("c{i}")).collect()
+        })
+    }
+}
+
+impl<T: RecordParser> Iterator for RecordReader<T> {
+    type Item = T::Output;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.reader {
+            ReadImpl::MultiThreaded { receiver, handle } => match receiver.recv() {
+                Ok(record) => Some(record),
+                Err(_) => {
+                    if let Some(handle) = handle.take() {
+                        let _ = handle.join();
+                    }
+                    None
+                }
+            },
+            ReadImpl::SingleThreaded {
+                reader,
+                headers,
+                null_string,
+            } => {
+                let mut record = csv::StringRecord::new();
+                match reader.read_record(&mut record) {
+                    Ok(true) => Some(T::parse(headers, &record, null_string)),
+                    _ => None,
+                }
+            }
+        }
+    }
+}

data/ext/osv/src/csv/record.rs

@@ -0,0 +1,17 @@
+use magnus::{IntoValue, Ruby, Value};
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub enum CsvRecord {
+    Vec(Vec<Option<String>>),
+    Map(HashMap<String, Option<String>>),
+}
+
+impl IntoValue for CsvRecord {
+    fn into_value_with(self, handle: &Ruby) -> Value {
+        match self {
+            CsvRecord::Vec(vec) => vec.into_value_with(handle),
+            CsvRecord::Map(map) => map.into_value_with(handle),
+        }
+    }
+}

data/ext/osv/src/lib.rs

@@ -1,3 +1,4 @@
+mod csv;
 mod reader;
 mod utils;
 
@@ -10,6 +11,5 @@ use magnus::{Error, Ruby};
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("OSV")?;
     module.define_module_function("for_each", magnus::method!(parse_csv, -1))?;
-    module.define_module_function("for_each_compat", magnus::method!(parse_compat, -1))?;
     Ok(())
 }

data/ext/osv/src/reader.rs

@@ -1,235 +1,100 @@
+use std::collections::HashMap;
+
+use crate::csv::{CsvRecord, RecordReaderBuilder};
 use crate::utils::*;
-use magnus::{
-    block::Yield, rb_sys::AsRawValue, value::ReprValue, Error, RClass, RString, Ruby, Value,
-};
-use std::{collections::HashMap, fs::File, io::Read, os::fd::FromRawFd, thread};
+use magnus::value::ReprValue;
+use magnus::{block::Yield, Error, KwArgs, RHash, Ruby, Symbol, Value};
 
-/// Parses CSV data from a file and yields each row as a hash to the block.
 pub fn parse_csv(
     ruby: &Ruby,
     rb_self: Value,
     args: &[Value],
-) -> Result<Yield<impl Iterator<Item = HashMap<String, String>>>, Error> {
-    if !ruby.block_given() {
-        return Ok(Yield::Enumerator(rb_self.enumeratorize("for_each", args)));
-    }
-    let (to_read, has_headers, delimiter) = parse_csv_args(args)?;
-
-    let iter = RecordReader::<HashMap<String, String>>::new(
-        ruby,
+) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord>>>, Error> {
+    let CsvArgs {
         to_read,
         has_headers,
-        delimiter.unwrap_or_else(|| ",".to_string()).as_bytes()[0],
-        1000,
-    )?;
+        delimiter,
+        quote_char,
+        null_string,
+        buffer_size,
+        result_type,
+    } = parse_csv_args(ruby, args)?;
 
-    Ok(Yield::Iter(iter))
-}
-
-pub fn parse_compat(
-    ruby: &Ruby,
-    rb_self: Value,
-    args: &[Value],
-) -> Result<Yield<impl Iterator<Item = Vec<String>>>, Error> {
     if !ruby.block_given() {
-        return Ok(Yield::Enumerator(
-            rb_self.enumeratorize("for_each_compat", args),
-        ));
-    }
-    let (to_read, has_headers, delimiter) = parse_csv_args(args)?;
-
-    let iter = RecordReader::<Vec<String>>::new(
-        ruby,
-        to_read,
-        has_headers,
-        delimiter.unwrap_or_else(|| ",".to_string()).as_bytes()[0],
-        1000,
-    )?;
-
-    Ok(Yield::Iter(iter))
-}
-
-pub trait RecordParser {
-    type Output;
-
-    fn parse(headers: &[String], record: &csv::StringRecord) -> Self::Output;
-}
-
-impl RecordParser for HashMap<String, String> {
-    type Output = Self;
-
-    fn parse(headers: &[String], record: &csv::StringRecord) -> Self::Output {
-        let capacity = headers.len();
-        let mut map = HashMap::with_capacity(capacity);
-        for (i, field) in record.iter().enumerate() {
-            map.insert(headers[i].to_owned(), field.to_string());
-        }
-        map
+        return create_enumerator(EnumeratorArgs {
+            rb_self,
+            to_read,
+            has_headers,
+            delimiter,
+            quote_char,
+            null_string,
+            buffer_size,
+            result_type,
+        });
     }
-}
-
-impl RecordParser for Vec<String> {
-    type Output = Self;
 
-    fn parse(_headers: &[String], record: &csv::StringRecord) -> Self::Output {
-        let mut output = Vec::with_capacity(record.len());
-        for field in record.iter() {
-            output.push(field.to_string());
+    let iter: Box<dyn Iterator<Item = CsvRecord>> = match result_type.as_str() {
+        "hash" => Box::new(
+            RecordReaderBuilder::<HashMap<String, Option<String>>>::new(ruby, to_read)
+                .has_headers(has_headers)
+                .delimiter(delimiter)
+                .quote_char(quote_char)
+                .null_string(null_string)
+                .buffer(buffer_size)
+                .build()?
+                .map(CsvRecord::Map),
+        ),
+        "array" => Box::new(
+            RecordReaderBuilder::<Vec<Option<String>>>::new(ruby, to_read)
+                .has_headers(has_headers)
+                .delimiter(delimiter)
+                .quote_char(quote_char)
+                .null_string(null_string)
+                .buffer(buffer_size)
+                .build()?
+                .map(CsvRecord::Vec),
+        ),
+        _ => {
+            return Err(Error::new(
+                ruby.exception_runtime_error(),
+                "Invalid result type",
+            ))
         }
-        output
-    }
-}
-
-struct RecordReader<T: RecordParser> {
-    reader: ReadImpl<T>,
-}
+    };
 
-#[allow(dead_code)]
-enum ReadImpl<T: RecordParser> {
-    SingleThreaded {
-        reader: csv::Reader<Box<dyn Read + Send + 'static>>,
-        headers: Vec<String>,
-    },
-    MultiThreaded {
-        receiver: kanal::Receiver<T::Output>,
-        handle: Option<thread::JoinHandle<()>>,
-    },
+    Ok(Yield::Iter(iter))
 }
 
-impl<T: RecordParser + Send + 'static> RecordReader<T> {
-    fn new(
-        ruby: &Ruby,
-        to_read: Value,
-        has_headers: bool,
-        delimiter: u8,
-        buffer: usize,
-    ) -> Result<Self, Error> {
-        let string_io: RClass = ruby.eval("StringIO").map_err(|e| {
-            Error::new(
-                ruby.exception_runtime_error(),
-                format!("Failed to get StringIO class: {}", e),
-            )
-        })?;
-
-        let readable: Box<dyn Read + Send + 'static> = if to_read.is_kind_of(string_io) {
-            let string: RString = to_read.funcall("string", ()).map_err(|e| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to get string from StringIO: {}", e),
-                )
-            })?;
-            let content = string.to_string().map_err(|e| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to convert string to Rust String: {}", e),
-                )
-            })?;
-            Box::new(std::io::Cursor::new(content))
-        } else if to_read.is_kind_of(ruby.class_io()) {
-            let fd = unsafe { rb_sys::rb_io_descriptor(to_read.as_raw()) };
-            let file = unsafe { File::from_raw_fd(fd) };
-            Box::new(file)
-        } else {
-            let path = to_read
-                .to_r_string()
-                .map_err(|e| {
-                    Error::new(
-                        ruby.exception_runtime_error(),
-                        format!("Failed to convert path to string: {}", e),
-                    )
-                })?
-                .to_string()
-                .map_err(|e| {
-                    Error::new(
-                        ruby.exception_runtime_error(),
-                        format!("Failed to convert RString to Rust String: {}", e),
-                    )
-                })?;
-            let file = std::fs::File::open(&path).map_err(|e| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to open file: {}", e),
-                )
-            })?;
-            Box::new(file)
-        };
-
-        let mut reader = csv::ReaderBuilder::new()
-            .has_headers(has_headers)
-            .delimiter(delimiter)
-            .from_reader(readable);
-
-        let headers = Self::get_headers(&mut reader, has_headers)?;
-        let headers_clone = headers.clone();
-
-        let (sender, receiver) = kanal::bounded(buffer);
-        let handle = thread::spawn(move || {
-            let mut record = csv::StringRecord::new();
-            while let Ok(read) = reader.read_record(&mut record) {
-                if !read {
-                    let file_to_forget = reader.into_inner();
-                    std::mem::forget(file_to_forget);
-                    break;
-                }
-                let row = T::parse(&headers_clone, &record);
-                if sender.send(row).is_err() {
-                    break;
-                }
-            }
-        });
-
-        let read_impl = ReadImpl::MultiThreaded {
-            receiver,
-            handle: Some(handle),
-        };
-
-        Ok(Self { reader: read_impl })
-    }
-
-    fn get_headers(
-        reader: &mut csv::Reader<impl Read>,
-        has_headers: bool,
-    ) -> Result<Vec<String>, Error> {
-        let first_row = reader
-            .headers()
-            .map_err(|e| {
-                Error::new(
-                    magnus::exception::runtime_error(),
-                    format!("Failed to read headers: {}", e),
-                )
-            })?
-            .clone();
-        let num_fields = first_row.len();
-
-        Ok(if has_headers {
-            first_row.iter().map(|h| h.to_string()).collect()
-        } else {
-            (0..num_fields).map(|i| format!("c{}", i)).collect()
-        })
-    }
+struct EnumeratorArgs {
+    rb_self: Value,
+    to_read: Value,
+    has_headers: bool,
+    delimiter: u8,
+    quote_char: u8,
+    null_string: String,
+    buffer_size: usize,
+    result_type: String,
 }
 
-impl<T: RecordParser> Iterator for RecordReader<T> {
-    type Item = T::Output;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match &mut self.reader {
-            ReadImpl::MultiThreaded { receiver, handle } => match receiver.recv() {
-                Ok(record) => Some(record),
-                Err(_) => {
-                    if let Some(handle) = handle.take() {
-                        let _ = handle.join();
-                    }
-                    None
-                }
-            },
-            ReadImpl::SingleThreaded { reader, headers } => {
-                let mut record = csv::StringRecord::new();
-                match reader.read_record(&mut record) {
-                    Ok(true) => Some(T::parse(headers, &record)),
-                    _ => None,
-                }
-            }
-        }
-    }
+fn create_enumerator(
+    args: EnumeratorArgs,
+) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord>>>, Error> {
+    let kwargs = RHash::new();
+    kwargs.aset(Symbol::new("has_headers"), args.has_headers)?;
+    kwargs.aset(
+        Symbol::new("col_sep"),
+        String::from_utf8(vec![args.delimiter]).unwrap(),
+    )?;
+    kwargs.aset(
+        Symbol::new("quote_char"),
+        String::from_utf8(vec![args.quote_char]).unwrap(),
+    )?;
+    kwargs.aset(Symbol::new("nil_string"), args.null_string)?;
+    kwargs.aset(Symbol::new("buffer_size"), args.buffer_size)?;
+    kwargs.aset(Symbol::new("result_type"), Symbol::new(args.result_type))?;
+
+    let enumerator = args
+        .rb_self
+        .enumeratorize("for_each", (args.to_read, KwArgs(kwargs)));
+    Ok(Yield::Enumerator(enumerator))
 }

data/ext/osv/src/utils.rs

@@ -1,20 +1,123 @@
 use magnus::{
     scan_args::{get_kwargs, scan_args},
-    Error, Value,
+    value::ReprValue,
+    Error, RString, Ruby, Symbol, Value,
 };
 
+#[derive(Debug)]
+pub struct CsvArgs {
+    pub to_read: Value,
+    pub has_headers: bool,
+    pub delimiter: u8,
+    pub quote_char: u8,
+    pub null_string: String,
+    pub buffer_size: usize,
+    pub result_type: String,
+}
+
 /// Parse common arguments for CSV parsing
-pub fn parse_csv_args(args: &[Value]) -> Result<(Value, bool, Option<String>), Error> {
+pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
     let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
     let (to_read,) = parsed_args.required;
 
-    let kwargs = get_kwargs::<_, (), (Option<bool>, Option<String>), ()>(
+    let kwargs = get_kwargs::<
+        _,
+        (),
+        (
+            Option<bool>,
+            Option<String>,
+            Option<String>,
+            Option<String>,
+            Option<usize>,
+            Option<Value>,
+        ),
+        (),
+    >(
         parsed_args.keywords,
         &[],
-        &["has_headers", "delimiter"],
+        &[
+            "has_headers",
+            "col_sep",
+            "quote_char",
+            "nil_string",
+            "buffer_size",
+            "result_type",
+        ],
     )?;
 
     let has_headers = kwargs.optional.0.unwrap_or(true);
 
-    Ok((to_read, has_headers, kwargs.optional.1))
+    let delimiter = *kwargs
+        .optional
+        .1
+        .unwrap_or_else(|| ",".to_string())
+        .as_bytes()
+        .first()
+        .ok_or_else(|| {
+            Error::new(
+                magnus::exception::runtime_error(),
+                "Delimiter cannot be empty",
+            )
+        })?;
+
+    let quote_char = *kwargs
+        .optional
+        .2
+        .unwrap_or_else(|| "\"".to_string())
+        .as_bytes()
+        .first()
+        .ok_or_else(|| {
+            Error::new(
+                magnus::exception::runtime_error(),
+                "Quote character cannot be empty",
+            )
+        })?;
+
+    let null_string = kwargs.optional.3.unwrap_or_else(|| "".to_string());
+
+    let buffer_size = kwargs.optional.4.unwrap_or(1000);
+
+    let result_type = match kwargs.optional.5 {
+        Some(value) => {
+            let parsed = if value.is_kind_of(ruby.class_string()) {
+                RString::from_value(value)
+                    .ok_or_else(|| {
+                        Error::new(magnus::exception::type_error(), "Invalid string value")
+                    })?
+                    .to_string()?
+            } else if value.is_kind_of(ruby.class_symbol()) {
+                Symbol::from_value(value)
+                    .ok_or_else(|| {
+                        Error::new(magnus::exception::type_error(), "Invalid symbol value")
+                    })?
+                    .funcall("to_s", ())?
+            } else {
+                return Err(Error::new(
+                    magnus::exception::type_error(),
+                    "result_type must be a String or Symbol",
+                ));
+            };
+
+            match parsed.as_str() {
+                "hash" | "array" => parsed,
+                _ => {
+                    return Err(Error::new(
+                        magnus::exception::runtime_error(),
+                        "result_type must be either 'hash' or 'array'",
+                    ))
+                }
+            }
+        }
+        None => String::from("hash"),
+    };
+
+    Ok(CsvArgs {
+        to_read,
+        has_headers,
+        delimiter,
+        quote_char,
+        null_string,
+        buffer_size,
+        result_type,
+    })
 }

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

data/lib/osv.rbi

@@ -2,28 +2,26 @@
 
 module OSV
   sig do
-    type_parameters(:T)
-      .params(
-        input: T.any(String, StringIO, IO),
-        has_headers: T.nilable(T::Boolean),
-        delimiter: T.nilable(String),
-        blk: T.proc.params(row: T::Hash[String, String]).void
-      )
-      .returns(T.untyped)
+    params(
+      input: T.any(String, StringIO, IO),
+      has_headers: T.nilable(T::Boolean),
+      col_sep: T.nilable(String),
+      quote_char: T.nilable(String),
+      nil_string: T.nilable(String),
+      buffer_size: T.nilable(Integer),
+      result_type: T.nilable(String),
+      blk: T.nilable(T.proc.params(row: T.any(T::Hash[String, T.nilable(String)], T::Array[T.nilable(String)])).void)
+    ).returns(T.any(Enumerator, T.untyped))
   end
-  def self.for_each(input, has_headers: true, delimiter: nil, &blk)
-  end
-
-  sig do
-    type_parameters(:T)
-      .params(
-        input: T.any(String, StringIO, IO),
-        has_headers: T.nilable(T::Boolean),
-        delimiter: T.nilable(String),
-        blk: T.proc.params(row: T::Array[String]).void
-      )
-      .returns(T.untyped)
-  end
-  def self.for_each_compat(input, has_headers: true, delimiter: nil, &blk)
+  def self.for_each(
+    input,
+    has_headers: true,
+    col_sep: nil,
+    quote_char: nil,
+    nil_string: nil,
+    buffer_size: nil,
+    result_type: nil,
+    &blk
+  )
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Nathan Jaremko
@@ -55,6 +55,11 @@ files:
 - ext/osv/Cargo.lock
 - ext/osv/Cargo.toml
 - ext/osv/extconf.rb
+- ext/osv/src/csv/builder.rs
+- ext/osv/src/csv/mod.rs
+- ext/osv/src/csv/parser.rs
+- ext/osv/src/csv/reader.rs
+- ext/osv/src/csv/record.rs
 - ext/osv/src/lib.rs
 - ext/osv/src/reader.rs
 - ext/osv/src/utils.rs