osv 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33c644fac6e61f8bf3b9f11e646d6706017ece2a386df03a568b5ed06fd91e2a
-  data.tar.gz: 0d977fb3a7eaf867663feb76161eb2d3fbe42e758523ef8cafbff51a9acfef0d
+  metadata.gz: 9a28169673f9693d3985c700f79490ae9057b43d86161a4354e9cb7196b92425
+  data.tar.gz: 3871878a45c4e564eeacbc4af911fc1e91c95f7ca0ca93fcaf8f06426ce0b3a5
 SHA512:
-  metadata.gz: b6fe382c005837fbfc705bd02b1859fdfa9fa9f955c15f7b13ffacb97f1d5dc0714288c23a7e2431a21aada6aacb1952b33ae8d14acd019c96ed719f5580c02d
-  data.tar.gz: 4e7c3d783f23af709505a4c182d1ee6744c9f28226aecdf68c532ada9ffa653858bc730bfd879cfa94d8e8f7a1280c49380bb5b6f74ed16b7ac776318aa53d1b
+  metadata.gz: 2038c7f8a0f56460e2bb6cb11b1bf6342841306b19b0847d7f57e3be6fc96687ba5743f1f5326251110bc6b41f049d24e5b1045543a71b9aa9b7364053f9a3a7
+  data.tar.gz: a99622513a55f4ec6e3c19ac73d29ab0f7e85191bacc68de324e6e12c8cfff06355b881d46380735fa1625420744d6dcd652ab0cdca08c92b7ecdd3f82f43170

data/Cargo.lock

@@ -273,6 +273,7 @@ dependencies = [
  "rb-sys",
  "serde",
  "serde_magnus",
+ "thiserror",
 ]
 
 [[package]]
@@ -421,9 +422,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"
-version = "2.0.90"
+version = "2.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
+checksum = "d53cbcb5a243bd33b7858b1d7f4aca2153490815872d86d955d6ea29f743c035"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -436,6 +437,26 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
+[[package]]
+name = "thiserror"
+version = "2.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.14"

data/Gemfile

@@ -2,6 +2,13 @@ source "https://rubygems.org"
 
 gem "rb_sys", "~> 0.9.56"
 gem "rake"
-gem "rake-compiler", "1.2.0"
+gem "csv"
 
-gem "minitest", "~> 5.0", group: :test
+# Use local version of osv
+gemspec
+
+group :development, :test do
+  gem "minitest", "~> 5.0"
+  gem "benchmark-ips", "~> 2.12"
+  gem "fastcsv", "~> 0.0.7"
+end

data/README.md

@@ -65,19 +65,12 @@ Both methods support the following options:
 
 - `has_headers`: Boolean indicating if the first row contains headers (default: true)
 - `col_sep`: String specifying the field separator (default: ",")
-
-```ruby
-# Reading TSV files
-OSV.for_each("path/to/file.tsv", col_sep: "\t") do |row|
-  puts row["name"]
-end
-
-# Reading without headers
-OSV.for_each("path/to/file.csv", has_headers: false) do |row|
-  # Headers will be automatically generated as "c0", "c1", etc.
-  puts row["c0"]
-end
-```
+- `quote_char`: String specifying the quote character (default: "\"")
+- `nil_string`: String that should be interpreted as nil
+  - by default, empty strings are interpreted as empty strings
+  - if you want to interpret empty strings as nil, set this to an empty string
+- `buffer_size`: Integer specifying the read buffer size
+- `result_type`: String specifying the output format ("hash" or "array")
 
 ### Input Sources
 
@@ -111,3 +104,93 @@ OSV.for_each(data) { |row| puts row["name"] }
 ## Performance
 
 This library is faster than the standard Ruby CSV library, and is comparable to the fastest CSV parser gems I've used.
