roo 1.11.2 → 1.12.0

data/CHANGELOG

@@ -1,4 +1,29 @@
-== 1.11.2 (unreleased)
+== 1.12.0 (unreleased)
+
+* 3 deprecations
+  * Rename Openoffice -> OpenOffice, Libreoffice -> LibreOffice, Csv -> CSV, and redirect the old names to the new constants
+  * Enable Roo::Excel, Excel2003XML, Excelx, OpenOffice to accept an options hash, and deprecate the old method argument based approach to supplying them options
+  * Roo's roo_rails_helper, aka the `spreadsheet` html-generating view method is currently deprecated with no replacement. If you find it helpful, tell http://github.com/Empact or extract it yourself.
+
+* 9 enhancements
+  * Add Roo::Excelx#load_xml so that people can customize to their data, e.g. https://github.com/Empact/roo/pull/23
+  * Enable passing csv_options to Roo::CSV, which are passed through to the underlying CSV call.
+  * Enable passing options through from Roo::Spreadsheet to any Roo type.
+  * Enable passing an :extension option to Roo::Spreadsheet.new, which will override the extension detected on in the path https://github.com/Empact/roo/pull/15
+  * Switch from google-spreadsheet-ruby to google_drive for Roo::Google access https://github.com/Empact/roo/pull/40
+  * Make all the classes consistent in that #read_cells is only effective if the sheet has not been read.
+  * Roo::Google supports login via oauth :access_token. https://github.com/Empact/roo/pull/61
+  * Roo::Excel now exposes its Spreadsheet workbook via #workbook
+  * Pull #load_xml down into Roo::Base, and use it in Excel2003XML and OpenOffice.
+
+* 2 changes
+  * #formula? now returns truthy or falsey, rather than true/false.
+  * Base#longest_sheet was moved to Excel, as it only worked under Excel
+
+* 1 bugfix
+  * Fix that Roo::CSV#parse(headers: true) would blow up. https://github.com/Empact/roo/pull/37
+
+== 1.11.2 2013-04-10
 
 * 4 bugfixes
   * Fix that Roo::Spreadsheet.open wasn't tolerant to case differences.

data/Gemfile

@@ -3,9 +3,9 @@ source 'http://rubygems.org'
 gem 'spreadsheet', '> 0.6.4'
 gem 'nokogiri'
 gem 'rubyzip'
-# gem 'google-spreadsheet-ruby'
 
 group :development do
+  gem 'google_drive'
   gem 'jeweler'
 end
 
@@ -14,4 +14,5 @@ group :test do
   gem 'webmock'
   gem 'shoulda'
   gem 'rspec'
+  gem 'vcr'
 end

data/Gemfile.lock

@@ -4,14 +4,37 @@ GEM
     addressable (2.3.2)
     crack (0.3.1)
     diff-lcs (1.2.1)
+    faraday (0.8.7)
+      multipart-post (~> 1.1)
     git (1.2.5)
+    google_drive (0.3.6)
+      nokogiri (>= 1.4.4, != 1.5.2, != 1.5.1)
+      oauth (>= 0.3.6)
+      oauth2 (>= 0.5.0)
+    httpauth (0.2.0)
     jeweler (1.8.3)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
       rdoc
     json (1.7.7)
+    json (1.7.7-java)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    multi_json (1.7.3)
+    multi_xml (0.5.3)
+    multipart-post (1.2.0)
     nokogiri (1.5.6)
+    nokogiri (1.5.6-java)
+    oauth (0.4.7)
+    oauth2 (0.9.1)
+      faraday (~> 0.8)
+      httpauth (~> 0.1)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
     rake (0.9.2.2)
     rdoc (3.12.2)
       json (~> 1.4)
@@ -32,6 +55,7 @@ GEM
     shoulda-matchers (1.0.0)
     spreadsheet (0.8.2)
       ruby-ole (>= 1.0)
+    vcr (2.5.0)
     webmock (1.9.0)
       addressable (>= 2.2.7)
       crack (>= 0.1.7)
@@ -41,10 +65,12 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  google_drive
   jeweler
   nokogiri
   rspec
   rubyzip
   shoulda
   spreadsheet (> 0.6.4)
+  vcr
   webmock

data/README.markdown

