osv 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a791a08d1a1c44fcc4e69df668e1c04e9e099e8388d048f7e058aea2a7ee3305
-  data.tar.gz: 2616a3ab845191c29fb3f852f8a1a3a1cc51c33d39e5f4bc7b0da3ae733bf9f3
+  metadata.gz: ec1e35e2e9f14666ea236823b6433cd7910d3a384de97ade622aaf40bb320114
+  data.tar.gz: a4b61200cdf3350e153d93f3269695d771f7f985ed0bc9b2d55ec0b7da98086e
 SHA512:
-  metadata.gz: 4d1a816e49ffbf62dcd33dd8a2d3c49f32bac34ddfe2681e58a55839e33afadf4487c7e216e67bf878071272d0fc129370a598657fb3fb0bc8ec6c7934e6de3d
-  data.tar.gz: 67f8f1416e8f11cac750e60b46437293bd41421a2ea3de9b5557a78ea78c34e2be8251a62c9650f16af449c0f534d807c7aabd838c274486d3cfe0eaef7eecde
+  metadata.gz: a612087b5d63ebb1d30b215e346f351df1fc7e6d2a05ddc2860f3be9ddda3cba8311259a5673591f576dc7e2ac6fcfd3c8eeac5a8a3f2d376f7898cfcf2953ab
+  data.tar.gz: '02898ed010a8fb358f22d1caf7bbdc302733e2d80935fc4d03a6a0be0204513c63c58cfa875ea6e3326b78d664b9a2b7f3a303ba284396fb62820b8138c97306'

data/Cargo.lock

@@ -270,18 +270,6 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
-[[package]]
-name = "magnus"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1597ef40aa8c36be098249e82c9a20cf7199278ac1c1a1a995eeead6a184479"
-dependencies = [
- "magnus-macros",
- "rb-sys",
- "rb-sys-env",
- "seq-macro",
-]
-
 [[package]]
 name = "magnus"
 version = "0.7.1"
