osv 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 137ae556685639f7d13234e3061d9b310757ce02f75a713753d175f1bc71b628
-  data.tar.gz: 5892494ad08d783955d2b932150d65433a4d3593376fadbaf54e54780e7a350f
+  metadata.gz: cae389fff24c3109f17a1c450022771da964e1b7dced4ed2f34f93753c213dc8
+  data.tar.gz: 1e3736fb0b84003f62a5038a3d7e71e7d6e31581f943452c2acb08b04a21ff64
 SHA512:
-  metadata.gz: 6efbc2ee65a8e79379722ae977ee7dbec6131b78968d080f9feb86a3310368c387da54dd8c073e9b4008cb80d906293ea9115982d00d5ff637cf5ab51179b53c
-  data.tar.gz: 7b4ab3199f90654cd831dfbb52a9d22b70237e7120bd5308a1b7698268fa981abefd7ee47d53424d0c7bff46956256db8f1e139d17e381fd5570a16ca183e376
+  metadata.gz: ddae565f1b208de7fc18fa1cdaff7b3d1ed02ec22bf85d0477a9b152d9238049893a5ef40bad95ac4b2d8f8cb0cd59f14fd4e365aa69f3ef109fa6f6701d2499
+  data.tar.gz: aa81197d39f7e3dcc5732bfb7d71545cd9303d888ee7da1a34b0244ade287a8b25db16f7428d4f09689dfe1d874d3663bebb6d546e6b363f7496137339b15150

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

@@ -169,7 +169,8 @@ impl<'a, T: RecordParser<'a>> RecordReaderBuilder<'a, T> {
             return Err(ReaderError::InvalidFileDescriptor(fd));
         }
 
-        let file = unsafe { File::from_raw_fd(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))
     }

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

@@ -8,11 +8,11 @@ use std::{
     collections::HashMap,
     sync::{
         atomic::{AtomicU32, Ordering},
-        Arc, LazyLock, Mutex, OnceLock,
+        LazyLock, Mutex,
     },
 };
 
-use magnus::{r_string::FString, value::Opaque, IntoValue, RString, Ruby, Value};
+use magnus::{IntoValue, RString, Ruby, Value};
 
 use thiserror::Error;
 
@@ -22,24 +22,25 @@ pub enum CacheError {
     LockError(String),
 }
 
-static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, (Arc<StringCacheKey>, AtomicU32)>>> =
+static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, (StringCacheKey, AtomicU32)>>> =
     LazyLock::new(|| Mutex::new(HashMap::with_capacity(100)));
 
 pub struct StringCache;
 
-pub struct StringCacheKey(Opaque<FString>, &'static str);
+#[derive(Copy, Clone)]
+pub struct StringCacheKey(&'static str);
 
 impl StringCacheKey {
     pub fn new(string: &str) -> Self {
         let rstr = RString::new(string);
         let fstr = rstr.to_interned_str();
-        Self(Opaque::from(fstr), fstr.as_str().unwrap())
+        Self(fstr.as_str().unwrap())
     }
 }
 
 impl AsRef<str> for StringCacheKey {
     fn as_ref(&self) -> &'static str {
-        self.1
+        self.0
     }
 }
 
@@ -57,13 +58,13 @@ impl IntoValue for &StringCacheKey {
 
 impl std::fmt::Debug for StringCacheKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.1.fmt(f)
+        self.0.fmt(f)
     }
 }
 
 impl PartialEq for StringCacheKey {
     fn eq(&self, other: &Self) -> bool {
-        self.1 == other.1
+        self.0 == other.0
     }
 }
 
