osv 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935cf4c277ef52eb1b1c4a4c27d2fe54461489b38b4203a1e574ac1a9e3298df
-  data.tar.gz: aa13944483b0f9fa8963a830d5f2a2932110e86bb32c722565c2b4d5f9dbef3c
+  metadata.gz: aed16dbfb14e6caebceb388104731091a5354394cd174804982dbce8f4b95963
+  data.tar.gz: 232497c8ec55ab15559f126c4bc90c6bcd0dd4296efadcbf23d07d6a24c7969d
 SHA512:
-  metadata.gz: ea38b823a0423ef8883c04f6b677b16ba5d55f9a23faf434fc758788d238972b17b6e2435f0ec92661a32ee31fafb39170c81933d67a201af8cd528678e6261a
-  data.tar.gz: 77a62c7d62f36bd4143166d65c64eecccece56f1ebb969295cf7af6ff8639af9df71b3923d3ba13590824db68604e90cdc61e22490e81a3d0e24bf1af5f0be47
+  metadata.gz: 36e1bab13ede785e2f41f0a56b37a2ff7448deff182b614c71e15ccd16799abe94f1f7db63034cd1c04195666c85a12fa0284dde75753b16e05e8767e9c87b18
+  data.tar.gz: '0990fee8e41dd9eb046d6b3733770adb4ef9825165bb0a012b32dac03ddd9d8f2107860d75ef05437aa8d820d42d16c8148642fd3faab326dcab8007731bcf61'

data/README.md

@@ -70,9 +70,10 @@ Both methods support the following options:
   - 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")
+- `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
 

data/Rakefile

@@ -20,3 +20,9 @@ Rake::TestTask.new do |t|
   t.libs << "lib"
   t.libs << "test"
 end
+
+task :release do
+  sh "bundle exec rake test"
+  sh "gem build osv.gemspec"
+  sh "gem push 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.10"
 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.10
 platform: ruby
 authors:
 - Nathan Jaremko