osv 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cae389fff24c3109f17a1c450022771da964e1b7dced4ed2f34f93753c213dc8
-  data.tar.gz: 1e3736fb0b84003f62a5038a3d7e71e7d6e31581f943452c2acb08b04a21ff64
+  metadata.gz: a791a08d1a1c44fcc4e69df668e1c04e9e099e8388d048f7e058aea2a7ee3305
+  data.tar.gz: 2616a3ab845191c29fb3f852f8a1a3a1cc51c33d39e5f4bc7b0da3ae733bf9f3
 SHA512:
-  metadata.gz: ddae565f1b208de7fc18fa1cdaff7b3d1ed02ec22bf85d0477a9b152d9238049893a5ef40bad95ac4b2d8f8cb0cd59f14fd4e365aa69f3ef109fa6f6701d2499
-  data.tar.gz: aa81197d39f7e3dcc5732bfb7d71545cd9303d888ee7da1a34b0244ade287a8b25db16f7428d4f09689dfe1d874d3663bebb6d546e6b363f7496137339b15150
+  metadata.gz: 4d1a816e49ffbf62dcd33dd8a2d3c49f32bac34ddfe2681e58a55839e33afadf4487c7e216e67bf878071272d0fc129370a598657fb3fb0bc8ec6c7934e6de3d
+  data.tar.gz: 67f8f1416e8f11cac750e60b46437293bd41421a2ea3de9b5557a78ea78c34e2be8251a62c9650f16af449c0f534d807c7aabd838c274486d3cfe0eaef7eecde

data/Cargo.lock

@@ -15,7 +15,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -30,12 +30,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "autocfg"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
-
 [[package]]
 name = "bindgen"
 version = "0.69.5"
@@ -133,6 +127,22 @@ version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
+[[package]]
+name = "errno"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
 [[package]]
 name = "flate2"
 version = "1.0.35"
@@ -144,20 +154,26 @@ dependencies = [
 ]
 
 [[package]]
-name = "futures-core"
-version = "0.3.31"
+name = "getrandom"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets",
 ]
 
 [[package]]