+
+Here's some unscientific benchmarks. You can find the code in the [benchmark/comparison_benchmark.rb](benchmark/comparison_benchmark.rb) file.
+
+### 10,000 lines
+
+```
+Benchmarking with 10001 lines of data
+
+ruby 3.3.3 (2024-06-12 revision f1c7b6f435) [arm64-darwin23]
+Warming up --------------------------------------
+   OSV - Hash output     6.000 i/100ms
+   CSV - Hash output     1.000 i/100ms
+  OSV - Array output    18.000 i/100ms
+  CSV - Array output     2.000 i/100ms
+FastCSV - Array output
+                         9.000 i/100ms
+      OSV - StringIO     7.000 i/100ms
+      CSV - StringIO     1.000 i/100ms
+  FastCSV - StringIO    20.000 i/100ms
+       OSV - Gzipped     6.000 i/100ms
+       CSV - Gzipped     1.000 i/100ms
+Calculating -------------------------------------
+   OSV - Hash output     73.360 (± 4.1%) i/s   (13.63 ms/i) -    366.000 in   5.000390s
+   CSV - Hash output     11.937 (±25.1%) i/s   (83.78 ms/i) -     52.000 in   5.036297s
+  OSV - Array output    189.738 (± 8.4%) i/s    (5.27 ms/i) -    954.000 in   5.071018s
+  CSV - Array output     25.471 (±11.8%) i/s   (39.26 ms/i) -    120.000 in   5.015289s
+FastCSV - Array output
+                         97.867 (± 2.0%) i/s   (10.22 ms/i) -    495.000 in   5.060957s
+      OSV - StringIO     80.784 (± 6.2%) i/s   (12.38 ms/i) -    406.000 in   5.046696s
+      CSV - StringIO     15.872 (± 0.0%) i/s   (63.01 ms/i) -     80.000 in   5.043361s
+  FastCSV - StringIO    200.511 (± 2.0%) i/s    (4.99 ms/i) -      1.020k in   5.088592s
+       OSV - Gzipped     55.220 (±12.7%) i/s   (18.11 ms/i) -    258.000 in   5.030928s
+       CSV - Gzipped     12.591 (±15.9%) i/s   (79.42 ms/i) -     59.000 in   5.039709s
+
+Comparison:
+  FastCSV - StringIO:      200.5 i/s
+  OSV - Array output:      189.7 i/s - same-ish: difference falls within error
+FastCSV - Array output:       97.9 i/s - 2.05x  slower
+      OSV - StringIO:       80.8 i/s - 2.48x  slower
+   OSV - Hash output:       73.4 i/s - 2.73x  slower
+       OSV - Gzipped:       55.2 i/s - 3.63x  slower
+  CSV - Array output:       25.5 i/s - 7.87x  slower
+      CSV - StringIO:       15.9 i/s - 12.63x  slower
+       CSV - Gzipped:       12.6 i/s - 15.92x  slower
+   CSV - Hash output:       11.9 i/s - 16.80x  slower
+```
+
+### 1,000,000 lines
+
+```
+Benchmarking with 1000001 lines of data
+
+ruby 3.3.3 (2024-06-12 revision f1c7b6f435) [arm64-darwin23]
+Warming up --------------------------------------
+   OSV - Hash output     1.000 i/100ms
+   CSV - Hash output     1.000 i/100ms
+  OSV - Array output     1.000 i/100ms
+  CSV - Array output     1.000 i/100ms
+FastCSV - Array output
+                         1.000 i/100ms
+      OSV - StringIO     1.000 i/100ms
+      CSV - StringIO     1.000 i/100ms
+  FastCSV - StringIO     1.000 i/100ms
+       OSV - Gzipped     1.000 i/100ms
+       CSV - Gzipped     1.000 i/100ms
+Calculating -------------------------------------
+   OSV - Hash output      0.578 (± 0.0%) i/s     (1.73 s/i) -      3.000 in   5.287845s
+   CSV - Hash output      0.117 (± 0.0%) i/s     (8.57 s/i) -      1.000 in   8.571770s
+  OSV - Array output      1.142 (± 0.0%) i/s  (875.97 ms/i) -      5.000 in   5.234694s
+  CSV - Array output      0.235 (± 0.0%) i/s     (4.25 s/i) -      2.000 in   8.561144s
+FastCSV - Array output
+                          0.768 (± 0.0%) i/s     (1.30 s/i) -      4.000 in   6.924574s
+      OSV - StringIO      0.522 (± 0.0%) i/s     (1.91 s/i) -      3.000 in   5.803969s
+      CSV - StringIO      0.132 (± 0.0%) i/s     (7.59 s/i) -      1.000 in   7.593243s
+  FastCSV - StringIO      1.039 (± 0.0%) i/s  (962.53 ms/i) -      6.000 in   5.806644s
+       OSV - Gzipped      0.437 (± 0.0%) i/s     (2.29 s/i) -      3.000 in   6.885125s
+       CSV - Gzipped      0.115 (± 0.0%) i/s     (8.68 s/i) -      1.000 in   8.684069s
+
+Comparison:
+  OSV - Array output:        1.1 i/s
+  FastCSV - StringIO:        1.0 i/s - 1.10x  slower
+FastCSV - Array output:        0.8 i/s - 1.49x  slower
+   OSV - Hash output:        0.6 i/s - 1.98x  slower
+      OSV - StringIO:        0.5 i/s - 2.19x  slower
+       OSV - Gzipped:        0.4 i/s - 2.61x  slower
+  CSV - Array output:        0.2 i/s - 4.86x  slower
+      CSV - StringIO:        0.1 i/s - 8.67x  slower
+   CSV - Hash output:        0.1 i/s - 9.79x  slower
+       CSV - Gzipped:        0.1 i/s - 9.91x  slower
+```

