roo-smarter_csv 1.0.0

data/lib/roo/smarter_csv/smarter_csv_adapter.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "csv"
+require "date"
+require_relative "version"
+
+module Roo
+  # Roo CSV adapter backed by SmarterCSV while preserving Roo's sheet-style API.
+  class SmarterCSV
+    attr_reader :filename, :reader
+
+    COMPATIBLE_CSV_KEYS = %i[col_sep row_sep quote_char encoding].freeze
+    DEFAULT_SMARTER_CSV_OPTIONS = {
+      remove_empty_hashes: false
+      # collect_raw_lines: false
+    }.freeze
+
+    def sheets
+      ["default"]
+    end
+
+    def cell(row, col, sheet = nil)
+      sheet ||= default_sheet
+      read_cells(sheet)
+      row, col = normalize(row, col)
+
+      return @header_row[col - 1] if header_row?(row)
+
+      row_hash = sparse_row_for(row)
+      return nil unless row_hash
+
+      key = header_key_for(col)
+      return nil unless key
+      return row_hash[key] if row_hash.key?(key)
+
+      missing_cell_value
+    end
+
+    def celltype(row, col, sheet = nil)
+      sheet ||= default_sheet
+      read_cells(sheet)
+      row, col = normalize(row, col)
+
+      if header_row?(row)
+        value = @header_row[col - 1]
+        return value.nil? ? nil : infer_type(value)
+      end
+
+      row_hash = sparse_row_for(row)
+      return nil unless row_hash
+
+      key = header_key_for(col)
+      return nil unless key
+      return infer_type(row_hash[key]) if row_hash.key?(key)
+
+      :empty
+    end
+
+    def row(row_number, sheet = default_sheet)
+      read_cells(sheet)
+
+      if header_row?(row_number)
+        return @header_row.length < last_column(sheet) ? @header_row + Array.new(last_column(sheet) - @header_row.length) : @header_row.dup
+      end
+
+      row_hash = sparse_row_for(row_number)
+      return [] unless row_hash
+
+      @header_keys.map { |key| row_hash.fetch(key, missing_cell_value) }
+    end
+
+    def csv_options
+      @options[:csv_options] || {}
+    end
+
+    def smarter_csv_options
+      @smarter_csv_options ||= begin
+        compat = csv_options.each_with_object({}) do |(key, value), result|
+          symbol_key = key.to_sym
+          result[symbol_key] = value if COMPATIBLE_CSV_KEYS.include?(symbol_key)
+        end
+
+        smarter = normalize_option_hash(@options[:smarter_csv])
+
+        (compat.keys & smarter.keys).each do |key|
+          warn "roo-smarter_csv: conflicting option #{key} found in csv_options and smarter_csv; using smarter_csv[:#{key}]"
+        end
+
+        DEFAULT_SMARTER_CSV_OPTIONS.merge(compat).merge(smarter)
+      end
+    end
+
+    def set_value(row, col, value, _sheet)
+      read_cells(default_sheet) unless @cells_read[default_sheet]
+      row, col = normalize(row, col)
+
+      if header_row?(row)
+        ensure_header_width(col)
+        @header_row[col - 1] = value
+      else
+        ensure_data_row(row)
+        ensure_header_width(col)
+        @rows[data_row_index(row)][header_key_for(col)] = value
+      end
+
+      recalculate_bounds
+      value
+    end
+
+    def set_type(_row, _col, _type, _sheet)
+      nil
+    end
+
+    alias filename_or_stream filename
+
+    private
+
+    def read_cells(sheet = default_sheet)
+      sheet ||= default_sheet
+      return if @cells_read[sheet]
+
+      @reader = nil
+      @header_row = []
+      @header_keys = []
+      @rows = []
+
+      with_source do |source|
+        @reader = ::SmarterCSV::Reader.new(source, smarter_csv_options)
+        @reader.process do |row_data|
+          store_rows(row_data)
+        end
+
+        @header_row = parsed_header_row(@reader)
+        @header_keys = Array(@reader.headers).dup
+
+        set_row_count(sheet, total_rows)
+        set_column_count(sheet, [@header_row.length, @header_keys.length].max)
+      end
+
+      @cells_read[sheet] = true
+    end
+
+    def with_source
+      if uri?(filename)
+        ::Dir.mktmpdir(Roo::TEMP_PREFIX, ENV["ROO_TMP"]) do |tmpdir|
+          yield download_uri(filename, tmpdir)
+        end
+      else
+        yield filename_or_stream
+      end
+    end
+
+    def parsed_header_row(reader)
+      raw_header = reader.raw_header
+      return [] unless raw_header
+
+      header = ::CSV.parse_line(
+        raw_header,
+        col_sep: reader.options[:col_sep] || ",",
+        quote_char: reader.options.fetch(:quote_char, '"')
+      )
+
+      Array(header)
+    end
+
+    def store_rows(row_data)
+      case row_data
+      when Array
+        row_data.each { |entry| @rows << sparse_row_hash(entry) }
+      else
+        @rows << sparse_row_hash(row_data)
+      end
+    end
+
+    def sparse_row_hash(row_data)
+      case row_data
+      when Hash
+        row_data.dup
+      when Array
+        current_headers = Array(@reader&.headers)
+        row_data.each_with_index.each_with_object({}) do |(value, index), result|
+          key = current_headers[index] || generated_header_key(index + 1)
+          result[key] = value
+        end
+      when NilClass
+        {}
+      else
+        { generated_header_key(1) => row_data }
+      end
+    end
+
+    def infer_type(value)
+      case value
+      when NilClass then :empty
+      when TrueClass, FalseClass then :boolean
+      when Integer then :numeric
+      when Float then :float
+      when Date then :date
+      when DateTime, Time then :datetime
+      when String then value.empty? ? :empty : :string
+      else :string
+      end
+    end
+
+    def normalize_option_hash(hash)
+      return {} unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
+    end
+
+    def set_row_count(sheet, last_row)
+      @first_row[sheet] = 1
+      @last_row[sheet] = last_row
+      @last_row[sheet] = @first_row[sheet] if @last_row[sheet].zero?
+      nil
+    end
+
+    def set_column_count(sheet, last_col)
+      @first_column[sheet] = 1
+      @last_column[sheet] = last_col
+      @last_column[sheet] = @first_column[sheet] if @last_column[sheet].zero?
+      nil
+    end
+
+    def clean_sheet(sheet)
+      read_cells(sheet)
+      @header_row = @header_row.map { |value| value.is_a?(String) ? sanitize_value(value) : value }
+      @rows.each do |row_hash|
+        row_hash.each do |key, value|
+          row_hash[key] = sanitize_value(value) if value.is_a?(String)
+        end
+      end
+      @cleaned ||= {}
+      @cleaned[sheet] = true
+    end
+
+    def sanitize_value(value)
+      value.gsub(/[[:cntrl:]]|^\p{Space}+|\p{Space}+$/, "")
+    end
+
+    def reinitialize
+      initialize(@filename, @options)
+    end
+
+    def header_row?(row)
+      @header_row.any? && row == 1
+    end
+
+    def total_rows
+      @rows.length + (@header_row.any? ? 1 : 0)
+    end
+
+    def sparse_row_for(row)
+      index = data_row_index(row)
+      return nil if index.negative? || index >= @rows.length
+
+      @rows[index]
+    end
+
+    def data_row_index(row)
+      row - (@header_row.any? ? 2 : 1)
+    end
+
+    def header_key_for(col)
+      @header_keys[col - 1]
+    end
+
+    def missing_cell_value
+      nil
+    end
+
+    def ensure_data_row(row)
+      @rows << {} while data_row_index(row) >= @rows.length
+    end
+
+    def ensure_header_width(col)
+      @header_keys << generated_header_key(@header_keys.length + 1) while @header_keys.length < col
+      @header_row << nil while @header_row.length < col
+    end
+
+    def generated_header_key(col)
+      "column_#{col}".to_sym
+    end
+
+    def recalculate_bounds
+      sheet = default_sheet
+      @first_row[sheet] = 1
+      @last_row[sheet] = total_rows.zero? ? 1 : total_rows
+      @first_column[sheet] = 1
+      @last_column[sheet] = [@header_row.length, @header_keys.length].max
+      @last_column[sheet] = 1 if @last_column[sheet].zero?
+    end
+  end
+end

