osv 0.3.15 → 0.3.17

data/ext/osv/src/reader.rs

@@ -1,4 +1,4 @@
-use crate::csv::{CowValue, CsvRecord, RecordReaderBuilder};
+use crate::csv::{CowStr, CsvRecord, RecordReaderBuilder, StringCacheKey};
 use crate::utils::*;
 use ahash::RandomState;
 use csv::Trim;
@@ -6,12 +6,49 @@ use magnus::value::ReprValue;
 use magnus::{block::Yield, Error, KwArgs, RHash, Ruby, Symbol, Value};
 use std::collections::HashMap;
 
+/// Valid result types for CSV parsing
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ResultType {
+    Hash,
+    Array,
+}
+
+impl ResultType {
+    fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "hash" => Some(Self::Hash),
+            "array" => Some(Self::Array),
+            _ => None,
+        }
+    }
+}
+
+/// Arguments for creating an enumerator
+#[derive(Debug)]
+struct EnumeratorArgs {
+    rb_self: Value,
+    to_read: Value,
+    has_headers: bool,
+    delimiter: u8,
+    quote_char: u8,
+    null_string: Option<String>,
+    result_type: String,
+    flexible: bool,
+    flexible_default: Option<String>,
+    trim: Option<String>,
+}
+
+/// Parses a CSV file with the given configuration.
+///
+/// # Safety
+/// This function uses unsafe code to get the Ruby runtime and leak memory for static references.
+/// This is necessary for Ruby integration but should be used with caution.
 pub fn parse_csv(
     rb_self: Value,
     args: &[Value],
 ) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord<'static, RandomState>>>>, Error> {