data/ext/osv/Cargo.toml

@@ -14,3 +14,4 @@ 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"

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

@@ -1,11 +1,50 @@
 use super::{
-    header_cache::StringCache,
+    header_cache::{CacheError, StringCache},
     parser::RecordParser,
-    reader::{ReadImpl, RecordReader},
+    read_impl::ReadImpl,
+    reader::RecordReader,
 };
 use flate2::read::GzDecoder;
-use magnus::{rb_sys::AsRawValue, value::ReprValue, Error, RString, Ruby, Value};
-use std::{fs::File, io::Read, marker::PhantomData, os::fd::FromRawFd, thread};
+use magnus::{rb_sys::AsRawValue, value::ReprValue, Error as MagnusError, RString, Ruby, Value};
+use std::{
+    fs::File,
+    io::{self, Read},
+    marker::PhantomData,
+    os::fd::FromRawFd,
+    thread,
+};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ReaderError {
+    #[error("Failed to get file descriptor: {0}")]
+    FileDescriptor(String),
+    #[error("Invalid file descriptor")]
+    InvalidFileDescriptor,
+    #[error("Failed to open file: {0}")]
+    FileOpen(#[from] io::Error),
+    #[error("Failed to intern headers: {0}")]
+    HeaderIntern(#[from] CacheError),
+    #[error("Unsupported GzipReader")]
+    UnsupportedGzipReader,
+    #[error("Ruby error: {0}")]
+    Ruby(String),
+}
+
+impl From<MagnusError> for ReaderError {
+    fn from(err: MagnusError) -> Self {
+        Self::Ruby(err.to_string())
+    }
+}
+
+impl From<ReaderError> for MagnusError {
+    fn from(err: ReaderError) -> Self {
+        MagnusError::new(
+            Ruby::get().unwrap().exception_runtime_error(),
+            err.to_string(),
+        )
+    }
+}
 
 pub struct RecordReaderBuilder<'a, T: RecordParser + Send + 'static> {
     ruby: &'a Ruby,
@@ -13,7 +52,7 @@ pub struct RecordReaderBuilder<'a, T: RecordParser + Send + 'static> {
     has_headers: bool,
     delimiter: u8,
     quote_char: u8,
-    null_string: String,
+    null_string: Option<String>,
     buffer: usize,
     _phantom: PhantomData<T>,
 }
@@ -26,7 +65,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             has_headers: true,
             delimiter: b',',
             quote_char: b'"',
-            null_string: String::new(),
+            null_string: None,
             buffer: 1000,
             _phantom: PhantomData,
         }
@@ -47,7 +86,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
         self
     }
 
-    pub fn null_string(mut self, null_string: String) -> Self {
+    pub fn null_string(mut self, null_string: Option<String>) -> Self {
         self.null_string = null_string;
         self
     }
@@ -57,36 +96,83 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
         self
     }
 
-    fn get_reader(&self) -> Result<Box<dyn Read + Send + 'static>, Error> {
+    fn handle_string_io(&self) -> Result<Box<dyn Read + Send + 'static>, ReaderError> {
+        let string: RString = self.to_read.funcall("string", ())?;
+        let content = string.to_string()?;
+        Ok(Box::new(std::io::Cursor::new(content)))
+    }
+
+    fn handle_file_descriptor(&self) -> Result<Box<dyn Read + Send + 'static>, 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(|_| {
+                ReaderError::FileDescriptor("Failed to get file descriptor".to_string())
+            })?;
+
+        if fd < 0 {
+            return Err(ReaderError::InvalidFileDescriptor);
+        }
+
+        let file = unsafe { File::from_raw_fd(fd) };
+        Ok(Box::new(file))
+    }
+
+    fn handle_file_path(&self) -> Result<Box<dyn Read + Send + 'static>, ReaderError> {
+        let path = self.to_read.to_r_string()?.to_string()?;
+        let file = File::open(&path)?;
+
+        Ok(if path.ends_with(".gz") {
+            Box::new(GzDecoder::new(file))
+        } else {
+            Box::new(file)
+        })
+    }
+
+    fn get_reader(&self) -> Result<Box<dyn Read + Send + 'static>, ReaderError> {
         let string_io: magnus::RClass = self.ruby.eval("StringIO")?;
