roo-andyw8 2.0.0

data/Gemfile

@@ -0,0 +1,24 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  # additional testing libs
+  gem 'webmock'
+  gem 'shoulda'
+  gem 'rspec', '>= 3.0.0'
+  gem 'vcr'
+  gem 'simplecov', '>= 0.9.0', require: false
+  gem 'coveralls', require: false
+end
+
+group :local_development do
+  gem 'terminal-notifier-guard', require: false if RUBY_PLATFORM.downcase.include?('darwin')
+  gem 'guard-rspec', '>= 4.3.1', require: false
+  gem 'guard-minitest', require: false
+  gem 'guard-bundler', require: false
+  gem 'guard-preek', require: false
+  gem 'guard-rubocop', require: false
+  gem 'guard-reek', github: 'pericles/guard-reek', require: false
+  gem 'pry'
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest, test_folders: ['test'] do
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+end
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2014 Thomas Preymesser, Ben Woosley
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# Roo [![Build Status](https://travis-ci.org/roo-rb/roo.svg)](https://travis-ci.org/roo-rb/roo)[![Code Climate](https://codeclimate.com/github/roo-rb/roo/badges/gpa.svg)](https://codeclimate.com/github/roo-rb/roo)[![Coverage Status](https://coveralls.io/repos/roo-rb/roo/badge.png)](https://coveralls.io/r/roo-rb/roo)
+
+Roo implements read access for all spreadsheet types and read/write access for
+Google spreadsheets. It can handle
+* Excelx
+* OpenOffice / LibreOffice
+* CSV
+
+## Additional libraries
+
+In addition, the roo-xls and roo-google gems exist to Google Spreadsheet add classic Excel
+handling capabilities to roo.
+
+## Usage:
+
+```ruby
+require 'roo'
+
+s = Roo::OpenOffice.new("myspreadsheet.ods")      # loads an OpenOffice Spreadsheet
+s = Roo::OpenOffice.new("myspreadsheet.ods", :password => "password") # loads an encrypted OpenOffice Spreadsheet
+s = Roo::Excelx.new("myspreadsheet.xlsx")         # loads an Excel Spreadsheet for Excel .xlsx files
+s = Roo::CSV.new("mycsv.csv")                     # loads a CSV file
+
+# You can use CSV to load TSV files, or files of a certain encoding by passing
+# in options under the :csv_options key
+s = Roo::CSV.new("mytsv.tsv", csv_options: {col_sep: "\t"}) # TSV
+s = Roo::CSV.new("mycsv.csv", csv_options: {encoding: Encoding::ISO_8859_1}) # csv with explicit encoding
+
+s.default_sheet = s.sheets.first             # first sheet in the spreadsheet file will be used
+
+# s.sheets is an array which holds the names of the sheets within
+# a spreadsheet.
+# you can also write
+# s.default_sheet = s.sheets[3] or
+# s.default_sheet = 'Sheet 3'
+
+s.cell(1,1)                                 # returns the content of the first row/first cell in the sheet
+s.cell('A',1)                               # same cell
+s.cell(1,'A')                               # same cell
+s.cell(1,'A',s.sheets[0])                   # same cell
+
+# almost all methods have an optional argument 'sheet'.
+# If this parameter is omitted, the default_sheet will be used.
+
+s.info                                      # Returns basic info about the spreadsheet file
+
+s.first_row                                 # the number of the first row
+s.last_row                                  # the number of the last row
+s.first_column                              # the number of the first column
+s.last_column                               # the number of the last column
+
+# limited font information is available
+
+s.font(1,1).bold?
+s.font(1,1).italic?
+s.font(1,1).underline?
+
+
+# Roo::Spreadsheet requires spreadsheet gem
+require 'spreadsheet'
+
+# Spreadsheet.open can accept both files and paths
+
+xls = Roo::Spreadsheet.open('./new_prices.xls')
+
+# If the File.path or provided path string does not have an extension, you can optionally
+# provide one as a string or symbol
+
+xls = Roo::Spreadsheet.open('./rails_temp_upload', extension: :xls)
+
+# no more setting xls.default_sheet, just use this
+
+xls.sheet('Info').row(1)
+xls.sheet(0).row(1)
+
+# excel likes to create random "Data01" sheets for macros
+# use this to find the sheet with the most data to parse
+
+xls.longest_sheet
+
+# this excel file has multiple worksheets, let's iterate through each of them and process
+
+xls.each_with_pagename do |name, sheet|
+  p sheet.row(1)
+end
+
+# pull out a hash of exclusive column data (get rid of useless columns and save memory)
+
+xls.each(:id => 'UPC',:qty => 'ATS') {|hash| arr << hash}
+#=> hash will appear like {:upc=>727880013358, :qty => 12}
+
+# NOTE: .parse does the same as .each, except it returns an array (similar to each vs. map)
+
+# not sure exactly what a column will be named? try a wildcard search with a regex
+
+xls.parse(:id => /UPC|SKU/,:qty => /ATS*\sATP\s*QTY\z/)
+
+# if you need to locate the header row and assign the header names themselves,
+# use the :header_search option
+
+xls.parse(:header_search => [/UPC*SKU/,/ATS*\sATP\s*QTY\z/])
+#=> each element will appear in this fashion:
+#=> {"UPC" => 123456789012, "STYLE" => "987B0", "COLOR" => "blue", "QTY" => 78}
+
+# want to strip out annoying unicode characters and surrounding white space?
+
+xls.parse(:clean => true)
+
+# another bonus feature is a patch to prevent the Spreadsheet gem from parsing
+# thousands and thousands of blank lines. i got fed up after watching my computer
+# nearly catch fire for 4 hours for a spreadsheet with only 200 ACTUAL lines
+# - located in lib/roo/worksheet.rb
+
+# if you want to load and stream .xlsx rows
+
+s = Roo::Excelx.new("./test_data/test_small.xlsx")
+s.each_row_streaming do |row|
+    puts row.inspect # Array of Excelx::Cell objects
+end
+
+```

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'coveralls/rake/task'
+
+# Test unit
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+# RSpec
+RSpec::Core::RakeTask.new(:spec)
+
+# Coveralls
+Coveralls::RakeTask.new
+
+default_task = [:test, :spec]
+default_task << 'coveralls:push' if ENV['TRAVIS']
+
+task default: default_task

