osv 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1b0c347b0bab5c9d31069c56f47999bfa51e85dfc1e127d1c4474a84ac19c53
-  data.tar.gz: 847b199da27b7c1329c1fa64fc8636592f004e93a12fc2ddd8db6127298ac23d
+  metadata.gz: 17db543fc59ce3ec7b4ea87a0d403b82a628860ca01ba03eaea39438790b7863
+  data.tar.gz: 3d54507b6097b7b9e0a771f5a3c72d7605b27c5307528bf0707cd0f7ba29b474
 SHA512:
-  metadata.gz: 62fa77c1ca98031f483569a4dba7cf9e4eca52a4b5fae293d274d5f89c48003e301eab01d95116cfc9cc6a2642e742d16046231a21d25e4a5143bd6ec3b40dac
-  data.tar.gz: 3832cbb6ebadfc718a8a5d1963de960ed3abf09d4559d2f0ffe031c642a6c2581dc6ad6edf5d65f22248812585ca464916375503753831024fc355fe4cd04455
+  metadata.gz: 975e4e16a32d1c2d5678f1c4ede658165fcf247f563c166fa167bff7d9bfd95c34937f894207693df2e6716b61fce8c315b6bb4dad7a29d68161ab842768eca1
+  data.tar.gz: 9176674f894855098875df2c3287b4370b42193f84d7bdf20d13fa8ea9de9330a431c3070a00652458bbb0a8061866e69b4849a6ee71c1b90718e811d1ed7172

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nathan Jaremko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# OSV
+
+OSV is a high-performance CSV parser for Ruby, implemented in Rust. It wraps BurntSushi's excellent [csv-rs](https://github.com/BurntSushi/rust-csv) crate.
+
+It provides a simple interface for reading CSV files with support for both hash-based and array-based row formats.
+
+The array-based mode is faster than the hash-based mode, so if you don't need the hash keys, use the array-based mode.
+
+I have yet to figure out how to get rust to accept an implementation of this as one method with different return types, so I've had to implement two methods.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'osv'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install osv
+```
+
+## Usage
+
+### Basic Usage with Hash Output
+
+Each row is returned as a hash where the keys are the column headers:
+
+```ruby
+require 'osv'
+
+# Read from a file
+OSV.for_each("path/to/file.csv") do |row|
+  # row is a Hash like {"name" => "John", "age" => "25"}
+  puts row["name"]
+end
+
+# Without a block, returns an Enumerator
+rows = OSV.for_each("path/to/file.csv")
+rows.each { |row| puts row["name"] }
+```
+
+### Array Output Mode
+
+If you prefer working with arrays instead of hashes, use `for_each_compat`:
+
+```ruby
+OSV.for_each_compat("path/to/file.csv") do |row|
+  # row is an Array like ["John", "25"]
+  puts row[0]
+end
+```
+
+### Options
+
+Both methods support the following options:
+
+- `has_headers`: Boolean indicating if the first row contains headers (default: true)
+- `delimiter`: String specifying the field separator (default: ",")
+
+```ruby
+# Reading TSV files
+OSV.for_each("path/to/file.tsv", delimiter: "\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
+```
+
+### Input Sources
+
+OSV supports reading from:
+
+- File paths (as strings)
+- IO objects
+  - Important caveat: the IO object must respond to `rb_io_descriptor` with a file descriptor.
+- StringIO objects
+  - Note: when you do this, the string is read (in full) into a Rust string, and we parse it there.
+
+```ruby
+# From file path
+OSV.for_each("path/to/file.csv") { |row| puts row["name"] }
+
+# From IO object
+File.open("path/to/file.csv") do |file|
+  OSV.for_each(file) { |row| puts row["name"] }
+end
+
+# From StringIO
+data = StringIO.new("name,age\nJohn,25")
+OSV.for_each(data) { |row| puts row["name"] }
+```
+
+## Requirements
+
+- Ruby >= 3.1.0
+- Rust toolchain (for installation from source)
+
+## Performance
+
+This library is faster than the standard Ruby CSV library, and is comparable to the fastest CSV parser gems I've used.
+
+## License
+
+This gem is not currently licensed for public use.

data/ext/osv/src/reader.rs

@@ -2,20 +2,20 @@ use crate::utils::*;
 use magnus::{
     block::Yield, rb_sys::AsRawValue, value::ReprValue, Error, RClass, RString, Ruby, Value,
 };
-use std::{fs::File, io::Read, os::fd::FromRawFd, thread};
+use std::{collections::HashMap, fs::File, io::Read, os::fd::FromRawFd, thread};
 
 /// Parses CSV data from a file and yields each row as a hash to the block.
 pub fn parse_csv(
     ruby: &Ruby,
     rb_self: Value,
     args: &[Value],
-) -> Result<Yield<impl Iterator<Item = std::collections::HashMap<String, String>>>, Error> {
+) -> Result<Yield<impl Iterator<Item = HashMap<String, String>>>, Error> {
     if !ruby.block_given() {
         return Ok(Yield::Enumerator(rb_self.enumeratorize("for_each", args)));
     }
     let (to_read, has_headers, delimiter) = parse_csv_args(args)?;
 
-    let iter = RecordReader::<std::collections::HashMap<String, String>>::new(
+    let iter = RecordReader::<HashMap<String, String>>::new(
         ruby,
         to_read,
         has_headers,
@@ -55,15 +55,16 @@ pub trait RecordParser {
     fn parse(headers: &[String], record: &csv::StringRecord) -> Self::Output;
 }
 
-impl RecordParser for std::collections::HashMap<String, String> {
+impl RecordParser for HashMap<String, String> {
     type Output = Self;
 
     fn parse(headers: &[String], record: &csv::StringRecord) -> Self::Output {
-        record
-            .iter()
-            .enumerate()
-            .map(|(i, field)| (headers[i].clone(), field.to_string()))
-            .collect()
+        let capacity = headers.len();
+        let mut map = HashMap::with_capacity(capacity);
+        for (i, field) in record.iter().enumerate() {
+            map.insert(headers[i].to_owned(), field.to_string());
+        }
+        map
     }
 }
 
@@ -71,7 +72,11 @@ impl RecordParser for Vec<String> {
     type Output = Self;
 
     fn parse(_headers: &[String], record: &csv::StringRecord) -> Self::Output {
-        record.iter().map(|field| field.to_string()).collect()
+        let mut output = Vec::with_capacity(record.len());
+        for field in record.iter() {
+            output.push(field.to_string());
+        }
+        output
     }
 }
 
@@ -99,12 +104,12 @@ impl<T: RecordParser + Send + 'static> RecordReader<T> {
         delimiter: u8,
         buffer: usize,
     ) -> Result<Self, Error> {
-        let string_io = RClass::from(ruby.eval("StringIO").map_err(|e| {
+        let string_io: RClass = ruby.eval("StringIO").map_err(|e| {
             Error::new(
                 ruby.exception_runtime_error(),
                 format!("Failed to get StringIO class: {}", e),
             )
-        })?);
+        })?;
 
         let readable: Box<dyn Read + Send + 'static> = if to_read.is_kind_of(string_io) {
             let string: RString = to_read.funcall("string", ()).map_err(|e| {

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Nathan Jaremko
@@ -49,6 +49,8 @@ files:
 - Cargo.lock
 - Cargo.toml
 - Gemfile
+- LICENSE
+- README.md
 - Rakefile
 - ext/osv/Cargo.lock
 - ext/osv/Cargo.toml