+        let gzip_reader_class: magnus::RClass = self.ruby.eval("Zlib::GzipReader")?;
 
         if self.to_read.is_kind_of(string_io) {
-            let string: RString = self.to_read.funcall("string", ())?;
-            let content = string.to_string()?;
-            Ok(Box::new(std::io::Cursor::new(content)))
+            self.handle_string_io()
+        } else if self.to_read.is_kind_of(gzip_reader_class) {
+            Err(ReaderError::UnsupportedGzipReader)
         } else if self.to_read.is_kind_of(self.ruby.class_io()) {
-            let fd = unsafe { rb_sys::rb_io_descriptor(self.to_read.as_raw()) };
-            let file = unsafe { File::from_raw_fd(fd) };
-            Ok(Box::new(file))
+            self.handle_file_descriptor()
         } else {
-            let path = self.to_read.to_r_string()?.to_string()?;
-            let file = std::fs::File::open(&path).map_err(|e| {
-                Error::new(
-                    self.ruby.exception_runtime_error(),
-                    format!("Failed to open file: {e}"),
-                )
-            })?;
-            if path.ends_with(".gz") {
-                let file = GzDecoder::new(file);
-                Ok(Box::new(file))
-            } else {
-                Ok(Box::new(file))
+            self.handle_file_path()
+        }
+    }
+
+    fn get_single_threaded_reader(&self) -> Result<Box<dyn Read>, ReaderError> {
+        let string_io: magnus::RClass = self.ruby.eval("StringIO")?;
+        let gzip_reader_class: magnus::RClass = self.ruby.eval("Zlib::GzipReader")?;
+
+        if self.to_read.is_kind_of(string_io) {
+            self.handle_string_io().map(|r| -> Box<dyn Read> { r })
+        } else if self.to_read.is_kind_of(gzip_reader_class) {
+            Ok(Box::new(RubyReader::new(self.to_read)))
+        } else if self.to_read.is_kind_of(self.ruby.class_io()) {
+            self.handle_file_descriptor()
+                .map(|r| -> Box<dyn Read> { r })
+        } else {
+            self.handle_file_path().map(|r| -> Box<dyn Read> { r })
+        }
+    }
+
+    pub fn build(self) -> Result<RecordReader<T>, ReaderError> {
+        match self.get_reader() {
+            Ok(readable) => self.build_multi_threaded(readable),
+            Err(_) => {
+                let readable = self.get_single_threaded_reader()?;
+                self.build_single_threaded(readable)
             }
         }
     }
 
