osv 0.3.9 → 0.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935cf4c277ef52eb1b1c4a4c27d2fe54461489b38b4203a1e574ac1a9e3298df
-  data.tar.gz: aa13944483b0f9fa8963a830d5f2a2932110e86bb32c722565c2b4d5f9dbef3c
+  metadata.gz: 593a3c94b6ec0366399485444f4d5d6c45b04393cad30686e04b43f289b93d88
+  data.tar.gz: 9ae3ce1ff2655d65c726680a412336e853f3fa0328756b5dea69186b2c82654b
 SHA512:
-  metadata.gz: ea38b823a0423ef8883c04f6b677b16ba5d55f9a23faf434fc758788d238972b17b6e2435f0ec92661a32ee31fafb39170c81933d67a201af8cd528678e6261a
-  data.tar.gz: 77a62c7d62f36bd4143166d65c64eecccece56f1ebb969295cf7af6ff8639af9df71b3923d3ba13590824db68604e90cdc61e22490e81a3d0e24bf1af5f0be47
+  metadata.gz: a24c9b58b291d934ae6526e88baddebd768ad4ad431bfab8353b84d4e9f284e954aa2dd80b11138c041613702d56927f3fc4819b9fdcda2a22b5a590ba5459fa
+  data.tar.gz: 0a85ef04fc18b4ef680d669c4fb06310b0cd3a0eb2c6c3c5a0a9161bc5af8b8851bf7ca3c1cb08f3fc6fa2d96449e112b86d0bc47871cbd10cae5ebd332edfb4

data/README.md

@@ -30,38 +30,68 @@ gem install osv
 
 ## Usage
 
-### Basic Usage with Hash Output
-
-Each row is returned as a hash where the keys are the column headers:
+### Reading CSV Files
 
 ```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"]
+# Basic usage - each row as a hash
+OSV.for_each("data.csv") do |row|
+  puts row["name"]  # => "John"
+  puts row["age"]   # => "25"
 end
 
-# Without a block, returns an Enumerator
-rows = OSV.for_each("path/to/file.csv")
+# Return an enumerator instead of using a block
+rows = OSV.for_each("data.csv")
 rows.each { |row| puts row["name"] }
-```
 
-### Array Output Mode
+# High-performance array mode
+OSV.for_each("data.csv", result_type: :array) do |row|
+  puts row[0]  # First column
+  puts row[1]  # Second column
+end
+```
 
-If you prefer working with arrays instead of hashes, use `for_each_compat`:
+### Input Sources
 
 ```ruby
-OSV.for_each("path/to/file.csv", result_type: :array) do |row|
-  # row is an Array like ["John", "25"]
-  puts row[0]
-end
+# From a file path
+OSV.for_each("data.csv") { |row| puts row["name"] }
+
+# From a file path
+OSV.for_each("data.csv.gz") { |row| puts row["name"] }
+
+# From an IO object
+File.open("data.csv") { |file| OSV.for_each(file) { |row| puts row["name"] } }
+
+# From a string
+data = StringIO.new("name,age\nJohn,25")
+OSV.for_each(data) { |row| puts row["name"] }
 ```
 
-### Options
+### Configuration Options
 
-Both methods support the following options:
+```ruby
+OSV.for_each("data.csv",
+  # Input formatting
+  has_headers: true,     # First row contains headers (default: true)
+  col_sep: ",",          # Column separator (default: ",")
+  quote_char: '"',       # Quote character (default: '"')
+
+  # Output formatting
+  result_type: :hash,    # :hash or :array (hash is default)
+  nil_string: nil,       # String to interpret as nil when parsing (default: nil)
+
+  # Parsing behavior
+  flexible: false,       # Allow varying number of fields (default: false)
+  flexible_default: nil, # Default value for missing fields. If unset, we ignore missing fields.
+                         # Implicitly enables flexible mode if set.
+  trim: :all,            # Whether to trim whitespace. Options are :all, :headers, or :fields (default: nil)
+  buffer_size: 1024,     # Number of rows to buffer in memory (default: 1024)
+)
+```
+
+#### Available Options
 
 - `has_headers`: Boolean indicating if the first row contains headers (default: true)
 - `col_sep`: String specifying the field separator (default: ",")
@@ -69,34 +99,13 @@ Both methods support the following options:
 - `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")
