roo 2.6.0 → 2.8.3

data/lib/roo/base.rb

@@ -1,16 +1,24 @@
-# encoding: utf-8
-
-require 'tmpdir'
-require 'stringio'
-require 'nokogiri'
-require 'roo/utils'
+require "tmpdir"
+require "stringio"
+require "nokogiri"
+require "roo/utils"
+require "roo/formatters/base"
+require "roo/formatters/csv"
+require "roo/formatters/matrix"
+require "roo/formatters/xml"
+require "roo/formatters/yaml"
 
 # Base class for all other types of spreadsheets
 class Roo::Base
   include Enumerable
+  include Roo::Formatters::Base
+  include Roo::Formatters::CSV
+  include Roo::Formatters::Matrix
+  include Roo::Formatters::XML
+  include Roo::Formatters::YAML
 
-  MAX_ROW_COL = 999_999.freeze
-  MIN_ROW_COL = 0.freeze
+  MAX_ROW_COL = 999_999
+  MIN_ROW_COL = 0
 
   attr_reader :headers
 
@@ -18,10 +26,14 @@ class Roo::Base
   attr_accessor :header_line
 
   def self.TEMP_PREFIX
-    warn '[DEPRECATION] please access TEMP_PREFIX via Roo::TEMP_PREFIX'
+    warn "[DEPRECATION] please access TEMP_PREFIX via Roo::TEMP_PREFIX"
     Roo::TEMP_PREFIX
   end
 
+  def self.finalize(object_id)
+    proc { finalize_tempdirs(object_id) }
+  end
+
   def initialize(filename, options = {}, _file_warning = :error, _tmpdir = nil)
     @filename = filename
     @options = options
@@ -42,6 +54,11 @@ class Roo::Base
     if self.class.respond_to?(:finalize_tempdirs)
       self.class.finalize_tempdirs(object_id)
     end
+
+    instance_variables.each do |instance_variable|
+      instance_variable_set(instance_variable, nil)
+    end
+
     nil
   end
 
@@ -50,10 +67,10 @@ class Roo::Base
   end
 
   # sets the working sheet in the document
-  # 'sheet' can be a number (1 = first sheet) or the name of a sheet.
+  # 'sheet' can be a number (0 = first sheet) or the name of a sheet.
   def default_sheet=(sheet)
     validate_sheet!(sheet)
-    @default_sheet = sheet
+    @default_sheet = sheet.is_a?(String) ? sheet : sheets[sheet]
     @first_row[sheet] = @last_row[sheet] = @first_column[sheet] = @last_column[sheet] = nil
     @cells_read[sheet] = false
   end
@@ -86,7 +103,7 @@ class Roo::Base
   def collect_last_row_col_for_sheet(sheet)
     first_row = first_column = MAX_ROW_COL
     last_row = last_column = MIN_ROW_COL
-    @cell[sheet].each_pair do|key, value|
+    @cell[sheet].each_pair do |key, value|
       next unless value
       first_row = [first_row, key.first.to_i].min
       last_row = [last_row, key.first.to_i].max
@@ -96,82 +113,14 @@ class Roo::Base
     { first_row: first_row, first_column: first_column, last_row: last_row, last_column: last_column }
   end
 