-    pub fn build(self) -> Result<RecordReader<T>, Error> {
-        let readable = self.get_reader()?;
+    fn build_multi_threaded(
+        self,
+        readable: Box<dyn Read + Send + 'static>,
+    ) -> Result<RecordReader<T>, ReaderError> {
         let mut reader = csv::ReaderBuilder::new()
             .has_headers(self.has_headers)
             .delimiter(self.delimiter)
@@ -94,21 +180,16 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             .from_reader(readable);
 
         let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;
-        let null_string = self.null_string;
-
-        let static_headers = StringCache::intern_many(&headers).map_err(|e| {
-            Error::new(
-                self.ruby.exception_runtime_error(),
-                format!("Failed to intern headers: {e}"),
-            )
-        })?;
+        let static_headers = StringCache::intern_many(&headers)?;
         let headers_for_cleanup = static_headers.clone();
 
         let (sender, receiver) = kanal::bounded(self.buffer);
+        let null_string = self.null_string.clone();
+
         let handle = thread::spawn(move || {
             let mut record = csv::StringRecord::new();
             while let Ok(true) = reader.read_record(&mut record) {
-                let row = T::parse(&static_headers, &record, &null_string);
+                let row = T::parse(&static_headers, &record, null_string.as_deref());
                 if sender.send(row).is_err() {
                     break;
                 }
@@ -125,4 +206,58 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             },
         })
     }
+
+    fn build_single_threaded(
+        self,
+        readable: Box<dyn Read>,
+    ) -> Result<RecordReader<T>, ReaderError> {
+        let mut reader = csv::ReaderBuilder::new()
+            .has_headers(self.has_headers)
+            .delimiter(self.delimiter)
+            .quote(self.quote_char)
+            .from_reader(readable);
+
+        let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;
+        let static_headers = StringCache::intern_many(&headers)?;
+
+        Ok(RecordReader {
+            reader: ReadImpl::SingleThreaded {
+                reader,
+                headers: static_headers,
+                null_string: self.null_string,
+            },
+        })
+    }
+}
+
+struct RubyReader {
+    inner: Value,
+}
+
+impl RubyReader {
+    fn new(inner: Value) -> Self {
+        Self { inner }
+    }
+}
+
+impl Read for RubyReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let result = self.inner.funcall::<_, _, Value>("read", (buf.len(),));
+        match result {
+            Ok(data) => {
+                if data.is_nil() {
+                    return Ok(0);
+                }
+
+                let string = RString::from_value(data).ok_or_else(|| {
+                    io::Error::new(io::ErrorKind::Other, "Failed to convert to RString")
+                })?;
+                let bytes = unsafe { string.as_slice() };
+                let len = bytes.len().min(buf.len());
+                buf[..len].copy_from_slice(&bytes[..len]);
+                Ok(len)
+            }
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e.to_string())),
+        }
+    }
 }

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

@@ -4,22 +4,29 @@
 ///
 /// Note: Performance testing on macOS showed minimal speed improvements,
 /// so this optimization could be removed if any issues arise.
-
-
 use std::{
     collections::HashMap,
     sync::{atomic::AtomicU32, LazyLock, Mutex},
 };
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum CacheError {
+    #[error("Failed to acquire lock: {0}")]
+    LockError(String),
+}
 
 static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, AtomicU32>>> =
     LazyLock::new(|| Mutex::new(HashMap::with_capacity(100)));
 
-pub struct StringCache {}
+pub struct StringCache;
 
 impl StringCache {
     #[allow(dead_code)]
-    pub fn intern(string: String) -> Result<&'static str, String> {
-        let mut cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
+    pub fn intern(string: String) -> Result<&'static str, CacheError> {
+        let mut cache = STRING_CACHE
+            .lock()
+            .map_err(|e| CacheError::LockError(e.to_string()))?;
 
         if let Some((&existing, count)) = cache.get_key_value(string.as_str()) {
             count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
@@ -31,33 +38,36 @@ impl StringCache {
         }
     }
 
-    pub fn intern_many(strings: &[String]) -> Result<Vec<&'static str>, String> {
-        let mut cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
-        let mut result = Vec::with_capacity(strings.len());
+    pub fn intern_many(strings: &[String]) -> Result<Vec<&'static str>, CacheError> {
+        let mut cache = STRING_CACHE
+            .lock()
+            .map_err(|e| CacheError::LockError(e.to_string()))?;
 
+        let mut result = Vec::with_capacity(strings.len());
         for string in strings {
-            let static_str: &'static str =
-                if let Some((&existing, count)) = cache.get_key_value(string.as_str()) {
-                    count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-                    existing
-                } else {
-                    let leaked = Box::leak(string.clone().into_boxed_str());
-                    cache.insert(leaked, AtomicU32::new(1));
-                    leaked
-                };
-            result.push(static_str);
+            if let Some((&existing, count)) = cache.get_key_value(string.as_str()) {
+                count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                result.push(existing);
+            } else {
+                let leaked = Box::leak(string.clone().into_boxed_str());
+                cache.insert(leaked, AtomicU32::new(1));
+                result.push(leaked);
+            }
         }
-
         Ok(result)
     }
 