@@ -360,7 +348,7 @@ dependencies = [
  "flate2",
  "itertools 0.14.0",
  "jemallocator",
- "magnus 0.7.1",
+ "magnus",
  "mimalloc",
  "rb-sys",
  "serde",
@@ -499,11 +487,11 @@ dependencies = [
 
 [[package]]
 name = "serde_magnus"
-version = "0.8.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76c20da583b5e1016e9199ef5f3260f7a8d1b253307d232600f6b12737262dbd"
+checksum = "51b8b945a2dadb221f1c5490cfb411cab6c3821446b8eca50ee07e5a3893ec51"
 dependencies = [
- "magnus 0.6.4",
+ "magnus",
  "serde",
  "tap",
 ]

data/ext/osv/Cargo.toml

@@ -13,7 +13,7 @@ flate2 = "1.0.35"
 magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = "^0.9"
 serde = { version = "1.0", features = ["derive"] }
-serde_magnus = "0.8.1"
+serde_magnus = "0.9.0"
 thiserror = "2.0"
 itertools = "^0.14"
 tempfile = "3.17.1"

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

@@ -174,7 +174,12 @@ impl<'a, T: RecordParser<'a>> RecordReaderBuilder<'a, T> {
         if self.ignore_null_bytes {
             headers = headers.iter().map(|h| h.replace("\0", "")).collect();
         }
-        let static_headers = StringCache::intern_many(&headers)?;
+
+        let static_headers = if T::uses_headers() {
+            StringCache::intern_many(&headers)?
+        } else {
+            Vec::new()
+        };
 
         let null_string = self
             .null_string

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

@@ -6,23 +6,22 @@
 /// so this optimization could be removed if any issues arise.
 use std::{
     collections::HashMap,
-    sync::{
-        atomic::{AtomicU32, Ordering},
-        LazyLock, Mutex,
-    },
+    sync::{LazyLock, Mutex},
 };
 
 use magnus::{IntoValue, RString, Ruby, Value};
 
 use thiserror::Error;
 
-#[derive(Debug, Error)]
+#[derive(Debug, Clone, Error)]
 pub enum CacheError {
     #[error("Failed to acquire lock: {0}")]
     LockError(String),
+    #[error("Failed to convert Ruby String to interned string: {0}")]
+    RStringConversion(String),
 }
 
-static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, (StringCacheKey, AtomicU32)>>> =
+static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, StringCacheKey>>> =
     LazyLock::new(|| Mutex::new(HashMap::with_capacity(100)));
 
 pub struct StringCache;
@@ -31,10 +30,12 @@ pub struct StringCache;
 pub struct StringCacheKey(&'static str);
 
 impl StringCacheKey {
-    pub fn new(string: &str) -> Self {
+    pub fn new(string: &str) -> Result<Self, CacheError> {
         let rstr = RString::new(string);
         let fstr = rstr.to_interned_str();
-        Self(fstr.as_str().unwrap())
+        Ok(Self(fstr.as_str().map_err(|e| {
+            CacheError::RStringConversion(e.to_string())
+        })?))
     }
 }
 
@@ -80,18 +81,16 @@ impl StringCache {
     pub fn intern_many<AsStr: AsRef<str>>(
         strings: &[AsStr],
     ) -> Result<Vec<StringCacheKey>, CacheError> {
-        let mut cache = STRING_CACHE
+        let cache = STRING_CACHE
             .lock()
             .map_err(|e| CacheError::LockError(e.to_string()))?;
 
         let mut result: Vec<StringCacheKey> = Vec::with_capacity(strings.len());
         for string in strings {
-            if let Some((_, (interned_string, counter))) = cache.get_key_value(string.as_ref()) {
-                counter.fetch_add(1, Ordering::Relaxed);
+            if let Some((_, interned_string)) = cache.get_key_value(string.as_ref()) {
                 result.push(*interned_string);
             } else {
-                let interned = StringCacheKey::new(string.as_ref());
-                cache.insert(interned.0, (interned, AtomicU32::new(1)));
+                let interned = StringCacheKey::new(string.as_ref())?;
                 result.push(interned);
             }
         }

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

@@ -19,6 +19,8 @@ pub trait RecordParser<'a> {
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,
     ) -> Self::Output;
+
+    fn uses_headers() -> bool;
 }
 
 impl<'a, S: BuildHasher + Default> RecordParser<'a>
@@ -26,6 +28,11 @@ impl<'a, S: BuildHasher + Default> RecordParser<'a>
 {
     type Output = Self;
 
+    #[inline]
+    fn uses_headers() -> bool {
+        true
+    }
+
     #[inline]
     fn parse(
         headers: &[StringCacheKey],
@@ -66,6 +73,11 @@ impl<'a, S: BuildHasher + Default> RecordParser<'a>
 impl<'a> RecordParser<'a> for Vec<Option<CowStr<'a>>> {
     type Output = Self;
 
+    #[inline]
+    fn uses_headers() -> bool {
+        false
+    }
+
     #[inline]
     fn parse(
         headers: &[StringCacheKey],

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

@@ -26,7 +26,7 @@ impl<S: BuildHasher + Default> IntoValue for CsvRecord<'_, S> {
                 let mut values: [Value; 128] = [handle.qnil().as_value(); 128];
                 let mut i = 0;
 
-                for chunk in &map.into_iter().chunks(128) {
+                for chunk in &map.into_iter().chunks(64) {
                     for (k, v) in chunk {
                         values[i] = handle.into_value(k.as_ref());
                         values[i + 1] = handle.into_value(v);

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

@@ -1,18 +1,15 @@
 use flate2::bufread::GzDecoder;
 use magnus::{
     value::{Opaque, ReprValue},
-    RClass, RString, Ruby, Value,
+    RString, Ruby, Value,
 };
 use std::{
     fs::File,
     io::{self, BufReader, Read, Write},
-    sync::OnceLock,
 };
 
 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 enum RubyReader {
@@ -29,15 +26,6 @@ pub enum RubyReader {
 }
 
 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))
-    }
-
     fn is_io_like(value: &Value) -> bool {
         value.respond_to("read", false).unwrap_or(false)
     }
@@ -48,19 +36,13 @@ impl TryFrom<Value> for RubyReader {
 
     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) {
+        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_path = ruby_string.to_string()?;
             let file = File::open(&file_path)?;
 
             let x: Box<dyn Read> = if file_path.ends_with(".gz") {

data/lib/osv/version.rb

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

metadata

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