-    let original = unsafe { Ruby::get_unchecked() };
-    let ruby: &'static Ruby = Box::leak(Box::new(original));
+    //  SAFETY: We're in a Ruby callback, so Ruby runtime is guaranteed to be initialized
+    let ruby = unsafe { Ruby::get_unchecked() };
 
     let ReadCsvArgs {
         to_read,
@@ -19,16 +56,11 @@ pub fn parse_csv(
         delimiter,
         quote_char,
         null_string,
-        buffer_size,
         result_type,
         flexible,
         flexible_default,
         trim,
-    } = parse_read_csv_args(ruby, args)?;
-
-    let flexible_default: &'static Option<String> = Box::leak(Box::new(flexible_default));
-    let leaked_flexible_default: &'static Option<&str> =
-        Box::leak(Box::new(flexible_default.as_deref()));
+    } = parse_read_csv_args(&ruby, args)?;
 
     if !ruby.block_given() {
         return create_enumerator(EnumeratorArgs {
@@ -38,10 +70,9 @@ pub fn parse_csv(
             delimiter,
             quote_char,
             null_string,
-            buffer_size,
-            result_type,
+            result_type: result_type,
             flexible,
-            flexible_default: leaked_flexible_default.as_deref(),
+            flexible_default: flexible_default,
             trim: match trim {
                 Trim::All => Some("all".to_string()),
                 Trim::Headers => Some("headers".to_string()),
@@ -51,60 +82,47 @@ pub fn parse_csv(
         });
     }
 
-    let iter: Box<dyn Iterator<Item = CsvRecord<RandomState>>> = match result_type.as_str() {
-        "hash" => {
+    let result_type = ResultType::from_str(&result_type).ok_or_else(|| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Invalid result type, expected 'hash' or 'array'",
+        )
+    })?;
+
+    let iter: Box<dyn Iterator<Item = CsvRecord<RandomState>>> = match result_type {
+        ResultType::Hash => {
             let builder = RecordReaderBuilder::<
-                HashMap<&'static str, Option<CowValue<'static>>, RandomState>,
+                HashMap<StringCacheKey, Option<CowStr<'static>>, RandomState>,
             >::new(ruby, to_read)
             .has_headers(has_headers)
             .flexible(flexible)
-            .flexible_default(flexible_default.as_deref())
+            .flexible_default(flexible_default)
             .trim(trim)
             .delimiter(delimiter)
             .quote_char(quote_char)
-            .null_string(null_string)
-            .buffer(buffer_size);
+            .null_string(null_string);
 
-            Box::new(builder.build_threaded()?.map(CsvRecord::Map))
+            Box::new(builder.build()?.map(CsvRecord::Map))
         }
-        "array" => Box::new(
-            RecordReaderBuilder::<Vec<Option<CowValue<'static>>>>::new(ruby, to_read)
+        ResultType::Array => {
+            let builder = RecordReaderBuilder::<Vec<Option<CowStr<'static>>>>::new(ruby, to_read)
                 .has_headers(has_headers)
                 .flexible(flexible)
-                .flexible_default(flexible_default.as_deref())
+                .flexible_default(flexible_default)
                 .trim(trim)
                 .delimiter(delimiter)
                 .quote_char(quote_char)
                 .null_string(null_string)
-                .buffer(buffer_size)
-                .build_threaded()?
-                .map(CsvRecord::Vec),
-        ),
-        _ => {
-            return Err(Error::new(
-                ruby.exception_runtime_error(),
-                "Invalid result type",
-            ))
+                .build()?;
+
+            Box::new(builder.map(CsvRecord::Vec))
         }
     };
 
     Ok(Yield::Iter(iter))
 }
 
-struct EnumeratorArgs {
-    rb_self: Value,
-    to_read: Value,
-    has_headers: bool,
-    delimiter: u8,
-    quote_char: u8,
-    null_string: Option<String>,
-    buffer_size: usize,
-    result_type: String,
-    flexible: bool,
-    flexible_default: Option<&'static str>,
-    trim: Option<String>,
-}
-
+/// Creates an enumerator for lazy CSV parsing
 fn create_enumerator(
     args: EnumeratorArgs,
 ) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord<'static, RandomState>>>>, Error> {
@@ -119,11 +137,11 @@ fn create_enumerator(
         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))?;
     kwargs.aset(Symbol::new("flexible"), args.flexible)?;
     kwargs.aset(Symbol::new("flexible_default"), args.flexible_default)?;
     kwargs.aset(Symbol::new("trim"), args.trim.map(Symbol::new))?;
+
     let enumerator = args
         .rb_self
         .enumeratorize("for_each", (args.to_read, KwArgs(kwargs)));

data/ext/osv/src/utils.rs

@@ -4,8 +4,6 @@ use magnus::{
     Error, RString, Ruby, Symbol, Value,
 };
 
-use crate::csv::BUFFER_CHANNEL_SIZE;
-
 fn parse_string_or_symbol(ruby: &Ruby, value: Value) -> Result<Option<String>, Error> {
     if value.is_nil() {
         Ok(None)
@@ -34,7 +32,6 @@ pub struct ReadCsvArgs {
     pub delimiter: u8,
     pub quote_char: u8,
     pub null_string: Option<String>,
-    pub buffer_size: usize,
     pub result_type: String,
     pub flexible: bool,
     pub flexible_default: Option<String>,
@@ -54,7 +51,6 @@ pub fn parse_read_csv_args(ruby: &Ruby, args: &[Value]) -> Result<ReadCsvArgs, E
             Option<String>,
             Option<String>,
             Option<Option<String>>,
-            Option<usize>,
             Option<Value>,
             Option<bool>,
             Option<Option<String>>,
@@ -69,7 +65,6 @@ pub fn parse_read_csv_args(ruby: &Ruby, args: &[Value]) -> Result<ReadCsvArgs, E
             "col_sep",
             "quote_char",
             "nil_string",
-            "buffer_size",
             "result_type",
             "flexible",
             "flexible_default",
@@ -107,11 +102,9 @@ pub fn parse_read_csv_args(ruby: &Ruby, args: &[Value]) -> Result<ReadCsvArgs, E
 
     let null_string = kwargs.optional.3.unwrap_or_default();
 
-    let buffer_size = kwargs.optional.4.unwrap_or(BUFFER_CHANNEL_SIZE);
-
     let result_type = match kwargs
         .optional
-        .5
+        .4
         .map(|value| parse_string_or_symbol(ruby, value))
     {
         Some(Ok(Some(parsed))) => match parsed.as_str() {
@@ -133,13 +126,13 @@ pub fn parse_read_csv_args(ruby: &Ruby, args: &[Value]) -> Result<ReadCsvArgs, E
         None => String::from("hash"),
     };
 
-    let flexible = kwargs.optional.6.unwrap_or_default();
+    let flexible = kwargs.optional.5.unwrap_or_default();
 
-    let flexible_default = kwargs.optional.7.unwrap_or_default();
+    let flexible_default = kwargs.optional.6.unwrap_or_default();
 
     let trim = match kwargs
         .optional
-        .8
+        .7
         .map(|value| parse_string_or_symbol(ruby, value))
     {
         Some(Ok(Some(parsed))) => match parsed.as_str() {
@@ -172,7 +165,6 @@ pub fn parse_read_csv_args(ruby: &Ruby, args: &[Value]) -> Result<ReadCsvArgs, E
         delimiter,
         quote_char,
         null_string,
-        buffer_size,
         result_type,
         flexible,
         flexible_default,

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.3.15"
+  VERSION = "0.3.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.3.15
+  version: 0.3.17
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-03 00:00:00.000000000 Z
+date: 2025-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys