smarter_csv 1.16.4 → 1.17.0

data/lib/smarter_csv/reader.rb

@@ -7,7 +7,8 @@ module SmarterCSV
     include Enumerable
 
     # Default chunk size used by each_chunk when chunk_size is not explicitly set.
-    # A warning is emitted to STDERR so users know to configure it explicitly.
+    # A warning is recorded (and emitted via Rails.logger or Kernel#warn) so users
+    # know to configure it explicitly.
     DEFAULT_CHUNK_SIZE = 100
 
     include ::SmarterCSV::Reader::Options
@@ -21,7 +22,7 @@ module SmarterCSV
 
     attr_reader :input, :options
     attr_reader :csv_line_count, :chunk_count, :file_line_count
-    attr_reader :enforce_utf8, :has_rails, :has_acceleration
+    attr_reader :enforce_utf8, :has_rails, :has_rails_logger, :has_acceleration
     attr_reader :errors, :warnings, :headers, :raw_header, :result
 
     def self.default_options
@@ -30,7 +31,9 @@ module SmarterCSV
 
     # rubocop:disable Naming/MethodName
     def headerA
-      warn "Deprecarion Warning: 'headerA' will be removed in future versions. Use 'headders'"
+      record_warning(type: :deprecation, code: :header_a_method) do
+        "Deprecarion Warning: 'headerA' will be removed in future versions. Use 'headders'"
+      end
       @headerA
     end
     # rubocop:enable Naming/MethodName
@@ -39,6 +42,7 @@ module SmarterCSV
     def initialize(input, given_options = {})
       @input = input
       @has_rails = !!defined?(Rails)
+      @has_rails_logger = defined?(::Rails) && ::Rails.respond_to?(:logger) && !::Rails.logger.nil?
       @csv_line_count = 0
       @chunk_count = 0
       @errors = {}
@@ -47,9 +51,13 @@ module SmarterCSV
       @headers = nil
       @raw_header = nil # header as it appears in the file
       @result = []
-      @warnings = {}
+      @warnings = []
+      @warnings_by_key = {}
       @enforce_utf8 = false # only set to true if needed (after options parsing)
       @options = process_options(given_options)
+      # Cache quote_char as an ivar — stable for the Reader's lifetime; avoids per-row/per-line hash lookups.
+      @quote_char = @options[:quote_char]
+      @doubled_quote_chars = @quote_char * 2
       # true if it is compiled with accelleration
       @has_acceleration = !!SmarterCSV::Parser.respond_to?(:parse_csv_line_c)
     end
@@ -87,7 +95,11 @@ module SmarterCSV
 
       chunk_size = @options[:chunk_size]
       if chunk_size.nil?
-        warn "SmarterCSV: chunk_size not set, defaulting to #{DEFAULT_CHUNK_SIZE}. Set chunk_size explicitly to suppress this warning." unless @options[:verbose] == :quiet
+        unless @options[:verbose] == :quiet
+          record_warning(type: :config, code: :chunk_size_default) do
+            "chunk_size not set, defaulting to #{DEFAULT_CHUNK_SIZE}. Set chunk_size explicitly to suppress this warning."
+          end
+        end
         chunk_size = DEFAULT_CHUNK_SIZE
       end
       unless chunk_size.is_a?(Integer) && chunk_size >= 1
@@ -106,23 +118,65 @@ module SmarterCSV
       end
     end
 
-    def process(&block) # rubocop:disable Lint/UnusedMethodArgument
+    def process(&block)
       @enforce_utf8 = options[:force_utf8] || options[:file_encoding] !~ /utf-8/i
       @verbose = options[:verbose]
 
       begin