+- `buffer_size`: Integer specifying the number of rows to buffer in memory (default: 1024)
+- `result_type`: String specifying the output format ("hash" or "array" or :hash or :array)
 - `flexible`: Boolean specifying if the parser should be flexible (default: false)
 - `flexible_default`: String specifying the default value for missing fields. Implicitly enables flexible mode if set. (default: `nil`)
+- `trim`: String specifying the trim mode ("all" or "headers" or "fields" or :all or :headers or :fields)
 
-### 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"] }
-```
+When `has_headers` is false, hash keys will be generated as `"c0"`, `"c1"`, etc.
 
 ## Requirements
 

data/Rakefile

@@ -20,3 +20,10 @@ Rake::TestTask.new do |t|
   t.libs << "lib"
   t.libs << "test"
 end
+
+task :release do
+  sh "bundle exec rake test"
+  sh "mkdir -p pkg"
+  sh "gem build osv.gemspec -o pkg/osv-#{OSV::VERSION}.gem"
+  sh "gem push pkg/osv-#{OSV::VERSION}.gem"
+end

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

@@ -59,6 +59,7 @@ pub struct RecordReaderBuilder<'a, T: RecordParser + Send + 'static> {
     buffer: usize,
     flexible: bool,
     flexible_default: Option<String>,
+    trim: csv::Trim,
     _phantom: PhantomData<T>,
 }
 
@@ -74,6 +75,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             buffer: BUFFER_CHANNEL_SIZE,
             flexible: false,
             flexible_default: None,
+            trim: csv::Trim::None,
             _phantom: PhantomData,
         }
     }
@@ -113,6 +115,11 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
         self
     }
 
+    pub fn trim(mut self, trim: csv::Trim) -> Self {
+        self.trim = trim;
+        self
+    }
+
     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()?;
@@ -200,6 +207,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             .delimiter(self.delimiter)
             .quote(self.quote_char)
             .flexible(flexible)
+            .trim(self.trim)
             .from_reader(readable);
 
         let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;
@@ -248,6 +256,7 @@ impl<'a, T: RecordParser + Send + 'static> RecordReaderBuilder<'a, T> {
             .delimiter(self.delimiter)
             .quote(self.quote_char)
             .flexible(flexible)
+            .trim(self.trim)
             .from_reader(readable);
 
         let headers = RecordReader::<T>::get_headers(self.ruby, &mut reader, self.has_headers)?;

data/ext/osv/src/reader.rs

@@ -1,5 +1,6 @@
 use crate::csv::{CsvRecord, RecordReaderBuilder};
 use crate::utils::*;
+use csv::Trim;
 use magnus::value::ReprValue;
 use magnus::{block::Yield, Error, KwArgs, RHash, Ruby, Symbol, Value};
 use std::collections::HashMap;
@@ -21,6 +22,7 @@ pub fn parse_csv(
         result_type,
         flexible,
         flexible_default,
+        trim,
     } = parse_csv_args(&ruby, args)?;
 
     if !ruby.block_given() {
@@ -35,6 +37,12 @@ pub fn parse_csv(
             result_type,
             flexible,
             flexible_default,
+            trim: match trim {
+                Trim::All => Some("all".to_string()),
+                Trim::Headers => Some("headers".to_string()),
+                Trim::Fields => Some("fields".to_string()),
+                _ => None,
+            },
         });
     }
 
@@ -46,6 +54,7 @@ pub fn parse_csv(
             .has_headers(has_headers)
             .flexible(flexible)
             .flexible_default(flexible_default)
+            .trim(trim)
             .delimiter(delimiter)
             .quote_char(quote_char)
             .null_string(null_string)
@@ -58,6 +67,7 @@ pub fn parse_csv(
                 .has_headers(has_headers)
                 .flexible(flexible)
                 .flexible_default(flexible_default)
+                .trim(trim)
                 .delimiter(delimiter)
                 .quote_char(quote_char)
                 .null_string(null_string)
@@ -87,6 +97,7 @@ struct EnumeratorArgs {
     result_type: String,
     flexible: bool,
     flexible_default: Option<String>,
+    trim: Option<String>,
 }
 
 fn create_enumerator(
@@ -107,6 +118,7 @@ fn create_enumerator(
     kwargs.aset(Symbol::new("result_type"), Symbol::new(args.result_type))?;
     kwargs.aset(Symbol::new("flexible"), args.flexible)?;
     kwargs.aset(Symbol::new("flexible_default"), args.flexible_default)?;
+    kwargs.aset(Symbol::new("trim"), args.trim.map(Symbol::new))?;
     let enumerator = args
         .rb_self
         .enumeratorize("for_each", (args.to_read, KwArgs(kwargs)));

data/ext/osv/src/utils.rs

@@ -6,6 +6,27 @@ use magnus::{
 
 use crate::csv::BUFFER_CHANNEL_SIZE;
 
+fn parse_string_or_symbol(ruby: &Ruby, value: Value) -> Result<Option<String>, Error> {
+    if value.is_nil() {
+        Ok(None)
+    } else if value.is_kind_of(ruby.class_string()) {
+        RString::from_value(value)
+            .ok_or_else(|| Error::new(magnus::exception::type_error(), "Invalid string value"))?
+            .to_string()
+            .map(|s| Some(s))
+    } else if value.is_kind_of(ruby.class_symbol()) {
+        Symbol::from_value(value)
+            .ok_or_else(|| Error::new(magnus::exception::type_error(), "Invalid symbol value"))?
+            .funcall("to_s", ())
+            .map(|s| Some(s))
+    } else {
+        Err(Error::new(
+            magnus::exception::type_error(),
+            "Value must be a String or Symbol",
+        ))
+    }
+}
+
 #[derive(Debug)]
 pub struct CsvArgs {
     pub to_read: Value,
@@ -17,6 +38,7 @@ pub struct CsvArgs {
     pub result_type: String,
     pub flexible: bool,
     pub flexible_default: Option<String>,
+    pub trim: csv::Trim,
 }
 
 /// Parse common arguments for CSV parsing
@@ -36,6 +58,7 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
             Option<Value>,
             Option<bool>,
             Option<Option<String>>,
+            Option<Value>,
         ),
         (),
     >(
@@ -50,6 +73,7 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
             "result_type",
             "flexible",
             "flexible_default",
+            "trim",
         ],
     )?;
 
@@ -85,36 +109,26 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
 
     let buffer_size = kwargs.optional.4.unwrap_or(BUFFER_CHANNEL_SIZE);
 
-    let result_type = match kwargs.optional.5 {
-        Some(value) => {
-            let parsed = if value.is_kind_of(ruby.class_string()) {
-                RString::from_value(value)
-                    .ok_or_else(|| {
-                        Error::new(magnus::exception::type_error(), "Invalid string value")
-                    })?
-                    .to_string()?
-            } else if value.is_kind_of(ruby.class_symbol()) {
-                Symbol::from_value(value)
-                    .ok_or_else(|| {
-                        Error::new(magnus::exception::type_error(), "Invalid symbol value")
-                    })?
-                    .funcall("to_s", ())?
-            } else {
+    let result_type = match kwargs
+        .optional
+        .5
+        .map(|value| parse_string_or_symbol(ruby, value))
+    {
+        Some(Ok(Some(parsed))) => match parsed.as_str() {
+            "hash" | "array" => parsed,
+            _ => {
                 return Err(Error::new(
-                    magnus::exception::type_error(),
-                    "result_type must be a String or Symbol",
-                ));
-            };
-
-            match parsed.as_str() {
-                "hash" | "array" => parsed,
-                _ => {
-                    return Err(Error::new(
-                        magnus::exception::runtime_error(),
-                        "result_type must be either 'hash' or 'array'",
-                    ))
-                }
+                    magnus::exception::runtime_error(),
+                    "result_type must be either 'hash' or 'array'",
+                ))
             }
+        },
+        Some(Ok(None)) => String::from("hash"),
+        Some(Err(_)) => {
+            return Err(Error::new(
+                magnus::exception::type_error(),
+                "result_type must be a String or Symbol",
+            ))
         }
         None => String::from("hash"),
     };
@@ -123,6 +137,35 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
 
     let flexible_default = kwargs.optional.7.unwrap_or_default();
 
+    let trim = match kwargs
+        .optional
+        .8
+        .map(|value| parse_string_or_symbol(ruby, value))
+    {
+        Some(Ok(Some(parsed))) => match parsed.as_str() {
+            "all" => csv::Trim::All,
+            "headers" => csv::Trim::Headers,
+            "fields" => csv::Trim::Fields,
+            invalid => {
+                return Err(Error::new(
+                    magnus::exception::runtime_error(),
+                    format!(
+                        "trim must be either 'all', 'headers', or 'fields' but got '{}'",
+                        invalid
+                    ),
+                ))
+            }
+        },
+        Some(Ok(None)) => csv::Trim::None,
+        Some(Err(_)) => {
+            return Err(Error::new(
+                magnus::exception::type_error(),
+                "trim must be a String or Symbol",
+            ))
+        }
+        None => csv::Trim::None,
+    };
+
     Ok(CsvArgs {
         to_read,
         has_headers,
@@ -133,5 +176,6 @@ pub fn parse_csv_args(ruby: &Ruby, args: &[Value]) -> Result<CsvArgs, Error> {
         result_type,
         flexible,
         flexible_default,
+        trim,
     })
 }

data/lib/osv/version.rb

@@ -1,3 +1,3 @@
 module OSV
-  VERSION = "0.3.9"
+  VERSION = "0.3.11"
 end

data/lib/osv.rbi

@@ -14,12 +14,15 @@ module OSV
   #                   an empty string.
   #   - `buffer_size`: Integer specifying the read buffer size
   #   - `result_type`: String specifying the output format
-  #                    ("hash" or "array")
+  #                    ("hash" or "array" or :hash or :array)
   #   - `flexible`: Boolean specifying if the parser should be flexible
   #                 (default: false)
   #   - `flexible_default`: String specifying the default value for missing fields.
   #                         Implicitly enables flexible mode if set.
   #                         (default: `nil`)
+  #   - `trim`: String specifying the trim mode
+  #             ("all" or "headers" or "fields" or :all or :headers or :fields)
+  #             (default: `nil`)
   sig do
     params(
       input: T.any(String, StringIO, IO),
@@ -28,9 +31,10 @@ module OSV
       quote_char: T.nilable(String),
       nil_string: T.nilable(String),
       buffer_size: T.nilable(Integer),
-      result_type: T.nilable(String),
+      result_type: T.nilable(T.any(String, Symbol)),
       flexible: T.nilable(T::Boolean),
       flexible_default: T.nilable(String),
+      trim: T.nilable(T.any(String, Symbol)),
       blk: T.nilable(T.proc.params(row: T.any(T::Hash[String, T.nilable(String)], T::Array[T.nilable(String)])).void)
     ).returns(T.any(Enumerator, T.untyped))
   end
@@ -44,6 +48,7 @@ module OSV
     result_type: nil,
     flexible: nil,
     flexible_default: nil,
+    trim: nil,
     &blk
   )
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: osv
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.11
 platform: ruby
 authors:
 - Nathan Jaremko
@@ -69,7 +69,7 @@ files:
 - lib/osv/version.rb
 homepage: https://github.com/njaremko/osv
 licenses:
-- NONE
+- MIT
 metadata:
   homepage_uri: https://github.com/njaremko/osv
   source_code_uri: https://github.com/njaremko/osv