@@ -2,108 +2,128 @@
 
 Roo implements read access for all spreadsheet types and read/write access for
 Google spreadsheets. It can handle
-* Openoffice
+* OpenOffice
 * Excel
 * Google spreadsheets
 * Excelx
-* Libreoffice
+* LibreOffice
 * CSV
 
+## Notes
+
+### XLS
+
+There is no support for formulas in Roo for .xls files - you can get the result
+of a formula but not the formula itself.
+
+### Google Spreadsheet
+
 Using Roo to access Google spreadsheets requires you install the 'google-spreadsheet-ruby' gem separately.
 
-Unless the underlying 'spreadsheet' gem supports formulas there is no support
-for formulas in Roo for .xls files (you get the result of a formula in such a
-file but not the formula itself)
+## License
+
+While Roo is licensed under the MIT / Expat license, please note that the 'spreadsheet' gem [is released under](https://github.com/zdavatz/spreadsheet/blob/master/LICENSE.txt) the GPLv3 license.
 
 ## Usage:
 
-    require 'roo'
+require 'roo'
+
+s = Roo::OpenOffice.new("myspreadsheet.ods")      # loads an OpenOffice Spreadsheet
+s = Roo::Excel.new("myspreadsheet.xls")           # loads an Excel Spreadsheet
+s = Roo::Google.new("myspreadsheetkey_at_google") # loads a Google 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
 
-    s = Roo::Openoffice.new("myspreadsheet.ods")      # creates an Openoffice Spreadsheet instance
-    s = Roo::Excel.new("myspreadsheet.xls")           # creates an Excel Spreadsheet instance
-    s = Roo::Google.new("myspreadsheetkey_at_google") # creates an Google Spreadsheet instance
-    s = Roo::Excelx.new("myspreadsheet.xlsx")         # creates an Excel Spreadsheet instance for Excel .xlsx files
+# 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.default_sheet = s.sheets.first             # first sheet in the spreadsheet file will be used
 
-    # s.sheet 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.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
+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.
+# almost all methods have an optional argument 'sheet'.
+# If this parameter is omitted, the default_sheet will be used.
 
-    s.info                                      # prints infos about the spreadsheet file
+s.info                                      # prints infos 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
+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
+# limited font information is available
 
-    s.font(1,1).bold?
-    s.font(1,1).italic?
-    s.font(1,1).underline?
+s.font(1,1).bold?
+s.font(1,1).italic?
+s.font(1,1).underline?
 
 
 see http://roo.rubyforge.org for a more complete tutorial
 
 # Fork Changelog / New Features
 
-    # Spreadsheet.open can accept both files and paths
+# 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('./new_prices.xls')
+xls = Roo::Spreadsheet.open('./rails_temp_upload', extension: :xls)
 
-    # no more setting xls.default_sheet, just use this
+# no more setting xls.default_sheet, just use this
 
-    xls.sheet('Info').row_count
-    xls.sheet(0).row_count
+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
+# excel likes to create random "Data01" sheets for macros
+# use this to find the sheet with the most data to parse
 
-    xls.longest_sheet
+xls.longest_sheet
 
-    # this excel file has multiple worksheets, let's iterate through each of them and process
+# this excel file has multiple worksheets, let's iterate through each of them and process
 
-    xls.each_with_pagename do |name,sheet|
-    puts sheet.row_count
-    end
+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)
+# 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}
+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)
+# 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 the character *
-    # regex characters are allowed ('^price\s')
-    # case insensitive
+# not sure exactly what a column will be named? try a wildcard search with the character *
+# regex characters are allowed ('^price\s')
+# case insensitive
 
-    xls.parse(:id => 'UPC*SKU',:qty => 'ATS*\sATP\s*QTY$')
+xls.parse(:id => 'UPC*SKU',:qty => 'ATS*\sATP\s*QTY$')
 
-    # if you need to locate the header row and assign the header names themselves,
-    # use the :header_search option
+# 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$'])
-    #=> each element will appear in this fashion:
-    #=> {"UPC" => 123456789012, "STYLE" => "987B0", "COLOR" => "blue", "QTY" => 78}
+xls.parse(:header_search => ['UPC*SKU','ATS*\sATP\s*QTY$'])
+#=> 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?
+# want to strip out annoying unicode characters and surrounding white space?
 
-    xls.parse(:clean => true)
+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
+# 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
 