data/examples/roo_soap_client.rb

@@ -0,0 +1,50 @@
+require 'soap/rpc/driver'
+
+def ferien_fuer_region(proxy, region, year = nil)
+  proxy.first_row.upto(proxy.last_row) do |row|
+    if proxy.cell(row, 2) == region
+      jahr = proxy.cell(row, 1).to_i
+      if year.nil? || jahr == year
+        bis_datum = proxy.cell(row, 5)
+        if DateTime.now > bis_datum
+          print '('
+        end
+        print jahr.to_s + ' '
+        print proxy.cell(row, 2) + ' '
+        print proxy.cell(row, 3) + ' '
+        print proxy.cell(row, 4).to_s + ' '
+        print bis_datum.to_s + ' '
+        print (proxy.cell(row, 6) || '') + ' '
+        if DateTime.now > bis_datum
+          print ')'
+        end
+        puts
+      end
+    end
+  end
+end
+
+proxy = SOAP::RPC::Driver.new('http://localhost:12321', 'spreadsheetserver')
+proxy.add_method('cell', 'row', 'col')
+proxy.add_method('officeversion')
+proxy.add_method('last_row')
+proxy.add_method('last_column')
+proxy.add_method('first_row')
+proxy.add_method('first_column')
+proxy.add_method('sheets')
+proxy.add_method('set_default_sheet', 's')
+proxy.add_method('ferien_fuer_region', 'region')
+
+sheets = proxy.sheets
+proxy.set_default_sheet(sheets.first)
+
+puts "first row: #{proxy.first_row}"
+puts "first column: #{proxy.first_column}"
+puts "last row: #{proxy.last_row}"
+puts "last column: #{proxy.last_column}"
+puts "cell: #{proxy.cell('C', 8)}"
+puts "cell: #{proxy.cell('F', 12)}"
+puts "officeversion: #{proxy.officeversion}"
+puts 'Berlin:'
+
+ferien_fuer_region(proxy, 'Berlin')