-        fh = input.respond_to?(:readline) ? input : File.open(input, "r:#{options[:file_encoding]}")
+        fh = input.is_a?(String) ? File.open(input, "r:#{options[:file_encoding]}") : input
+
+        # Rewindable inputs (File, Tempfile, StringIO, Zlib::GzipReader, ...) use
+        # native rewind for auto-detection — no wrapper overhead in the hot loop.
+        # Non-rewindable streams (pipes, STDIN, custom non-seekable IOs) go through
+        # PeekableIO which buffers the first chunk so detection can replay without
+        # seeking the underlying source.
+        has_rewind = seekable?(fh)
+
+        unless has_rewind
+          # buffer_size has been validated and clamped by reader_options.rb to be in
+          # [MIN_BUFFER_SIZE, MAX_BUFFER_SIZE], with a cross-validation bump if it was
+          # below auto_row_sep_chars. Use it directly.
+          fh = SmarterCSV::PeekableIO.new(fh, options, buffer_size: options[:buffer_size])
+        end
 
         if (options[:force_utf8] || options[:file_encoding] =~ /utf-8/i) && (fh.respond_to?(:external_encoding) && fh.external_encoding != Encoding.find('UTF-8') || fh.respond_to?(:encoding) && fh.encoding != Encoding.find('UTF-8'))
-          warn 'WARNING: you are trying to process UTF-8 input, but did not open the input with "b:utf-8" option. See README file "NOTES about File Encodings".' unless options[:verbose] == :quiet
+          unless options[:verbose] == :quiet
+            record_warning(type: :encoding, code: :utf8_missing_binary_mode) do
+              'WARNING: you are trying to process UTF-8 input, but did not open the input with "b:utf-8" option. See README file "NOTES about File Encodings".'
+            end
+          end
         end
 
-        # auto-detect the row separator
-        options[:row_sep] = guess_line_ending(fh, options) if options[:row_sep]&.to_sym == :auto
-        # attempt to auto-detect column separator
-        options[:col_sep] = guess_column_separator(fh, options) if options[:col_sep]&.to_sym == :auto
+        # Auto-detection. Two orchestrations, same detection functions:
+        #   has_rewind=true  → native fh.rewind between passes; BOM is stripped by
+        #                      next_line_with_counts on the first real line.
+        #   has_rewind=false → PeekableIO buffers the first chunk; peek strips BOM,
+        #                      rewind_buffer replays, freeze_buffer! locks the buffer.
+        if options[:row_sep]&.to_sym == :auto || options[:col_sep]&.to_sym == :auto
+          if has_rewind
+            options[:row_sep] = guess_line_ending(fh, options) if options[:row_sep]&.to_sym == :auto
+            fh.rewind
+            @file_line_count = 0
+            @csv_line_count = 0
+            # skip_lines feeds clean data lines to guess_column_separator. When col_sep is
+            # explicit, it's wasted work — the bytes are consumed and rewound. Guard it.
+            skip_lines(fh, options) if options[:skip_lines] && options[:col_sep]&.to_sym == :auto
+            options[:col_sep] = guess_column_separator(fh, options) if options[:col_sep]&.to_sym == :auto
+            fh.rewind
+            @file_line_count = 0
+            @csv_line_count = 0
+          else
+            fh.peek
+            options[:row_sep] = guess_line_ending(fh, options) if options[:row_sep]&.to_sym == :auto
+            rewind_buffer(fh)
+            skip_lines(fh, options) if options[:skip_lines] && options[:col_sep]&.to_sym == :auto
+            options[:col_sep] = guess_column_separator(fh, options) if options[:col_sep]&.to_sym == :auto
+            fh.freeze_buffer!
+            rewind_buffer(fh)
+          end
+        end
 
-        skip_lines(fh, options)
+        skip_lines(fh, options) if options[:skip_lines] # skip comments
 
         # NOTE: we are no longer using header_size
         @headers, _header_size = process_headers(fh, options)
@@ -195,8 +249,6 @@ module SmarterCSV
         @delete_nil_keys   = !!options[:key_mapping]
         @delete_empty_keys = !!options[:key_mapping] || @headers.include?(:"")
 
-        # Cache quote_char as an ivar for the stitch-loop memchr guard (avoids hash lookup per continuation line).
-        @quote_char = options[:quote_char]
         # Cache field_size_limit as an ivar (nil when unset → one nil-check per row, no method calls).
         @field_size_limit = options[:field_size_limit]
 