data/lib/roo/smarter_csv/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "roo"
+
+module Roo
+  class SmarterCSV < Roo::Base
+    VERSION = "1.0.0"
+  end
+end

data/lib/roo-smarter_csv.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "roo_smarter_csv"

data/lib/roo_smarter_csv.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "roo"
+require "smarter_csv"
+require_relative "roo/smarter_csv/smarter_csv_adapter"
+
+# Roo namespace extensions for the SmarterCSV-backed CSV adapter.
+module Roo
+  # Registers the SmarterCSV-backed CSV adapter as Roo's CSV handler.
+  CLASS_FOR_EXTENSION.merge!(
+    csv: Roo::SmarterCSV
+  )
+end

data/roo-smarter_csv.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative "lib/roo/smarter_csv/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "roo-smarter_csv"
+  spec.date          = Time.now.utc.strftime('%Y-%m-%d')
+  spec.version       = Roo::SmarterCSV::VERSION
+  spec.authors       = ["Tilo Sloboda"]
+  spec.email         = ["tilo.slobodal@gmail.com"]
+  spec.summary       = "High-performance CSV support for Roo using SmarterCSV"
+  spec.description   = "Extends Roo with SmarterCSV integration for robust and faster CSV parsing"
+
+  spec.license       = "MIT"
+
+  spec.homepage      = "https://github.com/tilo/roo-smarter_csv"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}/tree/main/"
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.6.0" # same as SmarterCSV
+
+  # Dependencies
+  spec.add_dependency "roo", ">= 2.0.0", "< 4"   # roo 4.x is not out yet
+  spec.add_dependency "smarter_csv", ">= 1.15.0" # it is recommended to use the latest version
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", ">= 1.7"
+  spec.add_development_dependency "matrix"
+  spec.add_development_dependency "minitest", ">= 5.19.0"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rspec", ">= 3.0"
+end