@@ -71,95 +72,29 @@ impl std::cmp::Eq for StringCacheKey {}
 
 impl std::hash::Hash for StringCacheKey {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.1.hash(state);
+        self.0.hash(state);
     }
 }
 
 impl StringCache {
-    #[allow(dead_code)]
-    pub fn intern(string: String) -> Result<Arc<StringCacheKey>, CacheError> {
+    pub fn intern_many<AsStr: AsRef<str>>(
+        strings: &[AsStr],
+    ) -> Result<Vec<StringCacheKey>, CacheError> {
         let mut cache = STRING_CACHE
             .lock()
             .map_err(|e| CacheError::LockError(e.to_string()))?;
 
-        if let Some((_, (interned_string, counter))) = cache.get_key_value(string.as_str()) {
-            counter.fetch_add(1, Ordering::Relaxed);
-            Ok(interned_string.clone())
-        } else {
-            let interned = Arc::new(StringCacheKey::new(string.as_str()));
-            let leaked = Box::leak(string.into_boxed_str());
-            cache.insert(leaked, (interned.clone(), AtomicU32::new(1)));
-            Ok(interned)
-        }
-    }
-
-    pub fn intern_many(strings: &[String]) -> Result<Vec<Arc<StringCacheKey>>, CacheError> {
-        let mut cache = STRING_CACHE
-            .lock()
-            .map_err(|e| CacheError::LockError(e.to_string()))?;
-
-        let mut result: Vec<Arc<StringCacheKey>> = Vec::with_capacity(strings.len());
+        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_str()) {
+            if let Some((_, (interned_string, counter))) = cache.get_key_value(string.as_ref()) {
                 counter.fetch_add(1, Ordering::Relaxed);
-                result.push(interned_string.clone());
+                result.push(*interned_string);
             } else {
-                let interned = Arc::new(StringCacheKey::new(string));
-                let leaked = Box::leak(string.clone().into_boxed_str());
-                cache.insert(leaked, (interned.clone(), AtomicU32::new(1)));
+                let interned = StringCacheKey::new(string.as_ref());
+                cache.insert(interned.0, (interned, AtomicU32::new(1)));
                 result.push(interned);
             }
         }
         Ok(result)
     }
-
-    pub fn clear(headers: &[Arc<StringCacheKey>]) -> Result<(), CacheError> {
-        let mut cache = STRING_CACHE
-            .lock()
-            .map_err(|e| CacheError::LockError(e.to_string()))?;
-
-        let to_remove: Vec<_> = headers
-            .iter()
-            .filter_map(|header| {
-                let key = header.as_ref().as_ref();
-                if let Some((_, (_, counter))) = cache.get_key_value(key) {
-                    let prev_count = counter.fetch_sub(1, Ordering::Relaxed);
-                    if prev_count == 1 {
-                        Some(key)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        for key in to_remove {
-            cache.remove(key);
-        }
-
-        Ok(())
-    }
-}
-
-pub struct HeaderCacheCleanupIter<I> {
-    pub inner: I,
-    pub headers: OnceLock<Vec<Arc<StringCacheKey>>>,
-}
-
-impl<I: Iterator> Iterator for HeaderCacheCleanupIter<I> {
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next()
-    }
-}
-
-impl<I> Drop for HeaderCacheCleanupIter<I> {
-    fn drop(&mut self) {
-        if let Some(headers) = self.headers.get() {
-            StringCache::clear(headers).unwrap();
-        }
-    }
 }

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

@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
-use std::sync::Arc;
 
 use super::header_cache::StringCacheKey;
 use super::CowStr;
@@ -15,7 +14,7 @@ pub trait RecordParser<'a> {
     type Output;
 
     fn parse(
-        headers: &[Arc<StringCacheKey>],
+        headers: &[StringCacheKey],
         record: &CsvRecordType,
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,
@@ -23,46 +22,38 @@ pub trait RecordParser<'a> {
 }
 
 impl<'a, S: BuildHasher + Default> RecordParser<'a>
-    for HashMap<Arc<StringCacheKey>, Option<CowStr<'a>>, S>
+    for HashMap<StringCacheKey, Option<CowStr<'a>>, S>
 {
     type Output = Self;
 
     #[inline]
     fn parse(
-        headers: &[Arc<StringCacheKey>],
+        headers: &[StringCacheKey],
         record: &CsvRecordType,
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,
     ) -> Self::Output {
         let mut map = HashMap::with_capacity_and_hasher(headers.len(), S::default());
-
         let shared_empty = Cow::Borrowed("");
 
         headers.iter().enumerate().for_each(|(i, header)| {
             let value = match record {
                 CsvRecordType::String(s) => s.get(i).and_then(|field| {
-                    if null_string.as_deref() == Some(field.as_ref()) {
-                        None
-                    } else if field.is_empty() {
-                        Some(CowStr(shared_empty.clone()))
-                    } else if ignore_null_bytes {
-                        Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-                    } else {
-                        Some(CowStr(Cow::Owned(field.to_string())))
-                    }
+                    convert_field_to_cow_str(
+                        field,
+                        null_string.as_deref(),
+                        ignore_null_bytes,
+                        &shared_empty,
+                    )
                 }),
-
                 CsvRecordType::Byte(b) => b.get(i).and_then(|field| {
                     let field = String::from_utf8_lossy(field);
-                    if null_string.as_deref() == Some(field.as_ref()) {
-                        None
-                    } else if field.is_empty() {
-                        Some(CowStr(shared_empty.clone()))
-                    } else if ignore_null_bytes {
-                        Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-                    } else {
-                        Some(CowStr(Cow::Owned(field.to_string())))
-                    }
+                    convert_field_to_cow_str(
+                        &field,
+                        null_string.as_deref(),
+                        ignore_null_bytes,
+                        &shared_empty,
+                    )
                 }),
             };
 
@@ -77,43 +68,36 @@ impl<'a> RecordParser<'a> for Vec<Option<CowStr<'a>>> {
 
     #[inline]
     fn parse(
-        headers: &[Arc<StringCacheKey>],
+        headers: &[StringCacheKey],
         record: &CsvRecordType,
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,
     ) -> Self::Output {
         let target_len = headers.len();
         let mut vec = Vec::with_capacity(target_len);
-
         let shared_empty = Cow::Borrowed("");
 
         match record {
             CsvRecordType::String(record) => {
                 for field in record.iter() {
-                    let value = if Some(field.as_ref()) == null_string.as_deref() {
-                        None
-                    } else if field.is_empty() {
-                        Some(CowStr(shared_empty.clone()))
-                    } else if ignore_null_bytes {
-                        Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-                    } else {
-                        Some(CowStr(Cow::Owned(field.to_string())))
-                    };
+                    let value = convert_field_to_cow_str(
+                        field,
+                        null_string.as_deref(),
+                        ignore_null_bytes,
+                        &shared_empty,
+                    );
                     vec.push(value);
                 }
             }
             CsvRecordType::Byte(record) => {
                 for field in record.iter() {
                     let field = String::from_utf8_lossy(field);
-                    let value = if Some(field.as_ref()) == null_string.as_deref() {
-                        None
-                    } else if field.is_empty() {
-                        Some(CowStr(shared_empty.clone()))
-                    } else if ignore_null_bytes {
-                        Some(CowStr(Cow::Owned(field.replace("\0", ""))))
-                    } else {
-                        Some(CowStr(Cow::Owned(field.to_string())))
-                    };
+                    let value = convert_field_to_cow_str(
+                        &field,
+                        null_string.as_deref(),
+                        ignore_null_bytes,
+                        &shared_empty,
+                    );
                     vec.push(value);
                 }
             }
@@ -122,3 +106,21 @@ impl<'a> RecordParser<'a> for Vec<Option<CowStr<'a>>> {
         vec
     }
 }
+
+#[inline]
+fn convert_field_to_cow_str<'a>(
+    field: &str,
+    null_string: Option<&str>,
+    ignore_null_bytes: bool,
+    shared_empty: &Cow<'a, str>,
+) -> Option<CowStr<'a>> {
+    if Some(field) == null_string {
+        None
+    } else if field.is_empty() {
+        Some(CowStr(shared_empty.clone()))
+    } else if ignore_null_bytes {
+        Some(CowStr(Cow::Owned(field.replace("\0", ""))))
+    } else {
+        Some(CowStr(Cow::Owned(field.to_string())))
+    }
+}

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

@@ -1,13 +1,13 @@
 use itertools::Itertools;
 use magnus::{value::ReprValue, IntoValue, Ruby, Value};
-use std::{borrow::Cow, collections::HashMap, hash::BuildHasher, sync::Arc};
+use std::{borrow::Cow, collections::HashMap, hash::BuildHasher};
 
 use super::StringCacheKey;
 
 #[derive(Debug)]
 pub enum CsvRecord<'a, S: BuildHasher + Default> {
     Vec(Vec<Option<CowStr<'a>>>),
-    Map(HashMap<Arc<StringCacheKey>, Option<CowStr<'a>>, S>),
+    Map(HashMap<StringCacheKey, Option<CowStr<'a>>, S>),
 }
 
 impl<S: BuildHasher + Default> IntoValue for CsvRecord<'_, S> {

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

@@ -1,11 +1,10 @@
 use super::builder::ReaderError;
 use super::header_cache::StringCacheKey;
 use super::parser::{CsvRecordType, RecordParser};
-use super::{header_cache::StringCache, ruby_reader::SeekableRead};
+use super::ruby_reader::SeekableRead;
 use magnus::{Error, Ruby};
 use std::borrow::Cow;
 use std::io::{BufReader, Read};
-use std::sync::Arc;
 
 /// Size of the internal buffer used for reading CSV records
 pub(crate) const READ_BUFFER_SIZE: usize = 16384;
@@ -15,7 +14,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>>>,
-    headers: Vec<Arc<StringCacheKey>>,
+    headers: Vec<StringCacheKey>,
     null_string: Option<Cow<'a, str>>,
     string_record: CsvRecordType,
     parser: std::marker::PhantomData<T>,
@@ -75,7 +74,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>>>,
-        headers: Vec<Arc<StringCacheKey>>,
+        headers: Vec<StringCacheKey>,
         null_string: Option<Cow<'a, str>>,
         ignore_null_bytes: bool,
         lossy: bool,
@@ -137,11 +136,3 @@ impl<'a, T: RecordParser<'a>> Iterator for RecordReader<'a, T> {
         (0, None) // Cannot determine size without reading entire file
     }
 }
-
-impl<'a, T: RecordParser<'a>> Drop for RecordReader<'a, T> {
-    #[inline]
-    fn drop(&mut self) {
-        // Intentionally ignore errors during cleanup as there's no meaningful way to handle them
-        let _ = StringCache::clear(&self.headers);
-    }
-}

data/ext/osv/src/reader.rs

@@ -5,7 +5,6 @@ use csv::Trim;
 use magnus::value::ReprValue;
 use magnus::{Error, IntoValue, KwArgs, RHash, Ruby, Symbol, Value};
 use std::collections::HashMap;
-use std::sync::Arc;
 
 /// Valid result types for CSV parsing
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -94,7 +93,7 @@ pub fn parse_csv(rb_self: Value, args: &[Value]) -> Result<Value, Error> {
     match result_type {
         ResultType::Hash => {
             let builder = RecordReaderBuilder::<
-                HashMap<Arc<StringCacheKey>, Option<CowStr<'static>>, RandomState>,
+                HashMap<StringCacheKey, Option<CowStr<'_>>, RandomState>,
             >::new(ruby, to_read)
             .has_headers(has_headers)
             .flexible(flexible)
@@ -109,11 +108,11 @@ pub fn parse_csv(rb_self: Value, args: &[Value]) -> Result<Value, Error> {
             let ruby = unsafe { Ruby::get_unchecked() };
             for result in builder {
                 let record = result?;
-                let _: Value = ruby.yield_value(CsvRecord::Map(record))?;
+                let _: Value = ruby.yield_value(CsvRecord::<ahash::RandomState>::Map(record))?;
             }
         }
         ResultType::Array => {
-            let builder = RecordReaderBuilder::<Vec<Option<CowStr<'static>>>>::new(ruby, to_read)
+            let builder = RecordReaderBuilder::<Vec<Option<CowStr<'_>>>>::new(ruby, to_read)
                 .has_headers(has_headers)
                 .flexible(flexible)
                 .trim(trim)

data/lib/osv/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Nathan Jaremko