data/examples/roo_soap_server.rb

@@ -0,0 +1,26 @@
+require 'roo'
+require 'soap/rpc/standaloneServer'
+
+NS = 'spreadsheetserver' # name of your service = namespace
+class Server2 < SOAP::RPC::StandaloneServer
+  def on_init
+    spreadsheet = OpenOffice.new('./Ferien-de.ods')
+    add_method(spreadsheet, 'cell', 'row', 'col')
+    add_method(spreadsheet, 'officeversion')
+    add_method(spreadsheet, 'first_row')
+    add_method(spreadsheet, 'last_row')
+    add_method(spreadsheet, 'first_column')
+    add_method(spreadsheet, 'last_column')
+    add_method(spreadsheet, 'sheets')
+    # add_method(spreadsheet, 'default_sheet=', 's')
+    # method with '...=' did not work? alias method 'set_default_sheet' created
+    add_method(spreadsheet, 'set_default_sheet', 's')
+  end
+end
+
+PORT = 12_321
+puts "serving at port #{PORT}"
+svr = Server2.new('Roo', NS, '0.0.0.0', PORT)
+
+trap('INT') { svr.shutdown }
+svr.start

data/examples/write_me.rb

@@ -0,0 +1,31 @@
+require 'roo'
+
+#-- create a new spreadsheet within your google-spreadsheets and paste
+#-- the 'key' parameter in the spreadsheet URL
+MAXTRIES = 1000
+print "what's your name? "
+my_name = gets.chomp
+print 'where do you live? '
+my_location = gets.chomp
+print 'your message? (if left blank, only your name and location will be inserted) '
+my_message = gets.chomp
+spreadsheet = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
+spreadsheet.default_sheet = 'Sheet1'
+success = false
+MAXTRIES.times do
+  col = rand(10) + 1
+  row = rand(10) + 1
+  if spreadsheet.empty?(row, col)
+    if my_message.empty?
+      text = Time.now.to_s + ' ' + "Greetings from #{my_name} (#{my_location})"
+    else
+      text = Time.now.to_s + ' ' + "#{my_message} from #{my_name} (#{my_location})"
+    end
+    spreadsheet.set_value(row, col, text)
+    puts "message written to row #{row}, column #{col}"
+    success = true
+    break
+  end
+  puts "Row #{row}, column #{col} already occupied, trying again..."
+end
+puts "no empty cell found within #{MAXTRIES} tries" unless success

data/lib/roo.rb

@@ -0,0 +1,28 @@
+module Roo
+  autoload :Spreadsheet,  'roo/spreadsheet'
+  autoload :Base,         'roo/base'
+
+  autoload :OpenOffice,   'roo/open_office'
+  autoload :LibreOffice,  'roo/libre_office'
+  autoload :Excelx,       'roo/excelx'
+  autoload :CSV,          'roo/csv'
+
+  CLASS_FOR_EXTENSION = {
+    ods: Roo::OpenOffice,
+    xlsx: Roo::Excelx,
+    csv: Roo::CSV
+  }
+
+  def self.const_missing(const_name)
+    case const_name
+    when :Excel
+      raise "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."
+    when :Excel2003XML
+      raise "Excel SpreadsheetML support has been extracted to roo-xls. Install roo-xls to use Roo::Excel2003XML."
+    when :Google
+      raise "Google support has been extracted to roo-google. Install roo-google to use Roo::Google."
+    else
+      super
+    end
+  end
+end

data/lib/roo/base.rb