-    pub fn clear(headers: &[&'static str]) -> Result<(), String> {
-        let cache = STRING_CACHE.lock().map_err(|e| e.to_string())?;
+    pub fn clear(headers: &[&'static str]) -> Result<(), CacheError> {
+        let mut cache = STRING_CACHE
+            .lock()
+            .map_err(|e| CacheError::LockError(e.to_string()))?;
 
         for header in headers {
             if let Some(count) = cache.get(header) {
-                let remaining = count.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
-                if remaining == 0 {
+                // Returns the previous value of the counter
+                let was = count.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
+                if was == 1 {
+                    cache.remove(header);
                     let ptr = *header as *const str as *mut str;
                     unsafe {
                         let _ = Box::from_raw(ptr);

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

@@ -1,6 +1,7 @@
 mod builder;
 mod header_cache;
 mod parser;
+pub mod read_impl;
 mod reader;
 mod record;
 

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

@@ -2,50 +2,68 @@ use std::collections::HashMap;
 
 pub trait RecordParser {
     type Output;
+
     fn parse(
         headers: &[&'static str],
         record: &csv::StringRecord,
-        null_string: &str,
+        null_string: Option<&str>,
     ) -> Self::Output;
 }
 
 impl RecordParser for HashMap<&'static str, Option<String>> {
     type Output = Self;
+
+    #[inline]
     fn parse(
         headers: &[&'static str],
         record: &csv::StringRecord,
-        null_string: &str,
+        null_string: Option<&str>,
     ) -> Self::Output {
         let mut map = HashMap::with_capacity(headers.len());
-        for (header, field) in headers.iter().zip(record.iter()) {
-            map.insert(
-                *header,
-                if field == null_string {
-                    None
-                } else {
-                    Some(field.to_string())
-                },
-            );
-        }
+        headers
+            .iter()
+            .zip(record.iter())
+            .for_each(|(header, field)| {
+                map.insert(
+                    *header,
+                    if null_string == Some(field) {
+                        None
+                    } else {
+                        // Avoid allocating for empty strings
+                        if field.is_empty() {
+                            Some(String::new())
+                        } else {
+                            Some(field.to_string())
+                        }
+                    },
+                );
+            });
         map
     }
 }
 
 impl RecordParser for Vec<Option<String>> {
     type Output = Self;
+
+    #[inline]
     fn parse(
         _headers: &[&'static str],
         record: &csv::StringRecord,
-        null_string: &str,
+        null_string: Option<&str>,
     ) -> Self::Output {
         let mut vec = Vec::with_capacity(record.len());
-        for field in record.iter() {
-            vec.push(if field == null_string {
+        vec.extend(record.iter().map(|field| {
+            if null_string == Some(field) {
                 None
             } else {
-                Some(field.to_string())
-            });
-        }
+                // Avoid allocating for empty strings
+                if field.is_empty() {
+                    Some(String::new())
+                } else {
+                    Some(field.to_string())
+                }
+            }
+        }));
         vec
     }
 }

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

@@ -0,0 +1,65 @@
+use super::{header_cache::StringCache, parser::RecordParser};
+use std::{io::Read, thread};
+
+pub enum ReadImpl<T: RecordParser> {
+    SingleThreaded {
+        reader: csv::Reader<Box<dyn Read>>,
+        headers: Vec<&'static str>,
+        null_string: Option<String>,
+    },
+    MultiThreaded {
+        headers: Vec<&'static str>,
+        receiver: kanal::Receiver<T::Output>,
+        handle: Option<thread::JoinHandle<()>>,
+    },
+}
+
+impl<T: RecordParser> ReadImpl<T> {
+    #[inline]
+    pub fn next(&mut self) -> Option<T::Output> {
+        match self {
+            Self::MultiThreaded {
+                receiver, handle, ..
+            } => match receiver.recv() {
+                Ok(record) => Some(record),
+                Err(_) => {
+                    if let Some(handle) = handle.take() {
+                        let _ = handle.join();
+                    }
+                    None
+                }
+            },
+            Self::SingleThreaded {
+                reader,
+                headers,
+                null_string,
+            } => {
+                let mut record = csv::StringRecord::new();
+                match reader.read_record(&mut record) {
+                    Ok(true) => Some(T::parse(headers, &record, null_string.as_deref())),
+                    _ => None,
+                }
+            }
+        }
+    }
+
+    #[inline]
+    pub fn cleanup(&mut self) {
+        match self {
+            Self::MultiThreaded {
+                receiver,
+                handle,
+                headers,
+            } => {
+                receiver.close();
+                if let Some(handle) = handle.take() {
+                    let _ = handle.join();
+                }
+                let _ = StringCache::clear(headers);
+            }
+            Self::SingleThreaded { headers, .. } => {
+                let _ = StringCache::clear(headers);
+            }
+        }
+    }
+}

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

@@ -1,66 +1,35 @@
-use super::{header_cache::StringCache, parser::RecordParser};
+use super::{parser::RecordParser, read_impl::ReadImpl};
 use magnus::{Error, Ruby};
-use std::{io::Read, thread};
+use std::{borrow::Cow, io::Read};
 
 pub struct RecordReader<T: RecordParser> {
     pub(crate) reader: ReadImpl<T>,
 }
 
-impl<T: RecordParser> Drop for RecordReader<T> {
-    fn drop(&mut self) {
-        match &mut self.reader {
-            ReadImpl::MultiThreaded {
-                receiver,
-                handle,
-                headers,
-            } => {
-                receiver.close();
-                if let Some(handle) = handle.take() {
-                    let _ = handle.join();
-                }
-                StringCache::clear(headers).unwrap();
-            }
-            ReadImpl::SingleThreaded { headers, .. } => {
-                StringCache::clear(headers).unwrap();
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub enum ReadImpl<T: RecordParser> {
-    SingleThreaded {
-        reader: csv::Reader<Box<dyn Read + Send + 'static>>,
-        headers: Vec<&'static str>,
-        null_string: String,
-    },
-    MultiThreaded {
-        headers: Vec<&'static str>,
-        receiver: kanal::Receiver<T::Output>,
-        handle: Option<thread::JoinHandle<()>>,
-    },
-}
-
 impl<T: RecordParser> RecordReader<T> {
+    #[inline]
     pub(crate) fn get_headers(
         ruby: &Ruby,
         reader: &mut csv::Reader<impl Read>,
         has_headers: bool,
     ) -> Result<Vec<String>, Error> {
-        let first_row = reader
-            .headers()
-            .map_err(|e| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to read headers: {e}"),
-                )
-            })?
-            .clone();
+        let first_row = reader.headers().map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                Cow::Owned(format!("Failed to read headers: {e}")),
+            )
+        })?;
 
         Ok(if has_headers {
-            first_row.iter().map(String::from).collect()
+            // Pre-allocate the vector with exact capacity
+            let mut headers = Vec::with_capacity(first_row.len());
+            headers.extend(first_row.iter().map(String::from));
+            headers
         } else {
-            (0..first_row.len()).map(|i| format!("c{i}")).collect()
+            // Pre-allocate the vector with exact capacity
+            let mut headers = Vec::with_capacity(first_row.len());
+            headers.extend((0..first_row.len()).map(|i| format!("c{i}")));
+            headers
         })
     }
 }
@@ -68,30 +37,21 @@ impl<T: RecordParser> RecordReader<T> {
 impl<T: RecordParser> Iterator for RecordReader<T> {
     type Item = T::Output;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match &mut self.reader {
-            ReadImpl::MultiThreaded {
-                receiver, handle, ..
-            } => match receiver.recv() {
-                Ok(record) => Some(record),
-                Err(_) => {
-                    if let Some(handle) = handle.take() {
-                        let _ = handle.join();
-                    }
-                    None
-                }
-            },
-            ReadImpl::SingleThreaded {
-                reader,
-                headers,
-                null_string,
-            } => {
-                let mut record = csv::StringRecord::new();
-                match reader.read_record(&mut record) {
-                    Ok(true) => Some(T::parse(headers, &record, null_string)),
-                    _ => None,
-                }
-            }
-        }
+        self.reader.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // We can't know the exact size without reading the whole file
+        (0, None)
+    }
+}
+
+impl<T: RecordParser> Drop for RecordReader<T> {
+    #[inline]
+    fn drop(&mut self) {
+        self.reader.cleanup();
     }
 }

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RHash, Ruby, Value};
+use magnus::{IntoValue, Ruby, Value};
 use std::collections::HashMap;
 
 #[derive(Debug)]
@@ -8,14 +8,16 @@ pub enum CsvRecord {
 }
 
 impl IntoValue for CsvRecord {
+    #[inline]
     fn into_value_with(self, handle: &Ruby) -> Value {
         match self {
             CsvRecord::Vec(vec) => vec.into_value_with(handle),
             CsvRecord::Map(map) => {
-                let hash = RHash::new();
-                for (k, v) in map {
-                    hash.aset(k, v).unwrap();
-                }
+                // Pre-allocate the hash with the known size
+                let hash = handle.hash_new_capa(map.len());
+                map.into_iter()
+                    .try_for_each(|(k, v)| hash.aset(k, v))
+                    .unwrap();
                 hash.into_value_with(handle)
             }
         }

data/ext/osv/src/reader.rs

@@ -71,7 +71,7 @@ struct EnumeratorArgs {
     has_headers: bool,
     delimiter: u8,
     quote_char: u8,
-    null_string: String,
+    null_string: Option<String>,
     buffer_size: usize,
     result_type: String,
 }

data/ext/osv/src/utils.rs

@@ -10,7 +10,7 @@ pub struct CsvArgs {
     pub has_headers: bool,
     pub delimiter: u8,
     pub quote_char: u8,
-    pub null_string: String,
+    pub null_string: Option<String>,
     pub buffer_size: usize,
     pub result_type: String,
 }
@@ -73,7 +73,7 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
             )
         })?;
 
-    let null_string = kwargs.optional.3.unwrap_or_else(|| "".to_string());
+    let null_string = kwargs.optional.3;
 
     let buffer_size = kwargs.optional.4.unwrap_or(1000);
 

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.3.3"
+  VERSION = "0.3.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 2024-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -52,13 +52,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- ext/osv/Cargo.lock
 - ext/osv/Cargo.toml
 - ext/osv/extconf.rb
 - ext/osv/src/csv/builder.rs
 - ext/osv/src/csv/header_cache.rs
 - ext/osv/src/csv/mod.rs
 - ext/osv/src/csv/parser.rs
+- ext/osv/src/csv/read_impl.rs
 - ext/osv/src/csv/reader.rs
 - ext/osv/src/csv/record.rs
 - ext/osv/src/lib.rs

data/ext/osv/Cargo.lock

@@ -1,402 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "bindgen"
-version = "0.69.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
-dependencies = [
- "bitflags",
- "cexpr",
- "clang-sys",
- "itertools",
- "lazy_static",
- "lazycell",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash",
- "shlex",
- "syn",
-]
-
-[[package]]
-name = "bitflags"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
-
-[[package]]
-name = "cexpr"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
-dependencies = [
- "nom",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "clang-sys"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
-dependencies = [
- "glob",
- "libc",
- "libloading",
-]
-
-[[package]]
-name = "csv"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf"
-dependencies = [
- "csv-core",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "either"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
-
-[[package]]
-name = "glob"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
-
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
-[[package]]
-name = "libc"
-version = "0.2.169"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
-
-[[package]]
-name = "libloading"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
-dependencies = [
- "cfg-if",
- "windows-targets",
-]
-
-[[package]]
-name = "magnus"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d87ae53030f3a22e83879e666cb94e58a7bdf31706878a0ba48752994146dab"
-dependencies = [
- "magnus-macros",
- "rb-sys",
- "rb-sys-env",
- "seq-macro",
-]
-
-[[package]]
-name = "magnus-macros"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
-[[package]]
-name = "osv"
-version = "0.1.0"
-dependencies = [
- "csv",
- "magnus",
- "rb-sys",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rb-sys"
-version = "0.9.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91dbe37ab6ac2fba187480fb6544b92445e41e5c6f553bf0c33743f3c450a1df"
-dependencies = [
- "rb-sys-build",
-]
-
-[[package]]
-name = "rb-sys-build"
-version = "0.9.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4d56a49dcb646b70b758789c0d16c055a386a4f2a3346333abb69850fa860ce"
-dependencies = [
- "bindgen",
- "lazy_static",
- "proc-macro2",
- "quote",
- "regex",
- "shell-words",
- "syn",
-]
-
-[[package]]
-name = "rb-sys-env"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
-
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
-
-[[package]]
-name = "rustc-hash"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
-
-[[package]]
-name = "ryu"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
-
-[[package]]
-name = "seq-macro"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
-
-[[package]]
-name = "serde"
-version = "1.0.216"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.216"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "shell-words"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "syn"
-version = "2.0.90"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"