-  %w(first_row last_row first_column last_column).each do |key|
-    class_eval <<-EOS, __FILE__, __LINE__ + 1
-      def #{key}(sheet = default_sheet)                                   # def first_row(sheet = default_sheet)
-        read_cells(sheet)                                                 #   read_cells(sheet)
-        @#{key}[sheet] ||= first_last_row_col_for_sheet(sheet)[:#{key}]   #   @first_row[sheet] ||= first_last_row_col_for_sheet(sheet)[:first_row]
-      end                                                                 # end
-    EOS
-  end
-
-  # returns a rectangular area (default: all cells) as yaml-output
-  # you can add additional attributes with the prefix parameter like:
-  # oo.to_yaml({"file"=>"flightdata_2007-06-26", "sheet" => "1"})
-  def to_yaml(prefix = {}, from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
-    return '' unless first_row # empty result if there is no first_row in a sheet
-
-    from_row ||= first_row(sheet)
-    to_row ||= last_row(sheet)
-    from_column ||= first_column(sheet)
-    to_column ||= last_column(sheet)
-
-    result = "--- \n"
-    from_row.upto(to_row) do |row|
-      from_column.upto(to_column) do |col|
-        next if empty?(row, col, sheet)
-
-        result << "cell_#{row}_#{col}: \n"
-        prefix.each do|k, v|
-          result << "  #{k}: #{v} \n"
-        end
-        result << "  row: #{row} \n"
-        result << "  col: #{col} \n"
-        result << "  celltype: #{celltype(row, col, sheet)} \n"
-        value = cell(row, col, sheet)
-        if celltype(row, col, sheet) == :time
-          value = integer_to_timestring(value)
-        end
-        result << "  value: #{value} \n"
-      end
-    end
-
-    result
-  end
-
-  # write the current spreadsheet to stdout or into a file
-  def to_csv(filename = nil, separator = ',', sheet = default_sheet)
-    if filename
-      File.open(filename, 'w') do |file|
-        write_csv_content(file, sheet, separator)
-      end
-      true
-    else
-      sio = ::StringIO.new
-      write_csv_content(sio, sheet, separator)
-      sio.rewind
-      sio.read
+  %i(first_row last_row first_column last_column).each do |key|
+    ivar = "@#{key}".to_sym
+    define_method(key) do |sheet = default_sheet|
+      read_cells(sheet)
+      instance_variable_get(ivar)[sheet] ||= first_last_row_col_for_sheet(sheet)[key]
     end
   end
 
-  # returns a matrix object from the whole sheet or a rectangular area of a sheet
-  def to_matrix(from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
-    require 'matrix'
-
-    return Matrix.empty unless first_row
-
-    from_row ||= first_row(sheet)
-    to_row ||= last_row(sheet)
-    from_column ||= first_column(sheet)
-    to_column ||= last_column(sheet)
-
-    Matrix.rows(from_row.upto(to_row).map do |row|
-      from_column.upto(to_column).map do |col|
-        cell(row, col, sheet)
-      end
-    end)
-  end
-
   def inspect
     "<##{self.class}:#{object_id.to_s(8)} #{instance_variables.join(' ')}>"
   end
@@ -256,16 +205,16 @@ class Roo::Base
         "Number of sheets: #{sheets.size}\n"\
         "Sheets: #{sheets.join(', ')}\n"
       n = 1
-      sheets.each do|sheet|
+      sheets.each do |sheet|
         self.default_sheet = sheet
-        result << 'Sheet ' + n.to_s + ":\n"
+        result << "Sheet " + n.to_s + ":\n"
         if first_row
           result << "  First row: #{first_row}\n"
           result << "  Last row: #{last_row}\n"
           result << "  First column: #{::Roo::Utils.number_to_letter(first_column)}\n"
           result << "  Last column: #{::Roo::Utils.number_to_letter(last_column)}"
         else
-          result << '  - empty -'
+          result << "  - empty -"
         end
         result << "\n" if sheet != sheets.last
         n += 1
@@ -274,32 +223,6 @@ class Roo::Base
     end
   end
 
-  # returns an XML representation of all sheets of a spreadsheet file
-  def to_xml
-    Nokogiri::XML::Builder.new do |xml|
-      xml.spreadsheet do
-        sheets.each do |sheet|
-          self.default_sheet = sheet
-          xml.sheet(name: sheet) do |x|
-            if first_row && last_row && first_column && last_column
-              # sonst gibt es Fehler bei leeren Blaettern
-              first_row.upto(last_row) do |row|
-                first_column.upto(last_column) do |col|
-                  next if empty?(row, col)
-
-                  x.cell(cell(row, col),
-                           row: row,
-                           column: col,
-                           type: celltype(row, col))
-                end
-              end
-            end
-          end
-        end
-      end
-    end.to_xml
-  end
-
   # when a method like spreadsheet.a42 is called
   # convert it to a call of spreadsheet.cell('a',42)
   def method_missing(m, *args)
@@ -365,39 +288,42 @@ class Roo::Base
       clean_sheet_if_need(options)
       search_or_set_header(options)
       headers = @headers ||
-                Hash[(first_column..last_column).map do |col|
-                  [cell(@header_line, col), col]
-                end]
+                (first_column..last_column).each_with_object({}) do |col, hash|
+                  hash[cell(@header_line, col)] = col
+                end
 
       @header_line.upto(last_row) do |line|
-        yield(Hash[headers.map { |k, v| [k, cell(line, v)] }])
+        yield(headers.each_with_object({}) { |(k, v), hash| hash[k] = cell(line, v) })
       end
     end
   end
 
   def parse(options = {})
-    ary = []
-    each(options) do |row|
-      yield(row) if block_given?
-      ary << row
+    results = each(options).map do |row|
+      block_given? ? yield(row) : row
     end
-    ary
+
+    options[:headers] == true ? results : results.drop(1)
   end
 
   def row_with(query, return_headers = false)
     line_no = 0
+    closest_mismatched_headers = []
     each do |row|
       line_no += 1
       headers = query.map { |q| row.grep(q)[0] }.compact
-
       if headers.length == query.length
         @header_line = line_no
         return return_headers ? headers : line_no
-      elsif line_no > 100
-        raise Roo::HeaderRowNotFoundError
+      else
+        closest_mismatched_headers = headers if headers.length > closest_mismatched_headers.length
+        if line_no > 100
+          break
+        end
       end
     end
-    raise Roo::HeaderRowNotFoundError
+    missing_headers = query.select { |q| closest_mismatched_headers.grep(q).empty? }
+    raise Roo::HeaderRowNotFoundError, missing_headers
   end
 
   protected
@@ -410,7 +336,7 @@ class Roo::Base
       filename = File.basename(filename, File.extname(filename))
     end
 
-    if uri?(filename) && (qs_begin = filename.rindex('?'))
+    if uri?(filename) && (qs_begin = filename.rindex("?"))
       filename = filename[0..qs_begin - 1]
     end
     exts = Array(exts)
@@ -436,7 +362,7 @@ class Roo::Base
   # Diese Methode ist eine temp. Loesung, um zu erforschen, ob der
   # Zugriff mit numerischen Keys schneller ist.
   def key_to_num(str)
-    r, c = str.split(',')
+    r, c = str.split(",")
     [r.to_i, c.to_i]
   end
 
@@ -498,9 +424,9 @@ class Roo::Base
 
   def find_by_conditions(options)
     rows = first_row.upto(last_row)
-    header_for = Hash[1.upto(last_column).map do |col|
-      [col, cell(@header_line, col)]
-    end]
+    header_for = 1.upto(last_column).each_with_object({}) do |col, hash|
+      hash[col] = cell(@header_line, col)
+    end
 
     # are all conditions met?
     conditions = options[:conditions]
@@ -515,9 +441,9 @@ class Roo::Base
       rows.map { |i| row(i) }
     else
       rows.map do |i|
-        Hash[1.upto(row(i).size).map do |j|
-          [header_for.fetch(j), cell(i, j)]
-        end]
+        1.upto(row(i).size).each_with_object({}) do |j, hash|
+          hash[header_for.fetch(j)] = cell(i, j)
+        end
       end
     end
   end
@@ -535,7 +461,7 @@ class Roo::Base
 
   def find_basename(filename)
     if uri?(filename)
-      require 'uri'
+      require "uri"
       uri = URI.parse filename
       File.basename(uri.path)
     elsif !is_stream?(filename)
@@ -544,9 +470,9 @@ class Roo::Base
   end
 
   def make_tmpdir(prefix = nil, root = nil, &block)
-    warn '[DEPRECATION] extend Roo::Tempdir and use its .make_tempdir instead'
+    warn "[DEPRECATION] extend Roo::Tempdir and use its .make_tempdir instead"
     prefix = "#{Roo::TEMP_PREFIX}#{prefix}"
-    root ||= ENV['ROO_TMP']
+    root ||= ENV["ROO_TMP"]
 
     if block_given?
       # folder is deleted at end of block
@@ -565,14 +491,17 @@ class Roo::Base
   end
 
   def sanitize_value(v)
-    v.gsub(/[[:cntrl:]]|^[\p{Space}]+|[\p{Space}]+$/, '')
+    v.gsub(/[[:cntrl:]]|^[\p{Space}]+|[\p{Space}]+$/, "")
   end
 
   def set_headers(hash = {})
     # try to find header row with all values or give an error
     # then create new hash by indexing strings and keeping integers for header array
-    @headers = row_with(hash.values, true)
-    @headers = Hash[hash.keys.zip(@headers.map { |x| header_index(x) })]
+    header_row = row_with(hash.values, true)
+    @headers = {}
+    hash.each_with_index do |(key, _), index|
+      @headers[key] = header_index(header_row[index])
+    end
   end
 
   def header_index(query)
@@ -605,17 +534,17 @@ class Roo::Base
   end
 
   def uri?(filename)
-    filename.start_with?('http://', 'https://', 'ftp://')
+    filename.start_with?("http://", "https://", "ftp://")
   rescue
     false
   end
 
   def download_uri(uri, tmpdir)
-    require 'open-uri'
+    require "open-uri"
     tempfilename = File.join(tmpdir, find_basename(uri))
     begin
-      File.open(tempfilename, 'wb') do |file|
-        open(uri, 'User-Agent' => "Ruby/#{RUBY_VERSION}") do |net|
+      File.open(tempfilename, "wb") do |file|
+        open(uri, "User-Agent" => "Ruby/#{RUBY_VERSION}") do |net|
           file.write(net.read)
         end
       end
@@ -626,15 +555,15 @@ class Roo::Base
   end
 
   def open_from_stream(stream, tmpdir)
-    tempfilename = File.join(tmpdir, 'spreadsheet')
-    File.open(tempfilename, 'wb') do |file|
+    tempfilename = File.join(tmpdir, "spreadsheet")
+    File.open(tempfilename, "wb") do |file|
       file.write(stream[7..-1])
     end
-    File.join(tmpdir, 'spreadsheet')
+    File.join(tmpdir, "spreadsheet")
   end
 
   def unzip(filename, tmpdir)
-    require 'zip/filesystem'
+    require "zip/filesystem"
 
     Zip::File.open(filename) do |zip|
       process_zipfile_packed(zip, tmpdir)
@@ -647,7 +576,7 @@ class Roo::Base
     when nil
       fail ArgumentError, "Error: sheet 'nil' not valid"
     when Integer
-      sheets.fetch(sheet - 1) do
+      sheets.fetch(sheet) do
         fail RangeError, "sheet index #{sheet} not found"
       end
     when String
@@ -659,92 +588,20 @@ class Roo::Base
     end
   end
 
-  def process_zipfile_packed(zip, tmpdir, path = '')
+  def process_zipfile_packed(zip, tmpdir, path = "")
     if zip.file.file? path
       # extract and return filename
-      File.open(File.join(tmpdir, path), 'wb') do |file|
+      File.open(File.join(tmpdir, path), "wb") do |file|
         file.write(zip.read(path))
       end
       File.join(tmpdir, path)
     else
       ret = nil
-      path += '/' unless path.empty?
+      path += "/" unless path.empty?
       zip.dir.foreach(path) do |filename|
         ret = process_zipfile_packed(zip, tmpdir, path + filename)
       end
       ret
     end
   end
-
-  # Write all cells to the csv file. File can be a filename or nil. If the this
-  # parameter is nil the output goes to STDOUT
-  def write_csv_content(file = nil, sheet = nil, separator = ',')
-    file ||= STDOUT
-    return unless first_row(sheet) # The sheet is empty
-
-    1.upto(last_row(sheet)) do |row|
-      1.upto(last_column(sheet)) do |col|
-        file.print(separator) if col > 1
-        file.print cell_to_csv(row, col, sheet)
-      end
-      file.print("\n")
-    end
-  end
-
-  # The content of a cell in the csv output
-  def cell_to_csv(row, col, sheet)
-    return '' if empty?(row, col, sheet)
-
-    onecell = cell(row, col, sheet)
-
-    case celltype(row, col, sheet)
-    when :string
-      %("#{onecell.gsub('"', '""')}") unless onecell.empty?
-    when :boolean
-      # TODO: this only works for excelx
-      onecell = self.sheet_for(sheet).cells[[row, col]].formatted_value
-      %("#{onecell.gsub('"', '""').downcase}")
-    when :float, :percentage
-      if onecell == onecell.to_i
-        onecell.to_i.to_s
-      else
-        onecell.to_s
-      end
-    when :formula
-      case onecell
-      when String
-        %("#{onecell.gsub('"', '""')}") unless onecell.empty?
-      when Integer
-        onecell.to_s
-      when Float
-        if onecell == onecell.to_i
-          onecell.to_i.to_s
-        else
-          onecell.to_s
-        end
-      when DateTime
-        onecell.to_s
-      else
-        fail "unhandled onecell-class #{onecell.class}"
-      end
-    when :date, :datetime
-      onecell.to_s
-    when :time
-      integer_to_timestring(onecell)
-    when :link
-      %("#{onecell.url.gsub('"', '""')}")
-    else
-      fail "unhandled celltype #{celltype(row, col, sheet)}"
-    end || ''
-  end
-
-  # converts an integer value to a time string like '02:05:06'
-  def integer_to_timestring(content)
-    h = (content / 3600.0).floor
-    content -= h * 3600
-    m = (content / 60.0).floor
-    content -= m * 60
-    s = content
-    sprintf('%02d:%02d:%02d', h, m, s)
-  end
 end

data/lib/roo/constants.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Roo
-  ROO_EXCEL_NOTICE   = "Excel support has been extracted to roo-xls due to its dependency on the GPL'd spreadsheet gem. Install roo-xls to use Roo::Excel.".freeze
-  ROO_EXCELML_NOTICE = "Excel SpreadsheetML support has been extracted to roo-xls. Install roo-xls to use Roo::Excel2003XML.".freeze
-  ROO_GOOGLE_NOTICE = "Google support has been extracted to roo-google. Install roo-google to use Roo::Google.".freeze
+  ROO_EXCEL_NOTICE   = "Excel support has been extracted to roo-xls due to its dependency on the GPL'd spreadsheet gem. Install roo-xls to use Roo::Excel."
+  ROO_EXCELML_NOTICE = "Excel SpreadsheetML support has been extracted to roo-xls. Install roo-xls to use Roo::Excel2003XML."
+  ROO_GOOGLE_NOTICE = "Google support has been extracted to roo-google. Install roo-google to use Roo::Google."
 end