@@ -0,0 +1,717 @@
+# encoding: utf-8
+
+require 'tmpdir'
+require 'stringio'
+require 'nokogiri'
+require 'roo/utils'
+
+# Base class for all other types of spreadsheets
+class Roo::Base
+  include Enumerable
+
+  TEMP_PREFIX = 'roo_'
+  MAX_ROW_COL = 999_999.freeze
+  MIN_ROW_COL = 0.freeze
+
+  attr_reader :headers
+
+  # sets the line with attribute names (default: 1)
+  attr_accessor :header_line
+
+  def initialize(filename, options = {}, _file_warning = :error, _tmpdir = nil)
+    @filename = filename
+    @options = options
+
+    @cell = {}
+    @cell_type = {}
+    @cells_read = {}
+
+    @first_row = {}
+    @last_row = {}
+    @first_column = {}
+    @last_column = {}
+
+    @header_line = 1
+  end
+
+  def default_sheet
+    @default_sheet ||= sheets.first
+  end
+
+  # sets the working sheet in the document
+  # 'sheet' can be a number (1 = first sheet) or the name of a sheet.
+  def default_sheet=(sheet)
+    validate_sheet!(sheet)
+    @default_sheet = sheet
+    @first_row[sheet] = @last_row[sheet] = @first_column[sheet] = @last_column[sheet] = nil
+    @cells_read[sheet] = false
+  end
+
+  # first non-empty column as a letter
+  def first_column_as_letter(sheet = default_sheet)
+    ::Roo::Utils.number_to_letter(first_column(sheet))
+  end
+
+  # last non-empty column as a letter
+  def last_column_as_letter(sheet = default_sheet)
+    ::Roo::Utils.number_to_letter(last_column(sheet))
+  end
+
+  # Set first/last row/column for sheet
+  def first_last_row_col_for_sheet(sheet)
+    @first_last_row_cols ||= {}
+    @first_last_row_cols[sheet] ||= begin
+      result = collect_last_row_col_for_sheet(sheet)
+      {
+        first_row: result[:first_row] == MAX_ROW_COL ? nil : result[:first_row],
+        first_column: result[:first_column] == MAX_ROW_COL ? nil : result[:first_column],
+        last_row: result[:last_row] == MIN_ROW_COL ? nil : result[:last_row],
+        last_column: result[:last_column] == MIN_ROW_COL ? nil : result[:last_column]
+      }
+    end
+  end
+
+  # Collect first/last row/column from sheet
+  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|
+      next unless value
+      first_row = [first_row, key.first.to_i].min
+      last_row = [last_row, key.first.to_i].max
+      first_column = [first_column, key.last.to_i].min
+      last_column = [last_column, key.last.to_i].max
+    end if @cell[sheet]
+    {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|
+        unless 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
+    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
+    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
+
+  # call to_s method defined on subclasses
+  def inspect
+    to_s
+  end
+
+  # find a row either by row number or a condition
+  # Caution: this works only within the default sheet -> set default_sheet before you call this method
+  # (experimental. see examples in the test_roo.rb file)
+  def find(*args) # :nodoc
+    options = (args.last.is_a?(Hash) ? args.pop : {})
+
+    case args[0]
+    when Fixnum
+      find_by_row(args[0])
+    when :all
+      find_by_conditions(options)
+    else
+      fail ArgumentError, "unexpected arg #{args[0].inspect}, pass a row index or :all"
+    end
+  end
+
+  # returns all values in this row as an array
+  # row numbers are 1,2,3,... like in the spreadsheet
+  def row(row_number, sheet = default_sheet)
+    read_cells(sheet)
+    first_column(sheet).upto(last_column(sheet)).map do |col|
+      cell(row_number, col, sheet)
+    end
+  end
+
+  # returns all values in this column as an array
+  # column numbers are 1,2,3,... like in the spreadsheet
+  def column(column_number, sheet = default_sheet)
+    if column_number.is_a?(::String)
+      column_number = ::Roo::Utils.letter_to_number(column_number)
+    end
+    read_cells(sheet)
+    first_row(sheet).upto(last_row(sheet)).map do |row|
+      cell(row, column_number, sheet)
+    end
+  end
+
+  # set a cell to a certain value
+  # (this will not be saved back to the spreadsheet file!)
+  def set(row, col, value, sheet = default_sheet) #:nodoc:
+    read_cells(sheet)
+    row, col = normalize(row, col)
+    cell_type = cell_type_by_value(value)
+    set_value(row, col, value, sheet)
+    set_type(row, col, cell_type , sheet)
+  end
+
+  def cell_type_by_value(value)
+    case value
+    when Fixnum then :float
+    when String, Float then :string
+    else
+      raise ArgumentError, "Type for #{value} not set"
+    end
+  end
+
+  # reopens and read a spreadsheet document
+  def reload
+    ds = default_sheet
+    reinitialize
+    self.default_sheet = ds
+  end
+
+  # true if cell is empty
+  def empty?(row, col, sheet = default_sheet)
+    read_cells(sheet)
+    row, col = normalize(row, col)
+    contents = cell(row, col, sheet)
+    !contents || (celltype(row, col, sheet) == :string && contents.empty?) \
+      || (row < first_row(sheet) || row > last_row(sheet) || col < first_column(sheet) || col > last_column(sheet))
+  end
+
+  # returns information of the spreadsheet document and all sheets within
+  # this document.
+  def info
+    without_changing_default_sheet do
+      result = "File: #{File.basename(@filename)}\n"\
+        "Number of sheets: #{sheets.size}\n"\
+        "Sheets: #{sheets.join(', ')}\n"
+      n = 1
+      sheets.each do|sheet|
+        self.default_sheet = sheet
+        result << 'Sheet ' + n.to_s + ":\n"
+        unless first_row
+          result << '  - empty -'
+        else
+          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)}"
+        end
+        result << "\n" if sheet != sheets.last
+        n += 1
+      end
+      result
+    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|
+                  unless empty?(row, col)
+                    x.cell(cell(row, col),
+                           row: row,
+                           column: col,
+                           type: celltype(row, col))
+                  end
+                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)
+    # #aa42 => #cell('aa',42)
+    # #aa42('Sheet1')  => #cell('aa',42,'Sheet1')
+    if m =~ /^([a-z]+)(\d)$/
+      col = ::Roo::Utils.letter_to_number(Regexp.last_match[1])
+      row = Regexp.last_match[2].to_i
+      if args.empty?
+        cell(row, col)
+      else
+        cell(row, col, args.first)
+      end
+    else
+      super
+    end
+  end
+
+  # access different worksheets by calling spreadsheet.sheet(1)
+  # or spreadsheet.sheet('SHEETNAME')
+  def sheet(index, name = false)
+    self.default_sheet = String === index ? index : sheets[index]
+    name ? [default_sheet, self] : self
+  end
+
+  # iterate through all worksheets of a document
+  def each_with_pagename
+    sheets.each do |s|
+      yield sheet(s, true)
+    end
+  end
+
+
+  def clean_sheet_if_need(options)
+    return unless options[:clean]
+    options.delete(:clean)
+    @cleaned ||= {}
+    clean_sheet(default_sheet) unless @cleaned[default_sheet]
+  end
+
+  def search_or_set_header(options)
+    if options[:header_search]
+      @headers = nil
+      @header_line = row_with(options[:header_search])
+    elsif [:first_row, true].include?(options[:headers])
+      @headers = []
+      row(first_row).each_with_index { |x, i| @headers << [x, i + 1] }
+    else
+      set_headers(options)
+    end
+  end
+
+  # by passing in headers as options, this method returns
+  # specific columns from your header assignment
+  # for example:
+  # xls.sheet('New Prices').parse(:upc => 'UPC', :price => 'Price') would return:
+  # [{:upc => 123456789012, :price => 35.42},..]
+
+  # the queries are matched with regex, so regex options can be passed in
+  # such as :price => '^(Cost|Price)'
+  # case insensitive by default
+
+  # by using the :header_search option, you can query for headers
+  # and return a hash of every row with the keys set to the header result
+  # for example:
+  # xls.sheet('New Prices').parse(:header_search => ['UPC*SKU','^Price*\sCost\s'])
+
+  # that example searches for a column titled either UPC or SKU and another
+  # column titled either Price or Cost (regex characters allowed)
+  # * is the wildcard character
+
+  # you can also pass in a :clean => true option to strip the sheet of
+  # odd unicode characters and white spaces around columns
+
+  def each(options = {})
+    if options.empty?
+      1.upto(last_row) do |line|
+        yield row(line)
+      end
+    else
+      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]
+
+      @header_line.upto(last_row) do |line|
+        yield(Hash[headers.map { |k, v| [k, cell(line, v)] }])
+      end
+    end
+  end
+
+  def parse(options = {})
+    ary = []
+    each(options) do |row|
+      yield(row) if block_given?
+      ary << row
+    end
+    ary
+  end
+
+  def row_with(query, return_headers = false)
+    line_no = 0
+    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
+        fail "Couldn't find header row."
+      end
+    end
+    fail "Couldn't find header row."
+  end
+
+  protected
+
+  def file_type_check(filename, ext, name, warning_level, packed = nil)
+    if packed == :zip
+      # lalala.ods.zip => lalala.ods
+      # hier wird KEIN unzip gemacht, sondern nur der Name der Datei
+      # getestet, falls es eine gepackte Datei ist.
+      filename = File.basename(filename, File.extname(filename))
+    end
+
+    if uri?(filename) && qs_begin = filename.rindex('?')
+      filename = filename[0..qs_begin - 1]
+    end
+    if File.extname(filename).downcase != ext
+      case warning_level
+      when :error
+        warn file_type_warning_message(filename, ext)
+        fail TypeError, "#{filename} is not #{name} file"
+      when :warning
+        warn "are you sure, this is #{name} spreadsheet file?"
+        warn file_type_warning_message(filename, ext)
+      when :ignore
+        # ignore
+      else
+        fail "#{warning_level} illegal state of file_warning"
+      end
+    end
+  end
+
+  # konvertiert einen Key in der Form "12,45" (=row,column) in
+  # ein Array mit numerischen Werten ([12,45])
+  # 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.to_i, c.to_i]
+  end
+
+  # see: key_to_num
+  def key_to_string(arr)
+    "#{arr[0]},#{arr[1]}"
+  end
+
+  private
+
+  def local_filename(filename, tmpdir, packed)
+    filename = download_uri(filename, tmpdir) if uri?(filename)
+    filename = unzip(filename, tmpdir) if packed == :zip
+    unless File.file?(filename)
+      fail IOError, "file #{filename} does not exist"
+    end
+    filename
+  end
+
+  def file_type_warning_message(filename, ext)
+    "use #{Roo::CLASS_FOR_EXTENSION.fetch(ext.sub('.', '').to_sym)}.new to handle #{ext} spreadsheet files. This has #{File.extname(filename).downcase}"
+  rescue KeyError
+    raise "unknown file type: #{ext}"
+  end
+
+  def find_by_row(row_index)
+    row_index += (header_line - 1) if @header_line
+
+    row(row_index).size.times.map do |cell_index|
+      cell(row_index, cell_index + 1)
+    end
+  end
+
+  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]
+
+    # are all conditions met?
+    conditions = options[:conditions]
+    if conditions && !conditions.empty?
+      column_with = header_for.invert
+      rows = rows.select do |i|
+        conditions.all? { |key, val| cell(i, column_with[key]) == val }
+      end
+    end
+
+    if options[:array]
+      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]
+      end
+    end
+  end
+
+  def without_changing_default_sheet
+    original_default_sheet = default_sheet
+    yield
+  ensure
+    self.default_sheet = original_default_sheet
+  end
+
+  def reinitialize
+    initialize(@filename)
+  end
+
+  def make_tmpdir(prefix = nil, root = nil, &block)
+    prefix = if prefix
+      TEMP_PREFIX + prefix
+    else
+      TEMP_PREFIX
+    end
+    Dir.mktmpdir(prefix, root || ENV['ROO_TMP'], &block)
+  end
+
+  def clean_sheet(sheet)
+    read_cells(sheet)
+    @cell[sheet].each_pair do |coord, value|
+      if value.is_a?(::String)
+        @cell[sheet][coord] = sanitize_value(value)
+      end
+    end
+    @cleaned[sheet] = true
+  end
+
+  def sanitize_value(v)
+    v.unpack('U*').select { |b| b < 127 }.pack('U*').strip
+  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) })]
+  end
+
+  def header_index(query)
+    row(@header_line).index(query) + first_column
+  end
+
+  def set_value(row, col, value, sheet = default_sheet)
+    @cell[sheet][[row, col]] = value
+  end
+
+  def set_type(row, col, type, sheet = default_sheet)
+    @cell_type[sheet][[row, col]] = type
+  end
+
+  # converts cell coordinate to numeric values of row,col
+  def normalize(row, col)
+    if row.is_a?(::String)
+      if col.is_a?(::Fixnum)
+        # ('A',1):
+        # ('B', 5) -> (5, 2)
+        row, col = col, row
+      else
+        fail ArgumentError
+      end
+    end
+    if col.is_a?(::String)
+      col = ::Roo::Utils.letter_to_number(col)
+    end
+    [row, col]
+  end
+
+  def uri?(filename)
+    filename.start_with?('http://', 'https://')
+  rescue
+    false
+  end
+
+  def download_uri(uri, tmpdir)
+    require 'open-uri'
+    tempfilename = File.join(tmpdir, File.basename(uri))
+    begin
+      File.open(tempfilename, 'wb') do |file|
+        open(uri, 'User-Agent' => "Ruby/#{RUBY_VERSION}") do |net|
+          file.write(net.read)
+        end
+      end
+    rescue OpenURI::HTTPError
+      raise "could not open #{uri}"
+    end
+    tempfilename
+  end
+
+  def open_from_stream(stream, tmpdir)
+    tempfilename = File.join(tmpdir, 'spreadsheet')
+    File.open(tempfilename, 'wb') do |file|
+      file.write(stream[7..-1])
+    end
+    File.join(tmpdir, 'spreadsheet')
+  end
+
+  def unzip(filename, tmpdir)
+    require 'zip/filesystem'
+
+    Zip::File.open(filename) do |zip|
+      process_zipfile_packed(zip, tmpdir)
+    end
+  end
+
+  # check if default_sheet was set and exists in sheets-array
+  def validate_sheet!(sheet)
+    case sheet
+    when nil
+      fail ArgumentError, "Error: sheet 'nil' not valid"
+    when Fixnum
+      sheets.fetch(sheet - 1) do
+        fail RangeError, "sheet index #{sheet} not found"
+      end
+    when String
+      unless sheets.include? sheet
+        fail RangeError, "sheet '#{sheet}' not found"
+      end
+    else
+      fail TypeError, "not a valid sheet type: #{sheet.inspect}"
+    end
+  end
+
+  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.write(zip.read(path))
+      end
+      File.join(tmpdir, path)
+    else
+      ret = nil
+      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
+    if first_row(sheet) # sheet is not 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 # sheet not empty
+    end
+  end
+
+  # The content of a cell in the csv output
+  def cell_to_csv(row, col, sheet)
+    if empty?(row, col, sheet)
+      ''
+    else
+      onecell = cell(row, col, sheet)
+
+      case celltype(row, col, sheet)
+      when :string
+        %("#{onecell.tr('"', '""')}") unless onecell.empty?
+      when :boolean
+        %("#{onecell.tr('"', '""').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.tr('"', '""')}") unless onecell.empty?
+        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.tr('"', '""')}")
+      else
+        fail "unhandled celltype #{celltype(row, col, sheet)}"
+      end || ''
+    end
+  end
+
+  private
+
+  # converts an integer value to a time string like '02:05:06'
+  def integer_to_timestring(content)
+    h = (content / 3600.0).floor
+    content = content - h * 3600
+    m = (content / 60.0).floor
+    content = content - m * 60
+    s = content
+    sprintf('%02d:%02d:%02d', h, m, s)
+  end
+end