@@ -221,9 +273,9 @@ module SmarterCSV
 
         if on_start
           input_meta = if @input.is_a?(String)
-                          { input: @input, file_size: (File.size(@input) rescue nil) }
-                        else
-                          { input: @input.class.name, file_size: nil }
+                         { input: @input, file_size: (File.size(@input) rescue nil) }
+                       else
+                         { input: @input.class.name, file_size: nil }
                        end
           on_start.call(input_meta.merge(col_sep: options[:col_sep], row_sep: options[:row_sep]))
         end
@@ -254,7 +306,7 @@ module SmarterCSV
                 hash, data_size = parse_line_to_hash_ctx_c(line, @parse_ctx_double)
               end
             else
-              has_quotes = line.include?(options[:quote_char])
+              has_quotes = line.include?(@quote_char)
               hash, data_size = parse_line_to_hash_ruby(line, @headers, @hot_path_options, has_quotes)
               if @quote_escaping_auto && data_size == -1 && line.include?('\\')
                 hash, data_size = parse_line_to_hash_ruby(line, @headers, @quote_escaping_double, has_quotes)
@@ -515,6 +567,50 @@ module SmarterCSV
 
     private
 
+    # Records a warning into the histogram and emits it to the warning sink.
+    # `@warnings` is an Array of unique (type, code) records with a `count` field.
+    # `@warnings_by_key` is a dedup map keyed by `[type, code]` — key shape must
+    # stay fixed to keep both structures bounded by distinct codes, not by calls.
+    # The block form avoids string allocation on dedup-hit: on a repeat call we
+    # increment count and return without yielding the block.
+    # `dedup: false` bypasses the dedup map (still appends a new record per call);
+    # reserve for per-occurrence warnings where each call carries distinct info.
+    # `severity:` controls the Rails.logger level (`:debug`/`:info`/`:warn`/`:error`/`:fatal`);
+    # the non-Rails fallback is always `Kernel#warn` regardless of severity.
+    # `type` is purely a semantic grouping for callers iterating reader.warnings.
+    def record_warning(type:, code:, severity: :warn, dedup: true)
+      key = [type, code]
+      if dedup && (existing = @warnings_by_key[key])
+        existing[:count] += 1
+        return
+      end
+
+      message = yield
+      record = { type: type, code: code, severity: severity, message: message, count: 1 }
+      @warnings << record
+      @warnings_by_key[key] = record if dedup
+
+      if @has_rails_logger
+        ::Rails.logger.public_send(severity, "SmarterCSV: #{message}")
+      else
+        warn "SmarterCSV: #{message}"
+      end
+    end
+
+    # True when the IO is genuinely seekable — i.e. rewind will succeed at the kernel
+    # level, not just the Ruby method table. IO.pipe readers respond to :rewind but
+    # raise at the kernel layer when called; probing #pos surfaces that at decision time.
+    # Rescue SystemCallError (parent of all Errno::*) because the exact subclass varies
+    # by Ruby implementation: MRI raises Errno::ESPIPE, jruby raises Errno::EPIPE.
+    def seekable?(io)
+      return false unless io.respond_to?(:rewind)
+
+      io.pos if io.respond_to?(:pos)
+      true
+    rescue SystemCallError, IOError, NotImplementedError
+      false
+    end
+
     # Determine if a line has unbalanced quotes requiring multiline stitching.
     # For :auto mode, uses dual counting to avoid false multiline detection.
     # For :standard quote_boundary mode, uses a full state machine so that
@@ -663,9 +759,9 @@ module SmarterCSV
           elsif !in_quotes
             # Non-quote character: track whether field has started
             if strip # -- two direct == comparisons are faster than Array#include? in this hot loop
-              field_started = true unless line[i] == ' ' || line[i] == "\t"
-                          else
-                            field_started = true
+              field_started = true unless [' ', "\t"].include?(line[i])
+            else
+              field_started = true
             end
           end
           i += 1
@@ -679,7 +775,7 @@ module SmarterCSV
 
     # SEE: https://github.com/rails/rails/blob/32015b6f369adc839c4f0955f2d9dce50c0b6123/activesupport/lib/active_support/core_ext/object/blank.rb#L121
     # and in the future we might also include UTF-8 space characters: https://www.compart.com/en/unicode/category/Zs
