osv 0.3.20 → 0.3.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5d6f70d75ffe07595c68bf9c1d4c26d3c6f8fcb3dd1f6bcde44de036558584d
-  data.tar.gz: 70e7d68fe4e42755ed54fd900ef8eb871741ff9c17e683ae7aa7d3f20801c7da
+  metadata.gz: 26bda7b8aed144013156dea4f4f68c322b0a2042d6478c225edde0c44f54452f
+  data.tar.gz: cd63b6b71c158d8a09196a4fff496c5c7e7a9ac2c9a64724bbf31c56ff9ee0c7
 SHA512:
-  metadata.gz: 1b2817f12cef251ee9006ba93483b7c7a529e3302579148ef998513b5401fa8eeef924ba3553b1a95515437d905239ce08e5ab4117160d2aabd37ebf4c70fbd8
-  data.tar.gz: 5beb1952d332923bc4703dfdd7b8e234d785f548c0c5724706aad78302234f5f76b4c0094968354ff29eee5d03d5ed2e6ff633649c7a0e6092291b9824f77eac
+  metadata.gz: 947a7cc0d9f644977d157d0424893daf10c62efee5b4d544f81731ca7f04056cc75bab464560f4aea0b793b4b4e6e63a964fed8adace0c232cd388182a709a3a
+  data.tar.gz: 78536bdbba174b441792e39dc3b1c2ca08d85bafe4dce7763156160abcc611bb38c0743e6cadfd5d3466410b42fa0e598dc32e4865393109b8c88ec9673bf44b

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

@@ -34,6 +34,10 @@ pub enum ReaderError {
     InvalidFlexibleDefault(String),
     #[error("Invalid null string value: {0}")]
     InvalidNullString(String),
+    #[error("Failed to parse CSV record: {0}")]
+    CsvParse(#[from] csv::Error),
+    #[error("Invalid UTF-8: {0}")]
+    InvalidUtf8(String),
     #[error("Ruby error: {0}")]
     Ruby(String),
 }
@@ -46,10 +50,20 @@ impl From<MagnusError> for ReaderError {
 
 impl From<ReaderError> for MagnusError {
     fn from(err: ReaderError) -> Self {
-        MagnusError::new(
-            Ruby::get().unwrap().exception_runtime_error(),
-            err.to_string(),
-        )
+        let ruby = Ruby::get().unwrap();
+        match err {
+            ReaderError::CsvParse(csv_err) => {
+                if csv_err.to_string().contains("invalid utf-8") {
+                    MagnusError::new(ruby.exception_encoding_error(), csv_err.to_string())
+                } else {
+                    MagnusError::new(ruby.exception_runtime_error(), csv_err.to_string())
+                }
+            }
+            ReaderError::InvalidUtf8(utf8_err) => {
+                MagnusError::new(ruby.exception_encoding_error(), utf8_err.to_string())
+            }
+            _ => MagnusError::new(ruby.exception_runtime_error(), err.to_string()),
+        }
     }
 }
 
@@ -199,7 +213,8 @@ impl<'a, T: RecordParser<'a>> RecordReaderBuilder<'a, T> {
             .trim(self.trim)
             .from_reader(reader);
 
-        let mut headers = RecordReader::<T>::get_headers(&self.ruby, &mut reader, self.has_headers)?;
+        let mut headers =
+            RecordReader::<T>::get_headers(&self.ruby, &mut reader, self.has_headers)?;
         if self.ignore_null_bytes {
             headers = headers.iter().map(|h| h.replace("\0", "")).collect();
         }

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

@@ -42,10 +42,9 @@ impl<'a, S: BuildHasher + Default> RecordParser<'a>
                         None
                     } else if field.is_empty() {
                         Some(CowStr(shared_empty.clone()))
-                    } else if ignore_null_bytes  {
+                    } else if ignore_null_bytes {
                         Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-                    }
-                    else {
+                    } else {
                         Some(CowStr(Cow::Owned(field.to_string())))
                     }
                 },
@@ -78,10 +77,9 @@ impl<'a> RecordParser<'a> for Vec<Option<CowStr<'a>>> {
                 None
             } else if field.is_empty() {
                 Some(CowStr(shared_empty.clone()))
-            } else if ignore_null_bytes  {
+            } else if ignore_null_bytes {
                 Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-            }
-            else {
+            } else {
                 Some(CowStr(Cow::Owned(field.to_string())))
             };
             vec.push(value);

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

@@ -1,3 +1,4 @@
+use super::builder::ReaderError;
 use super::header_cache::StringCacheKey;
 use super::parser::RecordParser;
 use super::{header_cache::StringCache, ruby_reader::SeekableRead};