data/Rakefile

@@ -4,7 +4,7 @@ Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "roo"
   gem.summary = "Roo can access the contents of various spreadsheet files."
-  gem.description = "Roo can access the contents of various spreadsheet files. It can handle\n* Openoffice\n* Excel\n* Google spreadsheets\n* Excelx\n* Libreoffice\n* CSV"
+  gem.description = "Roo can access the contents of various spreadsheet files. It can handle\n* OpenOffice\n* Excel\n* Google spreadsheets\n* Excelx\n* LibreOffice\n* CSV"
   gem.email = "ruby.ruby.ruby.roo@gmail.com"
   gem.homepage = "http://github.com/Empact/roo"
   gem.authors = ['Thomas Preymesser', 'Hugh McGowan', 'Ben Woosley']

data/VERSION

@@ -1 +1 @@
-1.11.2
+1.12.0

data/examples/roo_soap_server.rb

@@ -5,7 +5,7 @@ NS = "spreadsheetserver" # name of your service = namespace
 class Server2 < SOAP::RPC::StandaloneServer
 
   def on_init
-    spreadsheet = Openoffice.new("./Ferien-de.ods")
+    spreadsheet = OpenOffice.new("./Ferien-de.ods")
     add_method(spreadsheet, 'cell', 'row', 'col')
     add_method(spreadsheet, 'officeversion')
     add_method(spreadsheet, 'first_row')

data/lib/roo.rb

@@ -1,16 +1,34 @@
 module Roo
 
-  VERSION = '1.10.3'
+  VERSION = '1.12.0'
 
-  autoload :Spreadsheet, 'roo/spreadsheet'
+  def self.const_missing(const_name)
+    case const_name
+    when :Libreoffice
+      warn "`Roo::Libreoffice` has been deprecated. Use `Roo::LibreOffice` instead."
+      LibreOffice
+    when :Openoffice
+      warn "`Roo::Openoffice` has been deprecated. Use `Roo::OpenOffice` instead."
+      OpenOffice
+    when :Csv
+      warn "`Roo::Csv` has been deprecated. Use `Roo::CSV` instead."
+      CSV
+    when :GenericSpreadsheet
+      warn "`Roo::GenericSpreadsheet` has been deprecated. Use `Roo::Base` instead."
+      Base
+    else
+      super
+    end
+  end
 
-  autoload :GenericSpreadsheet, 'roo/generic_spreadsheet'
-  autoload :Openoffice,         'roo/openoffice'
-  autoload :Excel,              'roo/excel'
-  autoload :Excelx,             'roo/excelx'
-  autoload :Google,             'roo/google'
-  autoload :Csv,                'roo/csv'
+  autoload :Spreadsheet,  'roo/spreadsheet'
+  autoload :Base,         'roo/base'
 
-  autoload :Excel2003XML,       'roo/excel2003xml'
-  autoload :RooRailsHelper,     'roo/roo_rails_helper'
+  autoload :OpenOffice,   'roo/openoffice'
+  autoload :LibreOffice,  'roo/openoffice'
+  autoload :Excel,        'roo/excel'
+  autoload :Excelx,       'roo/excelx'
+  autoload :Excel2003XML, 'roo/excel2003xml'
+  autoload :Google,       'roo/google'
+  autoload :CSV,          'roo/csv'
 end

data/lib/roo/{generic_spreadsheet.rb → base.rb}

@@ -5,7 +5,7 @@ require 'stringio'
 require 'zip/zipfilesystem'
 
 # Base class for all other types of spreadsheets
-class Roo::GenericSpreadsheet
+class Roo::Base
   include Enumerable
 
   TEMP_PREFIX = "oo_"
@@ -18,7 +18,7 @@ class Roo::GenericSpreadsheet
   protected
 
   def self.split_coordinate(str)
-    letter,number = Roo::GenericSpreadsheet.split_coord(str)
+    letter,number = Roo::Base.split_coord(str)
     x = letter_to_number(letter)
     y = number
     return y, x
@@ -37,9 +37,12 @@ class Roo::GenericSpreadsheet
 
   public
 