-    BLANK_RE = /\A\s*\z/.freeze
+    BLANK_RE = /\A[[:space:]]*\z/.freeze # Unicode whitespace, same as Rails' String#blank?
 
     # Optimization #5: fast-path empty string and nil checks before regex
     def blank?(value)

data/lib/smarter_csv/reader_options.rb

@@ -5,8 +5,13 @@ module SmarterCSV
     module Options
       DEFAULT_OPTIONS = {
         acceleration: true, # if user wants to use accelleration or not
-        auto_row_sep_chars: 500,
+        auto_row_sep_chars: SmarterCSV::AutoDetection::DEFAULT_AUTO_ROW_SEP_CHARS, # initial scan chunk size (default 4096).
+        #                                                                           Validated against [MIN, MAX]_AUTO_ROW_SEP_CHARS in reader_options.rb.
+        #                                                                           Doubling escalation in guess_line_ending caps at MAX_AUTO_ROW_SEP_CHARS.
         bad_row_limit: nil,
+        buffer_size: SmarterCSV::PeekableIO::DEFAULT_PEEK_SIZE, # peek buffer chunk size for non-seekable inputs.
+        #                                                         Validated: nil/0 → use default; clamped to [MIN_BUFFER_SIZE, MAX_BUFFER_SIZE];
+        #                                                         bumped if < auto_row_sep_chars (see validation in reader_options.rb).
         chunk_size: nil,
         col_sep: :auto, # was: ',',
         collect_raw_lines: true,
@@ -118,12 +123,14 @@ module SmarterCSV
           values = Array(@options[:only_headers])
           bad = values.reject { |v| v.is_a?(Symbol) || v.is_a?(String) }
           raise SmarterCSV::ValidationError, "headers: { only: } elements must be String or Symbol, got: #{bad.map(&:class).uniq.inspect}" if bad.any?
+
           @options[:only_headers] = values.map(&:to_sym)
         end
         if @options[:except_headers]
           values = Array(@options[:except_headers])
           bad = values.reject { |v| v.is_a?(Symbol) || v.is_a?(String) }
           raise SmarterCSV::ValidationError, "headers: { except: } elements must be String or Symbol, got: #{bad.map(&:class).uniq.inspect}" if bad.any?
+
           @options[:except_headers] = values.map(&:to_sym)
         end
 
@@ -187,6 +194,59 @@ module SmarterCSV
         unless %i[legacy standard].include?(options[:quote_boundary])
           errors << "invalid quote_boundary: must be :legacy or :standard"
         end
+        arc = options[:auto_row_sep_chars]
+        min_arc = SmarterCSV::AutoDetection::MIN_AUTO_ROW_SEP_CHARS
+        max_arc = SmarterCSV::AutoDetection::MAX_AUTO_ROW_SEP_CHARS
+        default_arc = DEFAULT_OPTIONS[:auto_row_sep_chars]
+
+        if arc.is_a?(Integer)
+          if arc < min_arc
+            warn "WARNING: auto_row_sep_chars value #{arc.inspect} is below minimum (#{min_arc}); using default (#{default_arc})" unless options[:verbose] == :quiet
+            options[:auto_row_sep_chars] = default_arc
+          elsif arc > max_arc
+            warn "WARNING: auto_row_sep_chars value #{arc.inspect} exceeds maximum (#{max_arc}); clamping to #{max_arc}" unless options[:verbose] == :quiet
+            options[:auto_row_sep_chars] = max_arc
+          end
+        else
+          warn "WARNING: invalid auto_row_sep_chars value #{arc.inspect} — must be an Integer; using default (#{default_arc})" unless options[:verbose] == :quiet
+          options[:auto_row_sep_chars] = default_arc
+        end
+        # buffer_size validation:
+        #   nil / 0           → unset, use default
+        #   non-Integer       → warn, use default
+        #   < MIN_BUFFER_SIZE → warn, clamp to MIN_BUFFER_SIZE
+        #   > MAX_BUFFER_SIZE → warn, clamp to MAX_BUFFER_SIZE
+        # Cross-validation (after the above):
+        #   < auto_row_sep_chars → warn, bump to max(2 * buffer_size, MIN_AUTO_ROW_SEP_CHARS)
+        bs = options[:buffer_size]
+        default_bs = DEFAULT_OPTIONS[:buffer_size]
+        min_bs = SmarterCSV::PeekableIO::MIN_BUFFER_SIZE
+        max_bs = SmarterCSV::PeekableIO::MAX_BUFFER_SIZE
+        quiet = options[:verbose] == :quiet
+
+        if bs.nil? || bs == 0
+          options[:buffer_size] = default_bs
+        elsif !bs.is_a?(Integer)
+          warn "WARNING: invalid buffer_size value #{bs.inspect} — must be an Integer; using default (#{default_bs})" unless quiet
+          options[:buffer_size] = default_bs
+        elsif bs < min_bs
+          warn "WARNING: buffer_size #{bs} is below minimum (#{min_bs}); clamping to #{min_bs}" unless quiet
+          options[:buffer_size] = min_bs
+        elsif bs > max_bs
+          warn "WARNING: buffer_size #{bs} exceeds maximum (#{max_bs}); clamping to #{max_bs}" unless quiet
+          options[:buffer_size] = max_bs
+        end
+
+        # Cross-validation: ensure buffer_size is reasonably sized relative to auto_row_sep_chars.
+        # Gentle bump (does not strictly enforce buffer_size >= auto_row_sep_chars — PeekableIO
+        # handles smaller buffers via multiple reads — but ensures at least one default scan window fits).
+        arc = options[:auto_row_sep_chars]
+        if arc.is_a?(Integer) && options[:buffer_size] < arc
+          bumped = [2 * options[:buffer_size], SmarterCSV::AutoDetection::MIN_AUTO_ROW_SEP_CHARS].max
+          bumped = [bumped, max_bs].min # Clamp bumped value to not exceed MAX_BUFFER_SIZE
+          warn "WARNING: buffer_size (#{options[:buffer_size]}) < auto_row_sep_chars (#{arc}); bumping buffer_size to #{bumped}" unless quiet
+          options[:buffer_size] = bumped
+        end
         fsl = options[:field_size_limit]
         unless fsl.nil? || (fsl.is_a?(Integer) && fsl > 0)
           errors << "invalid field_size_limit: must be nil or a positive Integer (got #{fsl.inspect})"

data/lib/smarter_csv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SmarterCSV
-  VERSION = "1.16.4"
+  VERSION = "1.17.0"
 end

data/lib/smarter_csv.rb

@@ -5,9 +5,10 @@ require "smarter_csv/version"
 require "smarter_csv/errors"
 
 require "smarter_csv/file_io"
+require "smarter_csv/auto_detection" # MAX_AUTO_ROW_SEP_CHARS is the canonical 64KB cap; loaded first so peekable_io.rb and reader_options.rb can reference it
+require "smarter_csv/peekable_io"
 require "smarter_csv/reader_options"
 require "smarter_csv/writer_options"
-require "smarter_csv/auto_detection"
 require 'smarter_csv/header_transformations'
 require 'smarter_csv/header_validations'
 require "smarter_csv/headers"
@@ -66,24 +67,30 @@ module SmarterCSV
   #   reader = SmarterCSV::Reader.new(input, options)
   #   reader.process # with or without block
   #
-  # After calling any of the class-level methods, errors from the last run are available via:
+  # After calling any of the class-level methods, errors and warnings from the last run
+  # are available via:
   #
-  #   SmarterCSV.errors  # => { bad_row_count: 2, bad_rows: [...] }
+  #   SmarterCSV.errors    # => { bad_row_count: 2, bad_rows: [...] }
+  #   SmarterCSV.warnings  # => [ { type:, code:, message:, count: }, ... ]
   #
-  # This exposes the same reader.errors hash without requiring access to the Reader instance.
-  # Errors are cleared at the start of each call and stored per-thread, so this is safe in
-  # multi-threaded environments (Puma, Sidekiq). Note: only the most recent call's errors
-  # are retained per thread.
+  # These expose the same reader.errors / reader.warnings without requiring access to the
+  # Reader instance. Both are cleared at the start of each call and stored per-thread, so
+  # this is safe in multi-threaded environments (Puma, Sidekiq). Only the most recent
+  # call's errors and warnings are retained per thread.
   #
   def self.process(input, given_options = {}, &block)
     Thread.current[:current_thread_recent_errors] = {}
+    Thread.current[:current_thread_recent_warnings] = []
     reader = Reader.new(input, given_options)
     reader.process(&block)
   ensure
     # Preserve partial error state when processing raises mid-stream
     # (e.g. TooManyBadRows, or a user block raising). `reader` is nil if
     # Reader.new itself raised before the local was assigned.
-    Thread.current[:current_thread_recent_errors] = reader.errors if reader
+    if reader
+      Thread.current[:current_thread_recent_errors] = reader.errors
+      Thread.current[:current_thread_recent_warnings] = reader.warnings
+    end
   end
 
   # Convenience method for parsing a CSV string directly.
@@ -111,10 +118,14 @@ module SmarterCSV
   #   SmarterCSV.each("data.csv").lazy.map { |h| h[:name] }.first(10)
   def self.each(input, options = {}, &block)
     Thread.current[:current_thread_recent_errors] = {}
+    Thread.current[:current_thread_recent_warnings] = []
     reader = Reader.new(input, options)
     reader.each(&block)
   ensure
-    Thread.current[:current_thread_recent_errors] = reader.errors if reader
+    if reader
+      Thread.current[:current_thread_recent_errors] = reader.errors
+      Thread.current[:current_thread_recent_warnings] = reader.warnings
+    end
   end
 
   # Yields each chunk as Array<Hash> plus its 0-based chunk index.
@@ -128,10 +139,14 @@ module SmarterCSV
   #   SmarterCSV.each_chunk("data.csv", chunk_size: 100).with_index { |chunk, i| ... }
   def self.each_chunk(input, options = {}, &block)
     Thread.current[:current_thread_recent_errors] = {}
+    Thread.current[:current_thread_recent_warnings] = []
     reader = Reader.new(input, options)
     reader.each_chunk(&block)
   ensure
-    Thread.current[:current_thread_recent_errors] = reader.errors if reader
+    if reader
+      Thread.current[:current_thread_recent_errors] = reader.errors
+      Thread.current[:current_thread_recent_warnings] = reader.warnings
+    end
   end
 
   # Returns the errors from the most recent call to .process, .parse, .each, or .each_chunk
@@ -149,6 +164,21 @@ module SmarterCSV
     Thread.current[:current_thread_recent_errors] || {}
   end
 
+  # Returns the warnings from the most recent call to .process, .parse, .each, or .each_chunk
+  # on the current thread. Cleared at the start of each new call.
+  #
+  # Each warning is a Hash: { type:, code:, message:, count: }.
+  # Repeated warnings of the same (type, code) are deduped — `count` tracks
+  # the number of occurrences.
+  #
+  # Example:
+  #   SmarterCSV.process('data.csv')
+  #   SmarterCSV.warnings.each { |w| logger.warn("[#{w[:type]}/#{w[:code]}] #{w[:message]} (×#{w[:count]})") }
+  #
+  def self.warnings
+    Thread.current[:current_thread_recent_warnings] || []
+  end
+
   # Convenience method for generating CSV files, IO objects, or in-memory strings.
   #
   # When called WITHOUT a first argument, generates CSV in memory and returns it as a String.
@@ -184,7 +214,6 @@ module SmarterCSV
   #     end
   #   end
   #
-  # rubocop:disable Lint/UnusedMethodArgument
   def self.generate(file_path_or_io = nil, options = {}, &block)
     raise ArgumentError, "SmarterCSV.generate requires a block" unless block_given?
 
@@ -213,5 +242,4 @@ module SmarterCSV
       end
     end
   end
-  # rubocop:enable Lint/UnusedMethodArgument
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: smarter_csv
 version: !ruby/object:Gem::Version
-  version: 1.16.4
+  version: 1.17.0
 platform: ruby
 authors:
 - Tilo Sloboda
 bindir: bin
 cert_chain: []
-date: 2026-04-21 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies: []
 description: |
   SmarterCSV is a high-performance CSV reader and writer for Ruby focused on
@@ -39,7 +39,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- TO_DO_v2.md
+- TO_DO.md
 - docs/_introduction.md
 - docs/bad_row_quarantine.md
 - docs/basic_read_api.md
@@ -59,10 +59,13 @@ files:
 - docs/releases/1.16.0/benchmarks.md
 - docs/releases/1.16.0/changes.md
 - docs/releases/1.16.0/performance_notes.md
+- docs/releases/1.17.0/benchmarks.md
+- docs/releases/1.17.0/changes.md
+- docs/releases/1.17.0/performance_notes.md
 - docs/row_col_sep.md
 - docs/ruby_csv_pitfalls.md
 - docs/value_converters.md
-- ext/smarter_csv/Makefile
+- docs/warnings.md
 - ext/smarter_csv/extconf.rb
 - ext/smarter_csv/smarter_csv.c
 - images/SmarterCSV_1.16.0_vs_RubyCSV_3.3.5_speedup.png
@@ -71,6 +74,9 @@ files:
 - images/SmarterCSV_1.16.0_vs_previous_C-speedup.svg
 - images/SmarterCSV_1.16.0_vs_previous_Rb-speedup.png
 - images/SmarterCSV_1.16.0_vs_previous_Rb-speedup.svg
+- images/SmarterCSV_1.17.0_vs_RubyCSV_3.3.5_speedup.svg
+- images/SmarterCSV_1.17.0_vs_previous_C-speedup.svg
+- images/SmarterCSV_1.17.0_vs_previous_Rb-speedup.svg
 - lib/smarter_csv.rb
 - lib/smarter_csv/auto_detection.rb
 - lib/smarter_csv/errors.rb
@@ -80,6 +86,7 @@ files:
 - lib/smarter_csv/header_validations.rb
 - lib/smarter_csv/headers.rb
 - lib/smarter_csv/parser.rb
+- lib/smarter_csv/peekable_io.rb
 - lib/smarter_csv/reader.rb
 - lib/smarter_csv/reader_options.rb
 - lib/smarter_csv/version.rb
@@ -110,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.11
 specification_version: 4
 summary: Fastest end-to-end CSV ingestion for Ruby with smart defaults and Rails-ready
   hash output

data/TO_DO_v2.md

@@ -1,14 +0,0 @@
-# SmarterCSV v2.0 TO DO List
-
-* add enumerable to speed up parallel processing [issue #66](https://github.com/tilo/smarter_csv/issues/66), [issue #32](https://github.com/tilo/smarter_csv/issues/32)
-* use Procs for validations and transformatoins [issue #118](https://github.com/tilo/smarter_csv/issues/118)
-* make @errors and @warnings work [issue #118](https://github.com/tilo/smarter_csv/issues/118)
-* skip file opening, allow reading from CSV string, e.g. reading from S3 file [issue #120](https://github.com/tilo/smarter_csv/issues/120).
-  Or stream large file from S3 (linked in the issue)
-* Collect all Errors, before surfacing them. Avoid throwing an exception on the first error [issue #133](https://github.com/tilo/smarter_csv/issues/133)
-* Don't call rewind on filehandle
-* [2.0 BUG] :convert_values_to_numeric_unless_leading_zeros drops leading zeros [issue #151](https://github.com/tilo/smarter_csv/issues/151)
-* [2.0 BUG]  convert_to_float saves Proc as @@convert_to_integer [issue #157](https://github.com/tilo/smarter_csv/issues/157)
-* Provide an example for custom Procs for hash_transformations in the docs [issue #174](https://github.com/tilo/smarter_csv/issues/174)
-* Replace remove_empty_values: false [issue #213](https://github.com/tilo/smarter_csv/issues/213)
-