@@ -210,16 +226,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "kanal"
-version = "0.1.0-pre8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05d55519627edaf7fd0f29981f6dc03fb52df3f5b257130eb8d0bf2801ea1d7"
-dependencies = [
- "futures-core",
- "lock_api",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -259,14 +265,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "lock_api"
-version = "0.4.12"
+name = "linux-raw-sys"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "magnus"
@@ -358,12 +360,12 @@ dependencies = [
  "flate2",
  "itertools 0.14.0",
  "jemallocator",
- "kanal",
  "magnus 0.7.1",
  "mimalloc",
  "rb-sys",
  "serde",
  "serde_magnus",
+ "tempfile",
  "thiserror",
 ]
 
@@ -451,16 +453,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
-name = "ryu"
-version = "1.0.18"
+name = "rustix"
+version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
 
 [[package]]
-name = "scopeguard"
-version = "1.2.0"
+name = "ryu"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "seq-macro"
@@ -528,6 +537,20 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
+[[package]]
+name = "tempfile"
+version = "3.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e5a0acb1f3f55f65cc4a866c361b2fb2a0ff6366785ae6fbb5f85df07ba230"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "getrandom 0.3.1",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.9"
@@ -566,6 +589,24 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -630,6 +671,15 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.35"

data/README.md

@@ -143,34 +143,34 @@ OSV - Gzipped Direct     1.000 i/100ms
    FastCSV - Gzipped     1.000 i/100ms
        CSV - Gzipped     1.000 i/100ms
 Calculating -------------------------------------
-      CSV - StringIO      0.083 (± 0.0%) i/s    (12.06 s/i) -      3.000 in  36.304469s
-  FastCSV - StringIO      0.335 (± 0.0%) i/s     (2.98 s/i) -     10.000 in  31.019521s
-      OSV - StringIO      0.705 (± 0.0%) i/s     (1.42 s/i) -     21.000 in  30.629511s
-   CSV - Hash output      0.060 (± 0.0%) i/s    (16.74 s/i) -      2.000 in  33.475977s
-   OSV - Hash output      0.434 (± 0.0%) i/s     (2.30 s/i) -     13.000 in  30.071679s
-  CSV - Array output      0.063 (± 0.0%) i/s    (15.88 s/i) -      2.000 in  32.229906s
-  OSV - Array output      0.406 (± 0.0%) i/s     (2.47 s/i) -     12.000 in  31.072600s
+      CSV - StringIO      0.081 (± 0.0%) i/s    (12.36 s/i) -      3.000 in  37.155983s
+  FastCSV - StringIO      0.367 (± 0.0%) i/s     (2.73 s/i) -     11.000 in  30.182262s
+      OSV - StringIO      0.673 (± 0.0%) i/s     (1.49 s/i) -     20.000 in  30.247575s
+   CSV - Hash output      0.056 (± 0.0%) i/s    (17.73 s/i) -      2.000 in  35.464673s
+   OSV - Hash output      0.266 (± 0.0%) i/s     (3.77 s/i) -      8.000 in  30.511406s
+  CSV - Array output      0.068 (± 0.0%) i/s    (14.76 s/i) -      3.000 in  44.371496s
+  OSV - Array output      0.631 (± 0.0%) i/s     (1.59 s/i) -     19.000 in  30.896566s
 FastCSV - Array output
-                          0.321 (± 0.0%) i/s     (3.11 s/i) -     10.000 in  31.458966s
+                          0.369 (± 0.0%) i/s     (2.71 s/i) -     12.000 in  32.518984s
 OSV - Direct Open Array output
-                          0.686 (± 0.0%) i/s     (1.46 s/i) -     21.000 in  30.639715s
-       OSV - Gzipped      0.524 (± 0.0%) i/s     (1.91 s/i) -     16.000 in  30.695259s
-OSV - Gzipped Direct      0.519 (± 0.0%) i/s     (1.93 s/i) -     16.000 in  30.830005s
-   FastCSV - Gzipped      0.313 (± 0.0%) i/s     (3.20 s/i) -     10.000 in  32.031002s
-       CSV - Gzipped      0.057 (± 0.0%) i/s    (17.55 s/i) -      2.000 in  35.107808s
+                          0.642 (± 0.0%) i/s     (1.56 s/i) -     19.000 in  30.162703s
+       OSV - Gzipped      0.519 (± 0.0%) i/s     (1.93 s/i) -     16.000 in  31.551051s
+OSV - Gzipped Direct      0.512 (± 0.0%) i/s     (1.95 s/i) -     16.000 in  31.630035s
+   FastCSV - Gzipped      0.321 (± 0.0%) i/s     (3.12 s/i) -     10.000 in  31.795400s
+       CSV - Gzipped      0.058 (± 0.0%) i/s    (17.34 s/i) -      2.000 in  34.686451s
 
 Comparison:
-      OSV - StringIO          : 0.7 i/s
-OSV - Direct Open Array output: 0.7 i/s - 1.03x  slower
-       OSV - Gzipped          : 0.5 i/s - 1.34x  slower
-OSV - Gzipped Direct          : 0.5 i/s - 1.36x  slower
-   OSV - Hash output          : 0.4 i/s - 1.62x  slower
-  OSV - Array output          : 0.4 i/s - 1.74x  slower
-  FastCSV - StringIO          : 0.3 i/s - 2.10x  slower
-FastCSV - Array output        : 0.3 i/s - 2.20x  slower
-   FastCSV - Gzipped          : 0.3 i/s - 2.26x  slower
-      CSV - StringIO          : 0.1 i/s - 8.50x  slower
-  CSV - Array output          : 0.1 i/s - 11.20x  slower
-   CSV - Hash output          : 0.1 i/s - 11.80x  slower
-       CSV - Gzipped          : 0.1 i/s - 12.37x  slower
+                OSV - StringIO:        0.7 i/s
+OSV - Direct Open Array output:        0.6 i/s - 1.05x  slower
+            OSV - Array output:        0.6 i/s - 1.07x  slower
+                 OSV - Gzipped:        0.5 i/s - 1.30x  slower
+          OSV - Gzipped Direct:        0.5 i/s - 1.31x  slower
+        FastCSV - Array output:        0.4 i/s - 1.82x  slower
+            FastCSV - StringIO:        0.4 i/s - 1.83x  slower
+             FastCSV - Gzipped:        0.3 i/s - 2.10x  slower
+             OSV - Hash output:        0.3 i/s - 2.53x  slower
+                CSV - StringIO:        0.1 i/s - 8.31x  slower
+            CSV - Array output:        0.1 i/s - 9.93x  slower
+                 CSV - Gzipped:        0.1 i/s - 11.66x  slower
+             CSV - Hash output:        0.1 i/s - 11.92x  slower
 ```

data/Rakefile

@@ -7,9 +7,24 @@ task default: :test
 
 GEMSPEC = Gem::Specification.load("osv.gemspec")
 
+platforms = [
+  "x86_64-linux",
+  "x86_64-linux-musl",
+  "aarch64-linux",
+  "aarch64-linux-musl",
+  "x86_64-darwin",
+  "arm64-darwin"
+]
+
 RbSys::ExtensionTask.new("osv", GEMSPEC) do |ext|
   ext.lib_dir = "lib/osv"
   ext.ext_dir = "ext/osv"
+  ext.cross_compile = true
+  ext.cross_platform = platforms
+  ext.cross_compiling do |spec|
+    spec.dependencies.reject! { |dep| dep.name == "rb_sys" }
+    spec.files.reject! { |file| File.fnmatch?("ext/*", file, File::FNM_EXTGLOB) }
+  end
 end
 
 Rake::TestTask.new do |t|

data/ext/osv/Cargo.toml

@@ -10,13 +10,13 @@ crate-type = ["cdylib"]
 ahash = "0.8"
 csv = "^1.3"
 flate2 = "1.0.35"
-kanal = "0.1.0-pre8"
 magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = "^0.9"
 serde = { version = "1.0", features = ["derive"] }
 serde_magnus = "0.8.1"
 thiserror = "2.0"
 itertools = "^0.14"
+tempfile = "3.17.1"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 jemallocator = { version = "0.5", features = ["disable_initial_exec_tls"] }

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

@@ -2,19 +2,13 @@ use super::{
     header_cache::{CacheError, StringCache},
     parser::RecordParser,
     record_reader::{RecordReader, READ_BUFFER_SIZE},
-    ruby_reader::{build_ruby_reader, SeekableRead},
-    ForgottenFileHandle,
+    ruby_reader::RubyReader,
 };
-use flate2::read::GzDecoder;
-use magnus::{rb_sys::AsRawValue, value::ReprValue, Error as MagnusError, RString, Ruby, Value};
+use magnus::{Error as MagnusError, RString, Ruby, Value};
 use std::{
     borrow::Cow,
-    fmt::Debug,
-    fs::File,
-    io::{self, BufReader, Read},
+    io::{self, BufReader},
     marker::PhantomData,
-    mem::ManuallyDrop,
-    os::fd::FromRawFd,
 };
 
 use thiserror::Error;
@@ -159,48 +153,9 @@ impl<'a, T: RecordParser<'a>> RecordReaderBuilder<'a, T> {
         self
     }
 
-    /// Handles reading from a file descriptor.
-    fn handle_file_descriptor(&self) -> Result<Box<dyn SeekableRead>, ReaderError> {
-        let raw_value = self.to_read.as_raw();
-        let fd = std::panic::catch_unwind(|| unsafe { rb_sys::rb_io_descriptor(raw_value) })
-            .map_err(|e| ReaderError::FileDescriptor(format!("{:?}", e)))?;
-
-        if fd < 0 {
-            return Err(ReaderError::InvalidFileDescriptor(fd));
-        }
-
-        let file = std::panic::catch_unwind(|| unsafe { File::from_raw_fd(fd) })
-            .map_err(|e| ReaderError::FileDescriptor(format!("{:?}", e)))?;
-        let forgotten = ForgottenFileHandle(ManuallyDrop::new(file));
-        Ok(Box::new(forgotten))
-    }
-
-    /// Handles reading from a file path.
-    fn handle_file_path(&self) -> Result<Box<dyn SeekableRead>, ReaderError> {
-        let path = self.to_read.to_r_string()?.to_string()?;
-        let file = File::open(&path)?;
-
-        if path.ends_with(".gz") {
-            // For gzipped files, we need to decompress them into memory first
-            // since GzDecoder doesn't support seeking
-            let mut decoder = GzDecoder::new(BufReader::with_capacity(READ_BUFFER_SIZE, file));
-            let mut contents = Vec::new();
-            decoder.read_to_end(&mut contents)?;
-            Ok(Box::new(std::io::Cursor::new(contents)))
-        } else {
-            Ok(Box::new(file))
-        }
-    }
-
     /// Builds the RecordReader with the configured options.
     pub fn build(self) -> Result<RecordReader<'a, T>, ReaderError> {
-        let readable = if self.to_read.is_kind_of(self.ruby.class_io()) {
-            self.handle_file_descriptor()?
-        } else if self.to_read.is_kind_of(self.ruby.class_string()) {
-            self.handle_file_path()?
-        } else {
-            build_ruby_reader(&self.ruby, self.to_read)?
-        };
+        let readable = RubyReader::try_from(self.to_read)?;
 
         let flexible = self.flexible;
         let reader = BufReader::with_capacity(READ_BUFFER_SIZE, readable);

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

@@ -3,11 +3,9 @@ mod header_cache;
 mod parser;
 mod record;
 mod record_reader;
-mod ruby_integration;
 mod ruby_reader;
 
 pub use builder::RecordReaderBuilder;
 pub use header_cache::StringCacheKey;
 pub use record::CowStr;
 pub use record::CsvRecord;
-pub use ruby_integration::*;

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

@@ -57,7 +57,7 @@ impl<'a, S: BuildHasher + Default> RecordParser<'a>
                 }),
             };
 
-            map.insert(header.clone(), value);
+            map.insert(*header, value);
         });
         map
     }

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

@@ -1,7 +1,7 @@
 use super::builder::ReaderError;
 use super::header_cache::StringCacheKey;
 use super::parser::{CsvRecordType, RecordParser};
-use super::ruby_reader::SeekableRead;
+use super::ruby_reader::RubyReader;
 use magnus::{Error, Ruby};
 use std::borrow::Cow;
 use std::io::{BufReader, Read};
@@ -13,7 +13,7 @@ pub(crate) const READ_BUFFER_SIZE: usize = 16384;
 ///
 /// This struct implements Iterator to provide a streaming interface for CSV records.
 pub struct RecordReader<'a, T: RecordParser<'a>> {
-    reader: csv::Reader<BufReader<Box<dyn SeekableRead>>>,
+    reader: csv::Reader<BufReader<RubyReader>>,
     headers: Vec<StringCacheKey>,
     null_string: Option<Cow<'a, str>>,
     string_record: CsvRecordType,
@@ -73,7 +73,7 @@ impl<'a, T: RecordParser<'a>> RecordReader<'a, T> {
 
     /// Creates a new RecordReader instance.
     pub(crate) fn new(
-        reader: csv::Reader<BufReader<Box<dyn SeekableRead>>>,
+        reader: csv::Reader<BufReader<RubyReader>>,
         headers: Vec<StringCacheKey>,
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,

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

@@ -1,178 +1,128 @@
+use flate2::bufread::GzDecoder;
 use magnus::{
-    error::Error as MagnusError,
     value::{Opaque, ReprValue},
     RClass, RString, Ruby, Value,
 };
-use std::fs::File;
-use std::io::{self, BufReader, Read, Seek, SeekFrom, Write};
-use std::sync::OnceLock;
+use std::{
+    fs::File,
+    io::{self, BufReader, Read, Write},
+    sync::OnceLock,
+};
 
-use super::{builder::ReaderError, ForgottenFileHandle};
+use super::{builder::ReaderError, record_reader::READ_BUFFER_SIZE};
 
 static STRING_IO_CLASS: OnceLock<Opaque<RClass>> = OnceLock::new();
 
 /// A reader that can handle various Ruby input types (String, StringIO, IO-like objects)
 /// and provide a standard Read implementation for them.
-pub struct RubyReader<T> {
-    inner: T,
-    offset: usize,
-}
-
-pub trait SeekableRead: std::io::Read + Seek {}
-impl SeekableRead for RubyReader<Value> {}
-impl SeekableRead for RubyReader<RString> {}
-impl SeekableRead for File {}
-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>, ReaderError> {
-    if RubyReader::is_string_io(ruby, &input) {
-        RubyReader::from_string_io(ruby, input)
-    } else if RubyReader::is_io_like(&input) {
-        RubyReader::from_io(input)
-    } else {
-        RubyReader::from_string_like(input)
-    }
+pub enum RubyReader {
+    String {
+        inner: Opaque<RString>,
+        offset: usize,
+    },
+    RubyIoLike {
+        inner: Opaque<Value>,
+    },
+    NativeProxyIoLike {
+        proxy_file: Box<dyn Read>,
+    },
 }
 
-impl Seek for RubyReader<Value> {
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        let (whence, offset) = match pos {
-            SeekFrom::Start(i) => (0, i as i64),
-            SeekFrom::Current(i) => (1, i),
-            SeekFrom::End(i) => (2, i),
-        };
-
-        let new_position = self
-            .inner
-            .funcall("seek", (offset, whence))
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
-
-        Ok(new_position)
-    }
-}
-
-impl Write for RubyReader<Value> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-        let ruby_bytes = RString::from_slice(buf);
-
-        let bytes_written = self
-            .inner
-            .funcall::<_, _, usize>("write", (ruby_bytes,))
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
-
-        Ok(bytes_written)
-    }
-
-    fn flush(&mut self) -> Result<(), io::Error> {
-        self.inner
-            .funcall::<_, _, Value>("flush", ())
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
-
-        Ok(())
+impl RubyReader {
+    fn is_string_io(ruby: &Ruby, value: &Value) -> bool {
+        let string_io_class = STRING_IO_CLASS.get_or_init(|| {
+            let class = RClass::from_value(ruby.eval("StringIO").expect("Failed to find StringIO"))
+                .expect("Failed to get StringIO class");
+            Opaque::from(class)
+        });
+        value.is_kind_of(ruby.get_inner(*string_io_class))
     }
-}
 
-impl Seek for RubyReader<RString> {
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        match pos {
-            io::SeekFrom::Start(offset) => self.offset = offset as usize,
-            io::SeekFrom::Current(offset) => self.offset = (self.offset as i64 + offset) as usize,
-            io::SeekFrom::End(offset) => self.offset = self.inner.len() - offset as usize,
-        }
-        Ok(self.offset as u64)
+    fn is_io_like(value: &Value) -> bool {
+        value.respond_to("read", false).unwrap_or(false)
     }
 }
 
-impl RubyReader<Value> {
-    fn from_io(input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
-        if Self::is_io_like(&input) {
-            Ok(Box::new(Self::from_io_like(input)))
+impl TryFrom<Value> for RubyReader {
+    type Error = ReaderError;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        if RubyReader::is_string_io(&ruby, &value) {
+            let string_content = value.funcall::<_, _, RString>("string", ())?;
+            Ok(RubyReader::String {
+                inner: Opaque::from(string_content),
+                offset: 0,
+            })
+        } else if RubyReader::is_io_like(&value) {
+            Ok(RubyReader::RubyIoLike {
+                inner: Opaque::from(value),
+            })
+        } else if value.is_kind_of(ruby.class_string()) {
+            let ruby_string = value.to_r_string()?;
+            let file_path = unsafe { ruby_string.as_str()? };
+            let file = File::open(&file_path)?;
+
+            let x: Box<dyn Read> = if file_path.ends_with(".gz") {
+                let decoder = GzDecoder::new(BufReader::with_capacity(READ_BUFFER_SIZE, file));
+                Box::new(decoder)
+            } else {
+                Box::new(file)
+            };
+
+            Ok(RubyReader::NativeProxyIoLike { proxy_file: x })
         } else {
-            Err(MagnusError::new(
-                magnus::exception::type_error(),
-                "Input is not an IO-like object",
-            ))?
-        }
-    }
-
-    fn is_io_like(input: &Value) -> bool {
-        input.respond_to("read", false).unwrap_or(false)
-    }
-
-    fn from_io_like(input: Value) -> Self {
-        Self {
-            inner: input,
-            offset: 0,
+            // Try calling `to_str`, and if that fails, try `to_s`
+            let string_content = value
+                .funcall::<_, _, RString>("to_str", ())
+                .or_else(|_| value.funcall::<_, _, RString>("to_s", ()))?;
+            Ok(RubyReader::String {
+                inner: Opaque::from(string_content),
+                offset: 0,
+            })
         }
     }
 }
 
-impl RubyReader<RString> {
-    pub fn from_string_io(ruby: &Ruby, input: Value) -> Result<Box<dyn SeekableRead>, ReaderError> {
-        if !Self::is_string_io(ruby, &input) {
-            return Err(MagnusError::new(
-                magnus::exception::type_error(),
-                "Input is not a StringIO",
-            ))?;
-        }
-
-        let string_content = input.funcall::<_, _, RString>("string", ()).unwrap();
-        Ok(Box::new(Self {
-            inner: string_content,
-            offset: 0,
-        }))
-    }
+impl Read for RubyReader {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        match self {
+            RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.read(buf),
+            RubyReader::String { inner, offset } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
 
-    fn is_string_io(ruby: &Ruby, input: &Value) -> bool {
-        let string_io_class = STRING_IO_CLASS.get_or_init(|| {
-            let class = RClass::from_value(ruby.eval("StringIO").unwrap()).unwrap();
-            Opaque::from(class)
-        });
-        input.is_kind_of(ruby.get_inner(*string_io_class))
-    }
+                let string_buffer = unsafe { unwrapped_inner.as_slice() };
+                if *offset >= string_buffer.len() {
+                    return Ok(0); // EOF
+                }
 
-    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", ()))?;
+                let remaining = string_buffer.len() - *offset;
+                let copy_size = remaining.min(buf.len());
+                buf[..copy_size].copy_from_slice(&string_buffer[*offset..*offset + copy_size]);
 
-        Ok(Box::new(Self {
-            inner: string_content,
-            offset: 0,
-        }))
-    }
-}
+                *offset += copy_size;
 
-impl Read for RubyReader<Value> {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let bytes = self
-            .inner
-            .funcall::<_, _, Option<RString>>("read", (buf.len(),))
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
-
-        match bytes {
-            Some(bytes) => {
-                buf.write_all(unsafe { bytes.as_slice() })?;
-                Ok(bytes.len())
+                Ok(copy_size)
+            }
+            RubyReader::RubyIoLike { inner } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+
+                let bytes = unwrapped_inner
+                    .funcall::<_, _, Option<RString>>("read", (buf.len(),))
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+                match bytes {
+                    Some(bytes) => {
+                        let string_buffer = unsafe { bytes.as_slice() };
+                        buf.write_all(string_buffer)?;
+                        Ok(string_buffer.len())
+                    }
+                    None => {
+                        return Ok(0);
+                    }
+                }
             }
-            None => Ok(0), // EOF
-        }
-    }
-}
-
-impl Read for RubyReader<RString> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let string_buffer = unsafe { self.inner.as_slice() };
-        if self.offset >= string_buffer.len() {
-            return Ok(0); // EOF
         }
-
-        let remaining = string_buffer.len() - self.offset;
-        let copy_size = remaining.min(buf.len());
-        buf[..copy_size].copy_from_slice(&string_buffer[self.offset..self.offset + copy_size]);
-        self.offset += copy_size;
-        Ok(copy_size)
     }
 }

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::{Error, IntoValue, KwArgs, RHash, Ruby, Symbol, Value};
+use magnus::{Error, IntoValue, KwArgs, Ruby, Symbol, Value};
 use std::collections::HashMap;
 
 /// Valid result types for CSV parsing
@@ -62,24 +62,27 @@ pub fn parse_csv(rb_self: Value, args: &[Value]) -> Result<Value, Error> {
     } = parse_read_csv_args(&ruby, args)?;
 
     if !ruby.block_given() {
-        return create_enumerator(EnumeratorArgs {
-            rb_self,
-            to_read,
-            has_headers,
-            delimiter,
-            quote_char,
-            null_string,
-            result_type,
-            flexible,
-            trim: match trim {
-                Trim::All => Some("all".to_string()),
-                Trim::Headers => Some("headers".to_string()),
-                Trim::Fields => Some("fields".to_string()),
-                _ => None,
+        return create_enumerator(
+            &ruby,
+            EnumeratorArgs {
+                rb_self,
+                to_read,
+                has_headers,
+                delimiter,
+                quote_char,
+                null_string,
+                result_type,
+                flexible,
+                trim: match trim {
+                    Trim::All => Some("all".to_string()),
+                    Trim::Headers => Some("headers".to_string()),
+                    Trim::Fields => Some("fields".to_string()),
+                    _ => None,
+                },
+                ignore_null_bytes,
+                lossy,
             },
-            ignore_null_bytes,
-            lossy,
-        })
+        )
         .map(|yield_enum| yield_enum.into_value_with(&ruby));
     }
 
@@ -136,8 +139,8 @@ pub fn parse_csv(rb_self: Value, args: &[Value]) -> Result<Value, Error> {
 }
 
 /// Creates an enumerator for lazy CSV parsing
-fn create_enumerator(args: EnumeratorArgs) -> Result<magnus::Enumerator, Error> {
-    let kwargs = RHash::new();
+fn create_enumerator(ruby: &Ruby, args: EnumeratorArgs) -> Result<magnus::Enumerator, Error> {
+    let kwargs = ruby.hash_new();
     kwargs.aset(Symbol::new("has_headers"), args.has_headers)?;
     kwargs.aset(
         Symbol::new("col_sep"),

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

data/lib/osv.rb

@@ -1,5 +1,10 @@
 require_relative "osv/version"
-require_relative "osv/osv"
+
+begin
+  require "osv/#{RUBY_VERSION.to_f}/osv"
+rescue LoadError
+  require "osv/osv"
+end
 
 module OSV
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -66,7 +66,6 @@ files:
 - ext/osv/src/csv/parser.rs
 - ext/osv/src/csv/record.rs
 - ext/osv/src/csv/record_reader.rs
-- ext/osv/src/csv/ruby_integration.rs
 - ext/osv/src/csv/ruby_reader.rs
 - ext/osv/src/lib.rs
 - ext/osv/src/reader.rs

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

@@ -1,19 +0,0 @@
-use std::{
-    fs::File,
-    io::{self, Read, Seek, SeekFrom},
-    mem::ManuallyDrop,
-};
-
-pub struct ForgottenFileHandle(pub ManuallyDrop<File>);
-
-impl Read for ForgottenFileHandle {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.read(buf)
-    }
-}
-
-impl Seek for ForgottenFileHandle {
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.0.seek(pos)
-    }
-}