-  def initialize(filename, packed=nil, file_warning=:error, tmpdir=nil)
-    @cell = Hash.new{|h,k| h[k] = {}}
-    @cell_type = Hash.new{|h,k| h[k] = {}}
+  def initialize(filename, options={}, file_warning=:error, tmpdir=nil)
+    @filename = filename
+    @options = options
+
+    @cell = {}
+    @cell_type = {}
     @cells_read = {}
 
     @first_row = {}
@@ -47,12 +50,8 @@ class Roo::GenericSpreadsheet
     @first_column = {}
     @last_column = {}
 
-    @style = {}
-    @style_defaults = Hash.new { |h,k| h[k] = [] }
-    @style_definitions = {}
-
+    @header_line = 1
     @default_sheet = self.sheets.first
-    @formula = {}
     @header_line = 1
   end
 
@@ -67,18 +66,18 @@ class Roo::GenericSpreadsheet
 
   # first non-empty column as a letter
   def first_column_as_letter(sheet=nil)
-    Roo::GenericSpreadsheet.number_to_letter(first_column(sheet))
+    Roo::Base.number_to_letter(first_column(sheet))
   end
 
   # last non-empty column as a letter
   def last_column_as_letter(sheet=nil)
-    Roo::GenericSpreadsheet.number_to_letter(last_column(sheet))
+    Roo::Base.number_to_letter(last_column(sheet))
   end
 
   # returns the number of the first non-empty row
   def first_row(sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     if @first_row[sheet]
       return @first_row[sheet]
     end
@@ -96,7 +95,7 @@ class Roo::GenericSpreadsheet
   # returns the number of the last non-empty row
   def last_row(sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     if @last_row[sheet]
       return @last_row[sheet]
     end
@@ -114,7 +113,7 @@ class Roo::GenericSpreadsheet
   # returns the number of the first non-empty column
   def first_column(sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     if @first_column[sheet]
       return @first_column[sheet]
     end
@@ -132,7 +131,7 @@ class Roo::GenericSpreadsheet
   # returns the number of the last non-empty column
   def last_column(sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     if @last_column[sheet]
       return @last_column[sheet]
     end
@@ -166,7 +165,7 @@ class Roo::GenericSpreadsheet
           result << "  col: #{col} \n"
           result << "  celltype: #{self.celltype(row,col,sheet)} \n"
           if self.celltype(row,col,sheet) == :time
-            result << "  value: #{Roo::GenericSpreadsheet.integer_to_timestring( self.cell(row,col,sheet))} \n"
+            result << "  value: #{Roo::Base.integer_to_timestring( self.cell(row,col,sheet))} \n"
           else
             result << "  value: #{self.cell(row,col,sheet)} \n"
           end
@@ -255,7 +254,7 @@ class Roo::GenericSpreadsheet
   # row numbers are 1,2,3,... like in the spreadsheet
   def row(rownumber,sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     first_column(sheet).upto(last_column(sheet)).map do |col|
       cell(rownumber,col,sheet)
     end
@@ -268,7 +267,7 @@ class Roo::GenericSpreadsheet
       columnnumber = Roo::Excel.letter_to_number(columnnumber)
     end
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     first_row(sheet).upto(last_row(sheet)).map do |row|
       cell(row,columnnumber,sheet)
     end
@@ -278,7 +277,7 @@ class Roo::GenericSpreadsheet
   # (this will not be saved back to the spreadsheet file!)
   def set(row,col,value,sheet=nil) #:nodoc:
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     row, col = normalize(row,col)
     cell_type = case value
                 when Fixnum then :float
@@ -293,21 +292,15 @@ class Roo::GenericSpreadsheet
 
   # reopens and read a spreadsheet document
   def reload
-    # von Abfrage der Klasse direkt auf .to_s == '..' umgestellt
     ds = @default_sheet
-    if self.class.to_s == 'Google'
-      initialize(@spreadsheetkey,@user,@password)
-    else
-      initialize(@filename)
-    end
+    reinitialize
     self.default_sheet = ds
-    #@first_row = @last_row = @first_column = @last_column = nil
   end
 
   # true if cell is empty
   def empty?(row, col, sheet=nil)
     sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet] or self.class == Roo::Excel
+    read_cells(sheet)
     row,col = normalize(row,col)
     contents = cell(row, col, sheet)
     !contents || (celltype(row, col, sheet) == :string && contents.empty?) \
@@ -329,8 +322,8 @@ class Roo::GenericSpreadsheet
       else
         result << "  First row: #{first_row}\n"
         result << "  Last row: #{last_row}\n"
-        result << "  First column: #{Roo::GenericSpreadsheet.number_to_letter(first_column)}\n"
-        result << "  Last column: #{Roo::GenericSpreadsheet.number_to_letter(last_column)}"
+        result << "  First column: #{Roo::Base.number_to_letter(first_column)}\n"
+        result << "  Last column: #{Roo::Base.number_to_letter(last_column)}"
       end
       result << "\n" if sheet != sheets.last
       n += 1
@@ -370,7 +363,7 @@ class Roo::GenericSpreadsheet
     # #aa42 => #cell('aa',42)
     # #aa42('Sheet1')  => #cell('aa',42,'Sheet1')
     if m =~ /^([a-z]+)(\d)$/
-      col = Roo::GenericSpreadsheet.letter_to_number($1)
+      col = Roo::Base.letter_to_number($1)
       row = $2.to_i
       if args.empty?
         cell(row,col)
@@ -382,148 +375,120 @@ class Roo::GenericSpreadsheet
     end
   end
 
-=begin
-#TODO: hier entfernen
-  # returns each formula in the selected sheet as an array of elements
-  # [row, col, formula]
-  def formulas(sheet=nil)
-    theformulas = Array.new
-    sheet ||= @default_sheet
-    read_cells(sheet) unless @cells_read[sheet]
-    return theformulas unless first_row(sheet) # if there is no first row then
-    # there can't be formulas
-    first_row(sheet).upto(last_row(sheet)) {|row|
-      first_column(sheet).upto(last_column(sheet)) {|col|
-        if formula?(row,col,sheet)
-          theformulas << [row, col, formula(row,col,sheet)]
-        end
-      }
-    }
-    theformulas
+  # access different worksheets by calling spreadsheet.sheet(1)
+  # or spreadsheet.sheet('SHEETNAME')
+  def sheet(index,name=false)
+    @default_sheet = String === index ? index : self.sheets[index]
+    name ? [@default_sheet,self] : self
   end
-=end
-
-
-
-    # FestivalBobcats fork changes begin here
 
-
-
-    # access different worksheets by calling spreadsheet.sheet(1)
-    # or spreadsheet.sheet('SHEETNAME')
-    def sheet(index,name=false)
-      @default_sheet = String === index ? index : self.sheets[index]
-      name ? [@default_sheet,self] : self
+  # iterate through all worksheets of a document
+  def each_with_pagename
+    self.sheets.each do |s|
+      yield sheet(s,true)
     end
+  end
 
-    # iterate through all worksheets of a document
-    def each_with_pagename
-      self.sheets.each do |s|
-        yield sheet(s,true)
-      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},..]
 
-    # 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
 
-    # 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'])
 
-    # 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
 
-    # 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
 
-    # 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
+      if options[:clean]
+        options.delete(:clean)
+        @cleaned ||= {}
+        @cleaned[@default_sheet] || clean_sheet(@default_sheet)
+      end
 
-    def each(options={})
-      if options.empty?
-        1.upto(last_row) do |line|
-          yield row(line)
-        end
+      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
-        if options[:clean]
-          options.delete(:clean)
-          @cleaned ||= {}
-          @cleaned[@default_sheet] || clean_sheet(@default_sheet)
-        end
-
-        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
+        set_headers(options)
+      end
 
-        headers = @headers ||
-          Hash[(first_column..last_column).map do |col|
-            [cell(@header_line,col), col]
-          end]
+      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
+      @header_line.upto(last_row) do |line|
+        yield(Hash[headers.map {|k,v| [k,cell(line,v)]}])
       end
     end
+  end
 
-    def parse(options={})
-      ary = []
-      if block_given?
-        each(options) {|row| ary << yield(row)}
-      else
-        each(options) {|row| ary << row}
-      end
-      ary
-    end
-
-    def row_with(query,return_headers=false)
-      query.map! {|x| Array(x.split('*'))}
-      line_no = 0
-      each do |row|
-        line_no += 1
-        # makes sure headers is the first part of wildcard search for priority
-        # ex. if UPC and SKU exist for UPC*SKU search, UPC takes the cake
-        headers = query.map do |q|
-          q.map {|i| row.grep(/#{i}/i)[0]}.compact[0]
-        end.compact
-
-        if headers.length == query.length
-          @header_line = line_no
-          return return_headers ? headers : line_no
-        elsif line_no > 100
-          raise "Couldn't find header row."
-        end
+  def parse(options={})
+    ary = []
+    if block_given?
+      each(options) {|row| ary << yield(row)}
+    else
+      each(options) {|row| ary << row}
+    end
+    ary
+  end
+
+  def row_with(query,return_headers=false)
+    query.map! {|x| Array(x.split('*'))}
+    line_no = 0
+    each do |row|
+      line_no += 1
+      # makes sure headers is the first part of wildcard search for priority
+      # ex. if UPC and SKU exist for UPC*SKU search, UPC takes the cake
+      headers = query.map do |q|
+        q.map {|i| row.grep(/#{i}/i)[0]}.compact[0]
+      end.compact
+
+      if headers.length == query.length
+        @header_line = line_no
+        return return_headers ? headers : line_no
+      elsif line_no > 100
+        raise "Couldn't find header row."
       end
     end
-
-    # this method lets you find the worksheet with the most data
-    def longest_sheet
-      sheet(@workbook.worksheets.inject {|m,o|
-        o.row_count > m.row_count ? o : m
-      }.name)
-    end
+  end
 
   protected
 
+  def load_xml(path)
+    File.open(path) do |file|
+      Nokogiri::XML(file)
+    end
+  end
+
   def file_type_check(filename, ext, name, warning_level, packed=nil)
     new_expression = {
-      '.ods' => 'Roo::Openoffice.new',
+      '.ods' => 'Roo::OpenOffice.new',
       '.xls' => 'Roo::Excel.new',
       '.xlsx' => 'Roo::Excelx.new',
-      '.csv' => 'Roo::Csv.new',
+      '.csv' => 'Roo::CSV.new',
       '.xml' => 'Roo::Excel2003XML.new',
     }
     if packed == :zip
@@ -574,6 +539,10 @@ class Roo::GenericSpreadsheet
 
   private
 
+  def reinitialize
+    initialize(@filename)
+  end
+
   def make_tmpdir(tmp_root = nil)
     Dir.mktmpdir(TEMP_PREFIX, tmp_root || ENV['ROO_TMP']) do |tmpdir|
       yield tmpdir
@@ -581,7 +550,7 @@ class Roo::GenericSpreadsheet
   end
 
   def clean_sheet(sheet)
-    read_cells(sheet) unless @cells_read[sheet]
+    read_cells(sheet)
     @cell[sheet].each_pair do |coord,value|
       if String === value
         @cell[sheet][coord] = sanitize_value(value)
@@ -627,7 +596,7 @@ class Roo::GenericSpreadsheet
       end
     end
     if col.class == String
-      col = Roo::GenericSpreadsheet.letter_to_number(col)
+      col = Roo::Base.letter_to_number(col)
     end
     return row,col
   end
@@ -636,21 +605,20 @@ class Roo::GenericSpreadsheet
     filename.start_with?("http://", "https://")
   end
 
-  def open_from_uri(uri, tmpdir)
+  def download_uri(uri, tmpdir)
     require 'open-uri'
+    tempfilename = File.join(tmpdir, File.basename(uri))
     response = ''
     begin
-      open(uri, "User-Agent" => "Ruby/#{RUBY_VERSION}") { |net|
-        response = net.read
-        tempfilename = File.join(tmpdir, File.basename(uri))
-        File.open(tempfilename,"wb") do |file|
-          file.write(response)
-        end
-      }
+      File.open(tempfilename,"wb") do |file|
+        open(uri, "User-Agent" => "Ruby/#{RUBY_VERSION}") { |net|
+          file.write(net.read)
+        }
+      end
     rescue OpenURI::HTTPError
       raise "could not open #{uri}"
     end
-    File.join(tmpdir, File.basename(uri))
+    tempfilename
   end
 
   def open_from_stream(stream, tmpdir)
@@ -790,7 +758,7 @@ class Roo::GenericSpreadsheet
       when :date, :datetime
         onecell.to_s
       when :time
-        Roo::GenericSpreadsheet.integer_to_timestring(onecell)
+        Roo::Base.integer_to_timestring(onecell)
       else
         raise "unhandled celltype #{celltype(row,col,sheet)}"
       end || ""