@@ -72,28 +73,31 @@ impl<'a, T: RecordParser<'a>> RecordReader<'a, T> {
     }
 
     /// Attempts to read the next record, returning any errors encountered.
-    fn try_next(&mut self) -> csv::Result<Option<T::Output>> {
-        match self.reader.read_record(&mut self.string_record)? {
-            true => Ok(Some(T::parse(
+    fn try_next(&mut self) -> Result<Option<T::Output>, ReaderError> {
+        if self.reader.read_record(&mut self.string_record)? {
+            Ok(Some(T::parse(
                 &self.headers,
                 &self.string_record,
                 self.null_string.clone(),
                 self.flexible_default.clone(),
-                self.ignore_null_bytes
-            ))),
-            false => Ok(None),
+                self.ignore_null_bytes,
+            )))
+        } else {
+            Ok(None)
         }
     }
 }
 
 impl<'a, T: RecordParser<'a>> Iterator for RecordReader<'a, T> {
-    type Item = T::Output;
+    type Item = Result<T::Output, ReaderError>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        // Note: We intentionally swallow errors here to maintain Iterator contract.
-        // Errors can be handled by using try_next() directly if needed.
-        self.try_next().ok().flatten()
+        match self.try_next() {
+            Ok(Some(record)) => Some(Ok(record)),
+            Ok(None) => None,
+            Err(e) => Some(Err(e)),
+        }
     }
 
     #[inline]

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

@@ -1,4 +1,5 @@
 use magnus::{
+    error::Error as MagnusError,
     value::{Opaque, ReprValue},
     RClass, RString, Ruby, Value,
 };
@@ -6,7 +7,7 @@ use std::fs::File;
 use std::io::{self, BufReader, Read, Seek, SeekFrom, Write};
 use std::sync::OnceLock;
 
-use super::ForgottenFileHandle;
+use super::{builder::ReaderError, ForgottenFileHandle};
 
 static STRING_IO_CLASS: OnceLock<Opaque<RClass>> = OnceLock::new();
 
@@ -25,10 +26,7 @@ impl<T: Read + Seek> SeekableRead for BufReader<T> {}
 impl SeekableRead for std::io::Cursor<Vec<u8>> {}
 impl SeekableRead for ForgottenFileHandle {}
 