data/sig/roo/smarter_csv.rbs

@@ -0,0 +1,6 @@
+module Roo
+  module SmarterCsv
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/spec/fixtures/blank_fields.csv

@@ -0,0 +1,4 @@
+id,first,last,address2,city,state,zip
+1,John,Doe,,Portland,OR,97201
+2,Jane,Smith,Apt 3,Seattle,WA,
+3,Bob,Jones,,,CA,90210

data/spec/fixtures/clean_values.csv

@@ -0,0 +1,2 @@
+ Name , City 
+ John	 , Portland 

data/spec/fixtures/defaults.csv

@@ -0,0 +1,3 @@
+Name,Note,Amount,Ratio
+John,"hello, world",30,1.5
+Jane,"plain text",42,2.75

data/spec/fixtures/duplicate_blank_headers.csv

@@ -0,0 +1,2 @@
+name,,name
+Alice,,Bob

data/spec/fixtures/empty_rows.csv

@@ -0,0 +1,4 @@
+id,name,age
+1,Alice,30
+,,
+2,Bob,40

data/spec/fixtures/quoted_headers.csv

@@ -0,0 +1,2 @@
+"Last, First",Age,"City, State"
+"Doe, Jane",30,"Portland, OR"

data/spec/fixtures/sample.csv

@@ -0,0 +1,4 @@
+Name,Age,Email,Salary
+John,30,john@example.com,50000
+Jane,28,jane@example.com,60000
+Bob,35,bob@example.com,55000

data/spec/fixtures/sample.tsv

@@ -0,0 +1,3 @@
+Name	Age	Email	Salary
+John	30	john@example.com	50000
+Jane	28	jane@example.com	60000

data/spec/fixtures/sample_bom.csv

@@ -0,0 +1,3 @@
+Name,Age,Email,Salary
+John,30,john@example.com,50000
+Jane,28,jane@example.com,60000