-pub fn build_ruby_reader(
-    ruby: &Ruby,
-    input: Value,
-) -> Result<Box<dyn SeekableRead>, magnus::Error> {
+pub fn build_ruby_reader(ruby: &Ruby, input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
     if RubyReader::is_string_io(ruby, &input) {
         RubyReader::from_string_io(ruby, input)
     } else if RubyReader::is_io_like(&input) {
@@ -88,14 +86,14 @@ impl Seek for RubyReader<RString> {
 }
 
 impl RubyReader<Value> {
-    fn from_io(input: Value) -> Result<Box<dyn SeekableRead>, magnus::Error> {
+    fn from_io(input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
         if Self::is_io_like(&input) {
             Ok(Box::new(Self::from_io_like(input)))
         } else {
-            Err(magnus::Error::new(
+            Err(MagnusError::new(
                 magnus::exception::type_error(),
                 "Input is not an IO-like object",
-            ))
+            ))?
         }
     }
 
@@ -112,15 +110,12 @@ impl RubyReader<Value> {
 }
 
 impl RubyReader<RString> {
-    pub fn from_string_io(
-        ruby: &Ruby,
-        input: Value,
-    ) -> Result<Box<dyn SeekableRead>, magnus::Error> {
+    pub fn from_string_io(ruby: &Ruby, input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
         if !Self::is_string_io(ruby, &input) {
-            return Err(magnus::Error::new(
+            return Err(MagnusError::new(
                 magnus::exception::type_error(),
                 "Input is not a StringIO",
-            ));
+            ))?;
         }
 
         let string_content = input.funcall::<_, _, RString>("string", ()).unwrap();
@@ -138,11 +133,11 @@ impl RubyReader<RString> {
         input.is_kind_of(ruby.get_inner(*string_io_class))
     }
 
-    fn from_string_like(input: Value) -> Result<Box<dyn SeekableRead>, magnus::Error> {
-        // Try calling `to_str`, and if that fails, try `to_s`
+    fn from_string_like(input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
         let string_content = input
             .funcall::<_, _, RString>("to_str", ())
             .or_else(|_| input.funcall::<_, _, RString>("to_s", ()))?;
+
         Ok(Box::new(Self {
             inner: string_content,
             offset: 0,
@@ -154,12 +149,16 @@ impl Read for RubyReader<Value> {
     fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
         let bytes = self
             .inner
-            .funcall::<_, _, RString>("read", (buf.len(),))
+            .funcall::<_, _, Option<RString>>("read", (buf.len(),))
             .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
 
-        buf.write_all(unsafe { bytes.as_slice() })?;
-
-        Ok(bytes.len())
+        match bytes {
+            Some(bytes) => {
+                buf.write_all(unsafe { bytes.as_slice() })?;
+                Ok(bytes.len())
+            }
+            None => Ok(0), // EOF
+        }
     }
 }
 

data/ext/osv/src/reader.rs

@@ -3,7 +3,7 @@ use crate::utils::*;
 use ahash::RandomState;
 use csv::Trim;
 use magnus::value::ReprValue;
-use magnus::{block::Yield, Error, KwArgs, RHash, Ruby, Symbol, Value};
+use magnus::{Error, IntoValue, KwArgs, RHash, Ruby, Symbol, Value};
 use std::collections::HashMap;
 
 /// Valid result types for CSV parsing
@@ -36,6 +36,7 @@ struct EnumeratorArgs {
     flexible: bool,
     flexible_default: Option<String>,
     trim: Option<String>,
+    ignore_null_bytes: bool,
 }
 
 /// Parses a CSV file with the given configuration.
@@ -43,10 +44,7 @@ struct EnumeratorArgs {
 /// # 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> {
+pub fn parse_csv(rb_self: Value, args: &[Value]) -> Result<Value, Error> {
     //  SAFETY: We're in a Ruby callback, so Ruby runtime is guaranteed to be initialized
     let ruby = unsafe { Ruby::get_unchecked() };
 
@@ -80,7 +78,9 @@ pub fn parse_csv(
                 Trim::Fields => Some("fields".to_string()),
                 _ => None,
             },
-        });
+            ignore_null_bytes,
+        })
+        .map(|yield_enum| yield_enum.into_value_with(&ruby));
     }
 
     let result_type = ResultType::from_str(&result_type).ok_or_else(|| {
@@ -90,7 +90,7 @@ pub fn parse_csv(
         )
     })?;
 
-    let iter: Box<dyn Iterator<Item = CsvRecord<RandomState>>> = match result_type {
+    match result_type {
         ResultType::Hash => {
             let builder = RecordReaderBuilder::<
                 HashMap<StringCacheKey, Option<CowStr<'static>>, RandomState>,
@@ -105,7 +105,11 @@ pub fn parse_csv(
             .ignore_null_bytes(ignore_null_bytes)
             .build()?;
 
-            Box::new(builder.map(CsvRecord::Map))
+            let ruby = unsafe { Ruby::get_unchecked() };
+            for result in builder {
+                let record = result?;
+                let _: Value = ruby.yield_value(CsvRecord::Map(record))?;
+            }
         }
         ResultType::Array => {
             let builder = RecordReaderBuilder::<Vec<Option<CowStr<'static>>>>::new(ruby, to_read)
@@ -119,17 +123,20 @@ pub fn parse_csv(
                 .ignore_null_bytes(ignore_null_bytes)
                 .build()?;
 
-            Box::new(builder.map(CsvRecord::Vec))
+            let ruby = unsafe { Ruby::get_unchecked() };
+            for result in builder {
+                let record = result?;
+                let _: Value = ruby.yield_value(CsvRecord::<ahash::RandomState>::Vec(record))?;
+            }
         }
-    };
+    }
 
-    Ok(Yield::Iter(iter))
+    let ruby = unsafe { Ruby::get_unchecked() };
+    Ok(ruby.qnil().into_value_with(&ruby))
 }
 
 /// Creates an enumerator for lazy CSV parsing
-fn create_enumerator(
-    args: EnumeratorArgs,
-) -> Result<Yield<Box<dyn Iterator<Item = CsvRecord<'static, RandomState>>>>, Error> {
+fn create_enumerator(args: EnumeratorArgs) -> Result<magnus::Enumerator, Error> {
     let kwargs = RHash::new();
     kwargs.aset(Symbol::new("has_headers"), args.has_headers)?;
     kwargs.aset(
@@ -145,9 +152,9 @@ fn create_enumerator(
     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))?;
+    kwargs.aset(Symbol::new("ignore_null_bytes"), args.ignore_null_bytes)?;
 
-    let enumerator = args
+    Ok(args
         .rb_self
-        .enumeratorize("for_each", (args.to_read, KwArgs(kwargs)));
-    Ok(Yield::Enumerator(enumerator))
+        .enumeratorize("for_each", (args.to_read, KwArgs(kwargs))))
 }

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.3.20"
+  VERSION = "0.3.22"
 end

metadata

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