data/spec/smarter_csv_spec.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Roo::SmarterCSV do
+  let(:csv_path) { File.expand_path("fixtures/sample.csv", __dir__) }
+  let(:tsv_path) { File.expand_path("fixtures/sample.tsv", __dir__) }
+  let(:bom_path) { File.expand_path("fixtures/sample_bom.csv", __dir__) }
+  let(:empty_path) { File.expand_path("fixtures/empty.csv", __dir__) }
+  let(:defaults_path) { File.expand_path("fixtures/defaults.csv", __dir__) }
+  let(:blank_fields_path) { File.expand_path("fixtures/blank_fields.csv", __dir__) }
+  let(:empty_rows_path) { File.expand_path("fixtures/empty_rows.csv", __dir__) }
+  let(:duplicate_blank_headers_path) { File.expand_path("fixtures/duplicate_blank_headers.csv", __dir__) }
+  let(:quoted_headers_path) { File.expand_path("fixtures/quoted_headers.csv", __dir__) }
+  let(:clean_values_path) { File.expand_path("fixtures/clean_values.csv", __dir__) }
+  let(:csv) { Roo::SmarterCSV.new(csv_path) }
+
+  describe "Roo interface" do
+    it "returns sheets array" do
+      expect(csv.sheets).to eq(["default"])
+    end
+
+    it "provides default_sheet" do
+      expect(csv.default_sheet).to eq("default")
+    end
+
+    it "accesses cells by row and column" do
+      expect(csv.cell(2, 1)).to eq("John")
+      expect(csv.cell(2, 2)).to eq(30)
+      expect(csv.cell(2, 3)).to eq("john@example.com")
+    end
+
+    it "detects cell types" do
+      expect(csv.celltype(1, 1)).to eq(:string)  # "Name"
+      expect(csv.celltype(2, 2)).to eq(:numeric) # 30
+    end
+
+    it "provides row access" do
+      row = csv.row(2)
+      expect(row).to eq(["John", 30, "john@example.com", 50_000])
+    end
+
+    it "provides boundary methods" do
+      expect(csv.first_row).to eq(1)
+      expect(csv.last_row).to eq(4) # 3 data rows + 1 header
+      expect(csv.first_column).to eq(1)
+      expect(csv.last_column).to eq(4)
+    end
+
+    it "iterates rows" do
+      rows = []
+      csv.each { |row| rows << row }
+      expect(rows.length).to eq(4)
+    end
+
+    it "parses with headers" do
+      data = csv.parse(headers: true)
+      expect(data.first).to be_a(Hash)
+      expect(data.first.keys).to eq(%w[Name Age Email Salary])
+      expect(data.first["Name"]).to eq("Name")
+      expect(data[1]["Name"]).to eq("John")
+    end
+  end
+
+  describe "Type detection" do
+    it "detects numeric types" do
+      expect(csv.celltype(2, 2)).to eq(:numeric) # 30
+      expect(csv.cell(2, 2)).to eq(30)
+    end
+
+    it "detects string types" do
+      expect(csv.celltype(2, 1)).to eq(:string)
+      expect(csv.cell(2, 1)).to eq("John")
+    end
+  end
+
+  describe "Integration with Roo::Spreadsheet" do
+    it "registers itself as Roo CSV handler" do
+      expect(Roo::CLASS_FOR_EXTENSION[:csv]).to eq(Roo::SmarterCSV)
+    end
+
+    it "can be opened via Roo::Spreadsheet.open" do
+      spreadsheet = Roo::Spreadsheet.open(csv_path)
+      expect(spreadsheet).to be_a(Roo::SmarterCSV)
+      expect(spreadsheet.cell(2, 1)).to eq("John")
+    end
+
+    it "works with StringIO input" do
+      spreadsheet = Roo::Spreadsheet.open(StringIO.new(File.read(csv_path)), extension: :csv)
+      expect(spreadsheet).to be_a(Roo::SmarterCSV)
+      expect(spreadsheet.cell(2, 2)).to eq(30)
+    end
+
+    it "reads files with a UTF-8 BOM" do
+      spreadsheet = Roo::Spreadsheet.open(bom_path)
+      expect(spreadsheet.cell(2, 1)).to eq("John")
+      expect(spreadsheet.cell(2, 4)).to eq(50_000)
+    end
+
+    it "treats an empty csv file as an error" do
+      expect { Roo::Spreadsheet.open(empty_path).cell(1, 1) }.to raise_error(SmarterCSV::EmptyFileError)
+    end
+
+    it "accepts csv_options from Roo and bridges them into SmarterCSV" do
+      spreadsheet = Roo::Spreadsheet.open(tsv_path, extension: :csv, csv_options: { col_sep: "\t" })
+      expect(spreadsheet.cell(2, 1)).to eq("John")
+      expect(spreadsheet.cell(2, 4)).to eq(50_000)
+    end
+
+    it "uses SmarterCSV defaults when no options are supplied" do
+      spreadsheet = Roo::Spreadsheet.open(defaults_path)
+      expect(spreadsheet.cell(2, 2)).to eq("hello, world")
+      expect(spreadsheet.cell(2, 3)).to eq(30)
+      expect(spreadsheet.cell(2, 4)).to eq(1.5)
+      expect(spreadsheet.celltype(2, 3)).to eq(:numeric)
+      expect(spreadsheet.celltype(2, 4)).to eq(:float)
+    end
+
+    it "preserves blank fields in the middle of rows" do
+      spreadsheet = Roo::Spreadsheet.open(blank_fields_path)
+      expect(spreadsheet.row(2)).to eq([1, "John", "Doe", nil, "Portland", "OR", 97_201])
+      expect(spreadsheet.row(3)).to eq([2, "Jane", "Smith", "Apt 3", "Seattle", "WA", nil])
+      expect(spreadsheet.row(4)).to eq([3, "Bob", "Jones", nil, nil, "CA", 90_210])
+      expect(spreadsheet.cell(2, 4)).to be_nil
+      expect(spreadsheet.celltype(2, 4)).to eq(:empty)
+    end
+
+    it "preserves fully empty rows end-to-end" do
+      spreadsheet = Roo::Spreadsheet.open(empty_rows_path)
+      expect(spreadsheet.last_row).to eq(4)
+      expect(spreadsheet.row(3)).to eq([nil, nil, nil])
+      expect(spreadsheet.celltype(3, 1)).to eq(:empty)
+      expect(spreadsheet.row(4)).to eq([2, "Bob", 40])
+    end
+
+    it "supports SmarterCSV chunk_size without changing visible spreadsheet rows" do
+      spreadsheet = Roo::SmarterCSV.new(csv_path, smarter_csv: { chunk_size: 2 })
+      expect(spreadsheet.last_row).to eq(4)
+      expect(spreadsheet.row(2)).to eq(["John", 30, "john@example.com", 50_000])
+      expect(spreadsheet.row(4)).to eq(["Bob", 35, "bob@example.com", 55_000])
+    end
+
+    it "supports user_provided_headers when headers_in_file is false" do
+      spreadsheet = Roo::SmarterCSV.new(
+        StringIO.new("1,John\n2,Jane\n"),
+        smarter_csv: { headers_in_file: false, user_provided_headers: %i[id name] }
+      )
+
+      expect(spreadsheet.first_row).to eq(1)
+      expect(spreadsheet.last_row).to eq(2)
+      expect(spreadsheet.row(1)).to eq([1, "John"])
+      expect(spreadsheet.row(2)).to eq([2, "Jane"])
+    end
+
+    it "handles duplicate and blank headers without shifting data columns" do
+      spreadsheet = Roo::Spreadsheet.open(duplicate_blank_headers_path)
+      expect(spreadsheet.row(1)).to eq(["name", nil, "name"])
+      expect(spreadsheet.row(2)).to eq(["Alice", nil, "Bob"])
+      expect(spreadsheet.last_column).to eq(3)
+    end
+
+    it "parses quoted headers containing separators correctly" do
+      spreadsheet = Roo::Spreadsheet.open(quoted_headers_path)
+      expect(spreadsheet.row(1)).to eq(["Last, First", "Age", "City, State"])
+      expect(spreadsheet.row(2)).to eq(["Doe, Jane", 30, "Portland, OR"])
+    end
+
+    it "supports clean: true through Roo's public parse API" do
+      spreadsheet = Roo::Spreadsheet.open(clean_values_path)
+      data = spreadsheet.parse(headers: true, clean: true)
+
+      expect(data.first.keys).to eq(%w[Name City])
+      expect(data[1]).to eq({ "Name" => "John", "City" => "Portland" })
+    end
+
+    it "prefers smarter_csv options over csv_options and emits a warning" do
+      spreadsheet = Roo::SmarterCSV.new(csv_path, csv_options: { col_sep: ";" }, smarter_csv: { col_sep: "," })
+      expect { spreadsheet.cell(2, 1) }.to output(/conflicting option col_sep/).to_stderr
+      expect(spreadsheet.cell(2, 1)).to eq("John")
+    end
+  end
+
+  describe "private helper coverage" do
+    let(:adapter) { described_class.new(csv_path) }
+
+    it "covers private helper methods and mutation helpers" do
+      expect(adapter.send(:normalize_option_hash, nil)).to eq({})
+      expect(adapter.send(:normalize_option_hash, "nope")).to eq({})
+      expect(adapter.send(:normalize_option_hash, "a" => 1)).to eq({ a: 1 })
+
+      expect(adapter.send(:infer_type, nil)).to eq(:empty)
+      expect(adapter.send(:infer_type, true)).to eq(:boolean)
+      expect(adapter.send(:infer_type, false)).to eq(:boolean)
+      expect(adapter.send(:infer_type, Date.new(2024, 1, 1))).to eq(:date)
+      expect(adapter.send(:infer_type, Time.new(2024, 1, 1, 12, 0, 0))).to eq(:datetime)
+      expect(adapter.send(:infer_type, Object.new)).to eq(:string)
+
+      expect(adapter.send(:sanitize_value, " \tHello\n")).to eq("Hello")
+      expect(adapter.send(:generated_header_key, 3)).to eq(:column_3)
+      expect(adapter.send(:set_type, 1, 1, :string, nil)).to be_nil
+
+      adapter.instance_variable_set(:@reader, double(headers: %i[a b]))
+      expect(adapter.send(:sparse_row_hash, { a: 1 })).to eq({ a: 1 })
+      expect(adapter.send(:sparse_row_hash, %w[x y z])).to eq({ a: "x", b: "y", column_3: "z" })
+      expect(adapter.send(:sparse_row_hash, nil)).to eq({})
+      expect(adapter.send(:sparse_row_hash, "solo")).to eq({ column_1: "solo" })
+
+      adapter.instance_variable_set(:@rows, [])
+      adapter.send(:store_rows, { a: 1 })
+      adapter.send(:store_rows, [{ a: 2 }, nil])
+      expect(adapter.instance_variable_get(:@rows)).to eq([{ a: 1 }, { a: 2 }, {}])
+
+      adapter.instance_variable_set(:@header_row, ["H1"])
+      adapter.instance_variable_set(:@header_keys, [:h1])
+      adapter.instance_variable_set(:@rows, [])
+      adapter.send(:ensure_data_row, 3)
+      adapter.send(:ensure_header_width, 3)
+      expect(adapter.instance_variable_get(:@rows).length).to eq(2)
+      expect(adapter.instance_variable_get(:@header_keys)).to eq(%i[h1 column_2 column_3])
+      expect(adapter.instance_variable_get(:@header_row)).to eq(["H1", nil, nil])
+
+      adapter.instance_variable_set(:@cells_read, { "default" => true })
+      adapter.instance_variable_set(:@first_row, {})
+      adapter.instance_variable_set(:@last_row, {})
+      adapter.instance_variable_set(:@first_column, {})
+      adapter.instance_variable_set(:@last_column, {})
+      adapter.set_value(1, 2, "Header", nil)
+      adapter.set_value(2, 3, "Value", nil)
+      expect(adapter.row(1)).to eq(["H1", "Header", nil])
+      expect(adapter.row(2)).to eq([nil, nil, "Value"])
+      expect(adapter.celltype(1, 3)).to be_nil
+      expect(adapter.first_row).to eq(1)
+      expect(adapter.last_row).to eq(3)
+      expect(adapter.first_column).to eq(1)
+      expect(adapter.last_column).to eq(3)
+
+      adapter.instance_variable_set(:@header_row, ["  Head\n", nil])
+      adapter.instance_variable_set(:@rows, [{ a: " row\t" }, { b: 1 }])
+      adapter.instance_variable_set(:@cells_read, { "default" => true })
+      adapter.send(:clean_sheet, "default")
+      expect(adapter.instance_variable_get(:@header_row)).to eq(["Head", nil])
+      expect(adapter.instance_variable_get(:@rows).first[:a]).to eq("row")
+      expect(adapter.instance_variable_get(:@cleaned)["default"]).to eq(true)
+
+      other = described_class.new(csv_path, csv_options: { col_sep: ";" })
+      expect(other.send(:reinitialize)).to eq(1)
+      expect(other).to be_a(described_class)
+      expect(other.csv_options).to eq(col_sep: ";")
+    end
+
+    it "uses the URI source path when reading remote files" do
+      remote = described_class.new("http://example.com/test.csv")
+      allow(remote).to receive(:uri?).and_return(true)
+      allow(remote).to receive(:download_uri).with("http://example.com/test.csv", "/tmp/roo-test").and_return("/tmp/downloaded.csv")
+
+      yielded = nil
+      allow(Dir).to receive(:mktmpdir).and_yield("/tmp/roo-test")
+      remote.send(:with_source) { |source| yielded = source }
+
+      expect(yielded).to eq("/tmp/downloaded.csv")
+    end
+  end
+end