roo 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67acb8a7cbbb8c526865f95e6b93f37313b6d373
-  data.tar.gz: 48cf05f82b1a5e64c2b2549f08afbc3544e575dc
+  metadata.gz: db86b4586034783940303cfd17a7ee5c60277a51
+  data.tar.gz: 2cf9222f2f2759f164164f745c72abe6b901df98
 SHA512:
-  metadata.gz: 0c77744d3f264952565934a3d49966bcaa80bd4f7b1a388164ded5a89873347e1f0fec00c074839a60f03982e6c37044b448568bb493a062c37c58dbf9fc5095
-  data.tar.gz: 42b35d1b9a8b55a5d10f41803cec60da00c902853ec38a5ee44bbd5ab2736f60637ef0a91a470cdbe2503a5bb06009e3c87c9f3f571eccbc3d7de4e8caf9c1c2
+  metadata.gz: 442e05a8bffdc839c45a8684e8882f4327098387617b76027b6b5c0543c2a7b4be284c511c35f8333c9bc1147e31350d1f6f67174fc62e5b7fc45520ab0ad307
+  data.tar.gz: 4ba67602e5772cae52f41ea0357ddd6835d25c35be57797307a6194a46ad977d7922b884b4fa826c91efd8533c6f3e56995e8cb0a13146a32e4a3ee7d5e42ae9

data/CHANGELOG.md

@@ -1,4 +1,19 @@
-## [2.0.0beta1] [unreleased]
+## [2.0.1] - 2015-06-01
+### Added
+- Return an enumerator when calling '#each' without a block [#219](https://github.com/roo-rb/roo/pull/219)
+- Added Roo::Base#close to delete any temp directories[#211](https://github.com/roo-rb/roo/pull/211)
+- Offset option for excelx #each_row. [#214](https://github.com/roo-rb/roo/pull/214)
+- Allow Roo::Excelx to open streams [#209](https://github.com/roo-rb/roo/pull/209)
+
+### Fixed
+- Use gsub instead of tr for double quote escaping [#212](https://github.com/roo-rb/roo/pull/212),  [#212-patch](https://github.com/roo-rb/roo/commit/fcc9a015868ebf9d42cbba5b6cfdaa58b81ecc01)
+- Fixed Changelog links and release data. [#204](https://github.com/roo-rb/roo/pull/204), [#206](https://github.com/roo-rb/roo/pull/206)
+- Allow Pathnames to be used when opening files. [#207](https://github.com/roo-rb/roo/pull/207)
+
+### Removed
+- Removed the scripts folder. [#213](https://github.com/roo-rb/roo/pull/213)
+
+## [2.0.0] - 2015-04-24
 ### Added
 - Added optional support for hidden sheets in Excelx and LibreOffice files [#177](https://github.com/roo-rb/roo/pull/177)
 - Roo::OpenOffice can be used to open encrypted workbooks. [#157](https://github.com/roo-rb/roo/pull/157)

data/lib/roo/base.rb

@@ -9,7 +9,7 @@ require 'roo/utils'
 class Roo::Base
   include Enumerable
 
-  TEMP_PREFIX = 'roo_'
+  TEMP_PREFIX = 'roo_'.freeze
   MAX_ROW_COL = 999_999.freeze
   MIN_ROW_COL = 0.freeze
 
@@ -32,6 +32,15 @@ class Roo::Base
     @last_column = {}
 
     @header_line = 1
+  rescue => e # clean up any temp files, but only if an error was raised
+    close
+    raise e
+  end
+
+  def close
+    return nil unless @tmpdirs
+    @tmpdirs.each { |dir| ::FileUtils.remove_entry(dir) }
+    nil
   end
 
   def default_sheet
@@ -343,21 +352,25 @@ class Roo::Base
   # control characters and white spaces around columns
 
   def each(options = {})
-    if options.empty?
-      1.upto(last_row) do |line|
-        yield row(line)
+    if block_given?
+      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
     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
+      to_enum(:each, options)
     end
   end
 
@@ -429,8 +442,16 @@ class Roo::Base
     "#{arr[0]},#{arr[1]}"
   end
 
+  def is_stream?(filename_or_stream)
+    filename_or_stream.respond_to?(:seek)
+  end
+
   private
 
+  def track_tmpdir!(tmpdir)
+    (@tmpdirs ||= []) << tmpdir
+  end
+
   def clean_sheet_if_need(options)
     return unless options[:clean]
     options.delete(:clean)
@@ -451,6 +472,7 @@ class Roo::Base
   end
 
   def local_filename(filename, tmpdir, packed)
+    return if is_stream?(filename)
     filename = download_uri(filename, tmpdir) if uri?(filename)
     filename = unzip(filename, tmpdir) if packed == :zip
     unless File.file?(filename)
@@ -516,7 +538,9 @@ class Roo::Base
     else
       TEMP_PREFIX
     end
-    Dir.mktmpdir(prefix, root || ENV['ROO_TMP'], &block)
+    ::Dir.mktmpdir(prefix, root || ENV['ROO_TMP'], &block).tap do |result|
+      block_given? || track_tmpdir!(result)
+    end
   end
 
   def clean_sheet(sheet)
@@ -663,9 +687,9 @@ class Roo::Base
 
       case celltype(row, col, sheet)
       when :string
-        %("#{onecell.tr('"', '""')}") unless onecell.empty?
+        %("#{onecell.gsub('"', '""')}") unless onecell.empty?
       when :boolean
-        %("#{onecell.tr('"', '""').downcase}")
+        %("#{onecell.gsub('"', '""').downcase}")
       when :float, :percentage
         if onecell == onecell.to_i
           onecell.to_i.to_s
@@ -675,7 +699,7 @@ class Roo::Base
       when :formula
         case onecell
         when String
-          %("#{onecell.tr('"', '""')}") unless onecell.empty?
+          %("#{onecell.gsub('"', '""')}") unless onecell.empty?
         when Float
           if onecell == onecell.to_i
             onecell.to_i.to_s
@@ -692,7 +716,7 @@ class Roo::Base
       when :time
         integer_to_timestring(onecell)
       when :link
-        %("#{onecell.url.tr('"', '""')}")
+        %("#{onecell.url.gsub('"', '""')}")
       else
         fail "unhandled celltype #{celltype(row, col, sheet)}"
       end || ''

data/lib/roo/excelx.rb

@@ -1,642 +1,490 @@
-require 'date'
 require 'nokogiri'
+require 'zip/filesystem'
 require 'roo/link'
 require 'roo/utils'
-require 'zip/filesystem'
 
-class Roo::Excelx < Roo::Base
-  autoload :Workbook, 'roo/excelx/workbook'
-  autoload :SharedStrings, 'roo/excelx/shared_strings'
-  autoload :Styles, 'roo/excelx/styles'
-
-  autoload :Relationships, 'roo/excelx/relationships'
-  autoload :Comments, 'roo/excelx/comments'
-  autoload :SheetDoc, 'roo/excelx/sheet_doc'
-
-  module Format
-    EXCEPTIONAL_FORMATS = {
-      'h:mm am/pm' => :date,
-      'h:mm:ss am/pm' => :date,
-    }
-
-    STANDARD_FORMATS = {
-      0 => 'General',
-      1 => '0',
-      2 => '0.00',
-      3 => '#,##0',
-      4 => '#,##0.00',
-      9 => '0%',
-      10 => '0.00%',
-      11 => '0.00E+00',
-      12 => '# ?/?',
-      13 => '# ??/??',
-      14 => 'mm-dd-yy',
-      15 => 'd-mmm-yy',
-      16 => 'd-mmm',
-      17 => 'mmm-yy',
-      18 => 'h:mm AM/PM',
-      19 => 'h:mm:ss AM/PM',
-      20 => 'h:mm',
-      21 => 'h:mm:ss',
-      22 => 'm/d/yy h:mm',
-      37 => '#,##0 ;(#,##0)',
-      38 => '#,##0 ;[Red](#,##0)',
-      39 => '#,##0.00;(#,##0.00)',
-      40 => '#,##0.00;[Red](#,##0.00)',
-      45 => 'mm:ss',
-      46 => '[h]:mm:ss',
-      47 => 'mmss.0',
-      48 => '##0.0E+0',
-      49 => '@',
-    }
-
-    def to_type(format)
-      format = format.to_s.downcase
-      if type = EXCEPTIONAL_FORMATS[format]
-        type
-      elsif format.include?('#')
-        :float
-      elsif !format.match(/d+(?![\]])/).nil? || format.include?('y')
-        if format.include?('h') || format.include?('s')
-          :datetime
+module Roo
+  class Excelx < Roo::Base
+    require 'roo/excelx/workbook'
+    require 'roo/excelx/shared_strings'
+    require 'roo/excelx/styles'
+    require 'roo/excelx/cell'
+    require 'roo/excelx/sheet'
+    require 'roo/excelx/relationships'
+    require 'roo/excelx/comments'
+    require 'roo/excelx/sheet_doc'
+    
+    module Format
+      EXCEPTIONAL_FORMATS = {
+        'h:mm am/pm' => :date,
+        'h:mm:ss am/pm' => :date
+      }
+
+      STANDARD_FORMATS = {
+        0 => 'General'.freeze,
+        1 => '0'.freeze,
+        2 => '0.00'.freeze,
+        3 => '#,##0'.freeze,
+        4 => '#,##0.00'.freeze,
+        9 => '0%'.freeze,
+        10 => '0.00%'.freeze,
+        11 => '0.00E+00'.freeze,
+        12 => '# ?/?'.freeze,
+        13 => '# ??/??'.freeze,
+        14 => 'mm-dd-yy'.freeze,
+        15 => 'd-mmm-yy'.freeze,
+        16 => 'd-mmm'.freeze,
+        17 => 'mmm-yy'.freeze,
+        18 => 'h:mm AM/PM'.freeze,
+        19 => 'h:mm:ss AM/PM'.freeze,
+        20 => 'h:mm'.freeze,
+        21 => 'h:mm:ss'.freeze,
+        22 => 'm/d/yy h:mm'.freeze,
+        37 => '#,##0 ;(#,##0)'.freeze,
+        38 => '#,##0 ;[Red](#,##0)'.freeze,
+        39 => '#,##0.00;(#,##0.00)'.freeze,
+        40 => '#,##0.00;[Red](#,##0.00)'.freeze,
+        45 => 'mm:ss'.freeze,
+        46 => '[h]:mm:ss'.freeze,
+        47 => 'mmss.0'.freeze,
+        48 => '##0.0E+0'.freeze,
+        49 => '@'.freeze
+      }
+
+      def to_type(format)
+        format = format.to_s.downcase
+        if (type = EXCEPTIONAL_FORMATS[format])
+          type
+        elsif format.include?('#')
+          :float
+        elsif !format.match(/d+(?![\]])/).nil? || format.include?('y')
+          if format.include?('h') || format.include?('s')
+            :datetime
+          else
+            :date
+          end
+        elsif format.include?('h') || format.include?('s')
+          :time
+        elsif format.include?('%')
+          :percentage
         else
-          :date
+          :float
         end
-      elsif format.include?('h') || format.include?('s')
-        :time
-      elsif format.include?('%')
-        :percentage
-      else
-        :float
       end
+
+      module_function :to_type
     end
 
-    module_function :to_type
-  end
+    ExceedsMaxError = Class.new(StandardError)
 
-  class Cell
-    attr_reader :type, :formula, :value, :excelx_type, :excelx_value, :style, :hyperlink, :coordinate
-    attr_writer :value
-
-    def initialize(value, type, formula, excelx_type, excelx_value, style, hyperlink, base_date, coordinate)
-      @type = type
-      @formula = formula
-      @base_date = base_date if [:date, :datetime].include?(@type)
-      @excelx_type = excelx_type
-      @excelx_value = excelx_value
-      @style = style
-      @value = type_cast_value(value)
-      @value = Roo::Link.new(hyperlink, @value.to_s) if hyperlink
-      @coordinate = coordinate
-    end
-
-    def type
-      if @formula
-        :formula
-      elsif @value.is_a?(Roo::Link)
-        :link
-      else
-        @type
+    # initialization and opening of a spreadsheet file
+    # values for packed: :zip
+    # optional cell_max (int) parameter for early aborting attempts to parse
+    # enormous documents.
+    def initialize(filename_or_stream, options = {})
+      packed = options[:packed]
+      file_warning = options.fetch(:file_warning, :error)
+      cell_max = options.delete(:cell_max)
+      sheet_options = {}
+      sheet_options[:expand_merged_ranges] = (options[:expand_merged_ranges] || false)
+
+      unless is_stream?(filename_or_stream)
+        file_type_check(filename_or_stream, '.xlsx', 'an Excel-xlsx', file_warning, packed)
+        basename = File.basename(filename_or_stream)
       end
-    end
 
-    class Coordinate
-      attr_accessor :row, :column
+      @tmpdir = make_tmpdir(basename, options[:tmpdir_root])
+      @filename = local_filename(filename_or_stream, @tmpdir, packed)
+      @comments_files = []
+      @rels_files = []
+      process_zipfile(@filename || filename_or_stream)
 
-      def initialize(row, column)
-        @row, @column = row, column
+      @sheet_names = workbook.sheets.map do |sheet|
+        unless options[:only_visible_sheets] && sheet['state'] == 'hidden'
+          sheet['name']
+        end
+      end.compact
+      @sheets = []
+      @sheets_by_name = Hash[@sheet_names.map.with_index do |sheet_name, n|
+        @sheets[n] = Sheet.new(sheet_name, @rels_files[n], @sheet_files[n], @comments_files[n], styles, shared_strings, workbook, sheet_options)
+        [sheet_name, @sheets[n]]
+      end]
+
+      if cell_max
+        cell_count = ::Roo::Utils.num_cells_in_range(sheet_for(options.delete(:sheet)).dimensions)
+        raise ExceedsMaxError.new("Excel file exceeds cell maximum: #{cell_count} > #{cell_max}") if cell_count > cell_max
       end
-    end
 
-    private
+      super
+    rescue => e # clean up any temp files, but only if an error was raised
+      close
+      raise e
+    end
 
-    def type_cast_value(value)
-      case @type
-      when :float, :percentage
-        value.to_f
-      when :date
-        yyyy,mm,dd = (@base_date+value.to_i).strftime("%Y-%m-%d").split('-')
-        Date.new(yyyy.to_i,mm.to_i,dd.to_i)
-      when :datetime
-        create_datetime_from((@base_date+value.to_f.round(6)).strftime("%Y-%m-%d %H:%M:%S.%N"))
-      when :time
-        value.to_f*(24*60*60)
-      when :string
-        value
+    def method_missing(method, *args)
+      if (label = workbook.defined_names[method.to_s])
+        safe_send(sheet_for(label.sheet).cells[label.key], :value)
       else
-        value
+        # call super for methods like #a1
+        super
       end
     end
 
-    def create_datetime_from(datetime_string)
-      date_part,time_part = round_time_from(datetime_string).split(' ')
-      yyyy,mm,dd = date_part.split('-')
-      hh,mi,ss = time_part.split(':')
-      DateTime.civil(yyyy.to_i,mm.to_i,dd.to_i,hh.to_i,mi.to_i,ss.to_i)
-    end
-
-    def round_time_from(datetime_string)
-      date_part,time_part = datetime_string.split(' ')
-      yyyy,mm,dd = date_part.split('-')
-      hh,mi,ss = time_part.split(':')
-      Time.new(yyyy.to_i, mm.to_i, dd.to_i, hh.to_i, mi.to_i, ss.to_r).round(0).strftime("%Y-%m-%d %H:%M:%S")
+    def sheets
+      @sheet_names
     end
-  end
 
-  class Sheet
-    def initialize(name, rels_path, sheet_path, comments_path, styles, shared_strings, workbook, options = {})
-      @name = name
-      @rels = Relationships.new(rels_path)
-      @comments = Comments.new(comments_path)
-      @styles = styles
-      @sheet = SheetDoc.new(sheet_path, @rels, @styles, shared_strings, workbook, options)
+    def sheet_for(sheet)
+      sheet ||= default_sheet
+      validate_sheet!(sheet)
+      @sheets_by_name[sheet]
     end
 
-    def cells
-      @cells ||= @sheet.cells(@rels)
+    # Returns the content of a spreadsheet-cell.
+    # (1,1) is the upper left corner.
+    # (1,1), (1,'A'), ('A',1), ('a',1) all refers to the
+    # cell at the first line and first row.
+    def cell(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :value)
     end
 
-    def present_cells
-      @present_cells ||= cells.select {|key, cell| cell && cell.value }
+    def row(rownumber, sheet = nil)
+      sheet_for(sheet).row(rownumber)
     end
 
-    # Yield each row as array of Excelx::Cell objects
-    # accepts options max_rows (int) (offset by 1 for header)
-    # and pad_cells (boolean)
-    def each_row(options = {}, &block)
-      row_count = 0
-      @sheet.each_row_streaming do |row|
-        break if options[:max_rows] && row_count == options[:max_rows] + 1
-        block.call(cells_for_row_element(row, options)) if block_given?
-        row_count += 1
+    # returns all values in this column as an array
+    # column numbers are 1,2,3,... like in the spreadsheet
+    def column(column_number, sheet = nil)
+      if column_number.is_a?(::String)
+        column_number = ::Roo::Utils.letter_to_number(column_number)
       end
-    end
-
-    def row(row_number)
-      first_column.upto(last_column).map do |col|
-        cells[[row_number,col]]
-      end.map {|cell| cell && cell.value }
-    end
-
-    def column(col_number)
-      first_row.upto(last_row).map do |row|
-        cells[[row,col_number]]
-      end.map {|cell| cell && cell.value }
+      sheet_for(sheet).column(column_number)
     end
 
     # returns the number of the first non-empty row
-    def first_row
-      @first_row ||= present_cells.keys.map {|row, _| row }.min
+    def first_row(sheet = nil)
+      sheet_for(sheet).first_row
     end
 
-    def last_row
-      @last_row ||= present_cells.keys.map {|row, _| row }.max
+    # returns the number of the last non-empty row
+    def last_row(sheet = nil)
+      sheet_for(sheet).last_row
     end
 
     # returns the number of the first non-empty column
-    def first_column
-      @first_column ||= present_cells.keys.map {|_, col| col }.min
+    def first_column(sheet = nil)
+      sheet_for(sheet).first_column
     end
 
     # returns the number of the last non-empty column
-    def last_column
-      @last_column ||= present_cells.keys.map {|_, col| col }.max
+    def last_column(sheet = nil)
+      sheet_for(sheet).last_column
     end
 
-    def excelx_format(key)
-      cell = cells[key]
-      @styles.style_format(cell.style).to_s if cell
+    # set a cell to a certain value
+    # (this will not be saved back to the spreadsheet file!)
+    def set(row, col, value, sheet = nil) #:nodoc:
+      key = normalize(row, col)
+      cell_type = cell_type_by_value(value)
+      sheet_for(sheet).cells[key] = Cell.new(value, cell_type, nil, cell_type, value, nil, nil, nil, Cell::Coordinate.new(row, col))
     end
 
-    def hyperlinks
-      @hyperlinks ||= @sheet.hyperlinks(@rels)
+    # Returns the formula at (row,col).
+    # Returns nil if there is no formula.
+    # The method #formula? checks if there is a formula.
+    def formula(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :formula)
     end
 
-    def comments
-      @comments.comments
+    # Predicate methods really should return a boolean
+    # value. Hopefully no one was relying on the fact that this
+    # previously returned either nil/formula
+    def formula?(*args)
+      !!formula(*args)
     end
 
-    def dimensions
-      @sheet.dimensions
-    end
-
-    private
-
-    # Take an xml row and return an array of Excelx::Cell objects
-    # optionally pad array to header width(assumed 1st row).
-    # takes option pad_cells (boolean) defaults false
-    def cells_for_row_element(row_element, options = {})
-      return [] unless row_element
-      cell_col = 0
-      cells = []
-      @sheet.each_cell(row_element) do |cell|
-        cells.concat(pad_cells(cell, cell_col)) if options[:pad_cells]
-        cells << cell
-        cell_col = cell.coordinate.column
+    # returns each formula in the selected sheet as an array of tuples in following format
+    # [[row, col, formula], [row, col, formula],...]
+    def formulas(sheet = nil)
+      sheet_for(sheet).cells.select { |_, cell| cell.formula }.map do |(x, y), cell|
+        [x, y, cell.formula]
       end
-      cells
     end
 
-    def pad_cells(cell, last_column)
-      pad = []
-      (cell.coordinate.column - 1 - last_column).times { pad << nil }
-      pad
+    # Given a cell, return the cell's style
+    def font(row, col, sheet = nil)
+      key = normalize(row, col)
+      definition_index = safe_send(sheet_for(sheet).cells[key], :style)
+      styles.definitions[definition_index] if definition_index
     end
-  end
-
-  ExceedsMaxError = Class.new(StandardError)
-
-  # initialization and opening of a spreadsheet file
-  # values for packed: :zip
-  # optional cell_max (int) parameter for early aborting attempts to parse
-  # enormous documents.
-  def initialize(filename, options = {})
-    packed = options[:packed]
-    file_warning = options.fetch(:file_warning, :error)
-    cell_max = options.delete(:cell_max)
-    sheet_options = {}
-    sheet_options[:expand_merged_ranges] = (options[:expand_merged_ranges] || false)
-
-    file_type_check(filename,'.xlsx','an Excel-xlsx', file_warning, packed)
-
-    @tmpdir = make_tmpdir(filename.split('/').last, options[:tmpdir_root])
-    @filename = local_filename(filename, @tmpdir, packed)
-    @comments_files = []
-    @rels_files = []
-    process_zipfile(@tmpdir, @filename)
-
-    @sheet_names = workbook.sheets.map do |sheet|
-      unless options[:only_visible_sheets] && sheet['state'] == 'hidden'
-        sheet['name']
-      end
-    end.compact
-    @sheets = []
-    @sheets_by_name = Hash[@sheet_names.map.with_index do |sheet_name, n|
-      @sheets[n] = Sheet.new(sheet_name, @rels_files[n], @sheet_files[n], @comments_files[n], styles, shared_strings, workbook, sheet_options)
-      [sheet_name, @sheets[n]]
-    end]
 
-    if cell_max
-      cell_count = ::Roo::Utils.num_cells_in_range(sheet_for(options.delete(:sheet)).dimensions)
-      raise ExceedsMaxError.new("Excel file exceeds cell maximum: #{cell_count} > #{cell_max}") if cell_count > cell_max
+    # returns the type of a cell:
+    # * :float
+    # * :string,
+    # * :date
+    # * :percentage
+    # * :formula
+    # * :time
+    # * :datetime
+    def celltype(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :type)
     end
 
-    super
-  end
-
-  def method_missing(method,*args)
-    if label = workbook.defined_names[method.to_s]
-      safe_send(sheet_for(label.sheet).cells[label.key], :value)
-    else
-      # call super for methods like #a1
-      super
+    # returns the internal type of an excel cell
+    # * :numeric_or_formula
+    # * :string
+    # Note: this is only available within the Excelx class
+    def excelx_type(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :excelx_type)
     end
-  end
 
-  def sheets
-    @sheet_names
-  end
-
-  def sheet_for(sheet)
-    sheet ||= default_sheet
-    validate_sheet!(sheet)
-    @sheets_by_name[sheet]
-  end
-
-  # Returns the content of a spreadsheet-cell.
-  # (1,1) is the upper left corner.
-  # (1,1), (1,'A'), ('A',1), ('a',1) all refers to the
-  # cell at the first line and first row.
-  def cell(row, col, sheet=nil)
-    key = normalize(row,col)
-    safe_send(sheet_for(sheet).cells[key], :value)
-  end
-
-  def row(rownumber,sheet=nil)
-    sheet_for(sheet).row(rownumber)
-  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=nil)
-    if column_number.is_a?(::String)
-      column_number = ::Roo::Utils.letter_to_number(column_number)
+    # returns the internal value of an excelx cell
+    # Note: this is only available within the Excelx class
+    def excelx_value(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :excelx_value)
     end
-    sheet_for(sheet).column(column_number)
-  end
-
-  # returns the number of the first non-empty row
-  def first_row(sheet=nil)
-    sheet_for(sheet).first_row
-  end
-
-  # returns the number of the last non-empty row
-  def last_row(sheet=nil)
-    sheet_for(sheet).last_row
-  end
-
-  # returns the number of the first non-empty column
-  def first_column(sheet=nil)
-    sheet_for(sheet).first_column
-  end
 
-  # returns the number of the last non-empty column
-  def last_column(sheet=nil)
-    sheet_for(sheet).last_column
-  end
-
-  # set a cell to a certain value
-  # (this will not be saved back to the spreadsheet file!)
-  def set(row,col,value, sheet = nil) #:nodoc:
-    key = normalize(row,col)
-    cell_type = cell_type_by_value(value)
-    sheet_for(sheet).cells[key] = Cell.new(value, cell_type, nil, cell_type, value, nil, nil, nil, Cell::Coordinate.new(row, col))
-  end
-
-
-  # Returns the formula at (row,col).
-  # Returns nil if there is no formula.
-  # The method #formula? checks if there is a formula.
-  def formula(row,col,sheet=nil)
-    key = normalize(row,col)
-    safe_send(sheet_for(sheet).cells[key], :formula)
-  end
-
-  # Predicate methods really should return a boolean
-  # value. Hopefully no one was relying on the fact that this
-  # previously returned either nil/formula
-  def formula?(*args)
-    !!formula(*args)
-  end
-
-  # returns each formula in the selected sheet as an array of tuples in following format
-  # [[row, col, formula], [row, col, formula],...]
-  def formulas(sheet=nil)
-    sheet_for(sheet).cells.select {|_, cell| cell.formula }.map do |(x, y), cell|
-      [x, y, cell.formula]
+    # returns the internal format of an excel cell
+    def excelx_format(row, col, sheet = nil)
+      key = normalize(row, col)
+      sheet_for(sheet).excelx_format(key)
     end
-  end
-
-  # Given a cell, return the cell's style
-  def font(row, col, sheet=nil)
-    key = normalize(row,col)
-    definition_index = safe_send(sheet_for(sheet).cells[key], :style)
-    styles.definitions[definition_index] if definition_index
-  end
-
-  # returns the type of a cell:
-  # * :float
-  # * :string,
-  # * :date
-  # * :percentage
-  # * :formula
-  # * :time
-  # * :datetime
-  def celltype(row,col,sheet=nil)
-    key = normalize(row, col)
-    safe_send(sheet_for(sheet).cells[key], :type)
-  end
-
-  # returns the internal type of an excel cell
-  # * :numeric_or_formula
-  # * :string
-  # Note: this is only available within the Excelx class
-  def excelx_type(row,col,sheet=nil)
-    key = normalize(row,col)
-    safe_send(sheet_for(sheet).cells[key], :excelx_type)
-  end
 
-  # returns the internal value of an excelx cell
-  # Note: this is only available within the Excelx class
-  def excelx_value(row,col,sheet=nil)
-    key = normalize(row,col)
-    safe_send(sheet_for(sheet).cells[key], :excelx_value)
-  end
+    def empty?(row, col, sheet = nil)
+      sheet = sheet_for(sheet)
+      key = normalize(row, col)
+      cell = sheet.cells[key]
+      !cell || !cell.value || (cell.type == :string && cell.value.empty?) \
+      || (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
+    end
 
-  # returns the internal format of an excel cell
-  def excelx_format(row,col,sheet=nil)
-    key = normalize(row,col)
-    sheet_for(sheet).excelx_format(key)
-  end
+    # shows the internal representation of all cells
+    # for debugging purposes
+    def to_s(sheet = nil)
+      sheet_for(sheet).cells.inspect
+    end
 
-  def empty?(row,col,sheet=nil)
-    sheet = sheet_for(sheet)
-    key = normalize(row,col)
-    cell = sheet.cells[key]
-    !cell || !cell.value || (cell.type == :string && cell.value.empty?) \
-      || (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
-  end
+    # returns the row,col values of the labelled cell
+    # (nil,nil) if label is not defined
+    def label(name)
+      labels = workbook.defined_names
+      return [nil, nil, nil] if labels.empty? || !labels.key?(name)
 
-  # shows the internal representation of all cells
-  # for debugging purposes
-  def to_s(sheet=nil)
-    sheet_for(sheet).cells.inspect
-  end
+      [labels[name].row, labels[name].col, labels[name].sheet]
+    end
 
-  # returns the row,col values of the labelled cell
-  # (nil,nil) if label is not defined
-  def label(name)
-    labels = workbook.defined_names
-    if labels.empty? || !labels.key?(name)
-      [nil,nil,nil]
-    else
-      [labels[name].row,
-        labels[name].col,
-        labels[name].sheet]
+    # Returns an array which all labels. Each element is an array with
+    # [labelname, [row,col,sheetname]]
+    def labels
+      @labels ||= workbook.defined_names.map do |name, label|
+        [
+          name,
+          [label.row, label.col, label.sheet]
+        ]
+      end
     end
-  end
 
-  # Returns an array which all labels. Each element is an array with
-  # [labelname, [row,col,sheetname]]
-  def labels
-    @labels ||= workbook.defined_names.map do |name, label|
-      [ name,
-        [ label.row,
-          label.col,
-          label.sheet,
-        ] ]
+    def hyperlink?(row, col, sheet = nil)
+      !!hyperlink(row, col, sheet)
     end
-  end
 
-  def hyperlink?(row,col,sheet=nil)
-    !!hyperlink(row, col, sheet)
-  end
+    # returns the hyperlink at (row/col)
+    # nil if there is no hyperlink
+    def hyperlink(row, col, sheet = nil)
+      key = normalize(row, col)
+      sheet_for(sheet).hyperlinks[key]
+    end
 
-  # returns the hyperlink at (row/col)
-  # nil if there is no hyperlink
-  def hyperlink(row,col,sheet=nil)
-    key = normalize(row,col)
-    sheet_for(sheet).hyperlinks[key]
-  end
+    # returns the comment at (row/col)
+    # nil if there is no comment
+    def comment(row, col, sheet = nil)
+      key = normalize(row, col)
+      sheet_for(sheet).comments[key]
+    end
 
-  # returns the comment at (row/col)
-  # nil if there is no comment
-  def comment(row,col,sheet=nil)
-    key = normalize(row,col)
-    sheet_for(sheet).comments[key]
-  end
+    # true, if there is a comment
+    def comment?(row, col, sheet = nil)
+      !!comment(row, col, sheet)
+    end
 
-  # true, if there is a comment
-  def comment?(row,col,sheet=nil)
-    !!comment(row,col,sheet)
-  end
+    def comments(sheet = nil)
+      sheet_for(sheet).comments.map do |(x, y), comment|
+        [x, y, comment]
+      end
+    end
 
-  def comments(sheet=nil)
-    sheet_for(sheet).comments.map do |(x, y), comment|
-      [x, y, comment]
+    # Yield an array of Excelx::Cell
+    # Takes options for sheet, pad_cells, and max_rows
+    def each_row_streaming(options = {})
+      sheet_for(options.delete(:sheet)).each_row(options) { |row| yield row }
     end
-  end
 
-  # Yield an array of Excelx::Cell
-  # Takes options for sheet, pad_cells, and max_rows
-  def each_row_streaming(options={})
-    sheet_for(options.delete(:sheet)).each_row(options) { |row| yield row }
-  end
+    private
 
-  private
+    def clean_sheet(sheet)
+      @sheets_by_name[sheet].cells.each_pair do |coord, value|
+        next unless value.value.is_a?(::String)
 
-  def clean_sheet(sheet)
-    @sheets_by_name[sheet].cells.each_pair do |coord, value|
-      next unless value.value.is_a?(::String)
+        @sheets_by_name[sheet].cells[coord].value = sanitize_value(value.value)
+      end
 
-      @sheets_by_name[sheet].cells[coord].value = sanitize_value(value.value)
+      @cleaned[sheet] = true
     end
 
-    @cleaned[sheet] = true
-  end
-
-  # Internal: extracts the worksheet_ids from the workbook.xml file. xlsx
-  #           documents require a workbook.xml file, so a if the file is missing
-  #           it is not a valid xlsx file. In these cases, an ArgumentError is
-  #           raised.
-  #
-  # wb - a Zip::Entry for the workbook.xml file.
-  # path - A String for Zip::Entry's destination path.
-  #
-  # Examples
-  #
-  #   extract_worksheet_ids(<Zip::Entry>, 'tmpdir/roo_workbook.xml')
-  #   # => ["rId1", "rId2", "rId3"]
-  #
-  # Returns an Array of Strings.
-  def extract_worksheet_ids(entries, path)
+    # Internal: extracts the worksheet_ids from the workbook.xml file. xlsx
+    #           documents require a workbook.xml file, so a if the file is missing
+    #           it is not a valid xlsx file. In these cases, an ArgumentError is
+    #           raised.
+    #
+    # wb - a Zip::Entry for the workbook.xml file.
+    # path - A String for Zip::Entry's destination path.
+    #
+    # Examples
+    #
+    #   extract_worksheet_ids(<Zip::Entry>, 'tmpdir/roo_workbook.xml')
+    #   # => ["rId1", "rId2", "rId3"]
+    #
+    # Returns an Array of Strings.
+    def extract_worksheet_ids(entries, path)
       wb = entries.find { |e| e.name[/workbook.xml$/] }
       fail ArgumentError 'missing required workbook file' if wb.nil?
 
       wb.extract(path)
       workbook_doc = Roo::Utils.load_xml(path).remove_namespaces!
-      workbook_doc.xpath('//sheet').map{ |s| s.attributes['id'].value }
-  end
+      workbook_doc.xpath('//sheet').map { |s| s.attributes['id'].value }
+    end
+
+    # Internal
+    #
+    # wb_rels - A Zip::Entry for the workbook.xml.rels file.
+    # path - A String for the Zip::Entry's destination path.
+    #
+    # Examples
+    #
+    #   extract_worksheets(<Zip::Entry>, 'tmpdir/roo_workbook.xml.rels')
+    #   # => {
+    #         "rId1"=>"worksheets/sheet1.xml",
+    #         "rId2"=>"worksheets/sheet2.xml",
+    #         "rId3"=>"worksheets/sheet3.xml"
+    #        }
+    #
+    # Returns a Hash.
+    def extract_worksheet_rels(entries, path)
+      wb_rels = entries.find { |e| e.name[/workbook.xml.rels$/] }
+      fail ArgumentError 'missing required workbook file' if wb_rels.nil?
+
+      wb_rels.extract(path)
+      rels_doc = Roo::Utils.load_xml(path).remove_namespaces!
+      worksheet_type = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet'
 
-  # Internal
-  #
-  # wb_rels - A Zip::Entry for the workbook.xml.rels file.
-  # path - A String for the Zip::Entry's destination path.
-  #
-  # Examples
-  #
-  #   extract_worksheets(<Zip::Entry>, 'tmpdir/roo_workbook.xml.rels')
-  #   # => {
-  #         "rId1"=>"worksheets/sheet1.xml",
-  #         "rId2"=>"worksheets/sheet2.xml",
-  #         "rId3"=>"worksheets/sheet3.xml"
-  #        }
-  #
-  # Returns a Hash.
-  def extract_worksheet_rels(entries, path)
-    wb_rels = entries.find { |e| e.name[/workbook.xml.rels$/] }
-    fail ArgumentError 'missing required workbook file' if wb_rels.nil?
-
-    wb_rels.extract(path)
-    rels_doc = Roo::Utils.load_xml(path).remove_namespaces!
-    worksheet_type ='http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet'
-
-    relationships = rels_doc.xpath('//Relationship').select do |relationship|
-      relationship.attributes['Type'].value == worksheet_type
-    end
-
-    relationships.inject({}) do |hash, relationship|
-      attributes = relationship.attributes
-      id = attributes['Id'];
-      hash[id.value] = attributes['Target'].value
-      hash
+      relationships = rels_doc.xpath('//Relationship').select do |relationship|
+        relationship.attributes['Type'].value == worksheet_type
+      end
+
+      relationships.inject({}) do |hash, relationship|
+        attributes = relationship.attributes
+        id = attributes['Id']
+        hash[id.value] = attributes['Target'].value
+        hash
+      end
     end
-  end
 
-  def extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
-    sheet_ids.each_with_index do |id, i|
-      name = sheets[id]
-      entry = entries.find { |entry| entry.name =~ /#{name}$/ }
-      path = "#{tmpdir}/roo_sheet#{i + 1}"
-      @sheet_files << path
-      entry.extract(path)
+    def extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
+      sheet_ids.each_with_index do |id, i|
+        name = sheets[id]
+        entry = entries.find { |e| e.name =~ /#{name}$/ }
+        path = "#{tmpdir}/roo_sheet#{i + 1}"
+        @sheet_files << path
+        entry.extract(path)
+      end
     end
-  end
 
-  # Extracts all needed files from the zip file
-  def process_zipfile(tmpdir, zipfilename)
-    @sheet_files = []
-    entries = Zip::File.open(zipfilename).to_a.sort_by(&:name)
+    # Extracts all needed files from the zip file
+    def process_zipfile(zipfilename_or_stream)
+      @sheet_files = []
 
-    # NOTE: When Google or Numbers 3.1 exports to xlsx, the worksheet filenames
-    #       are not in order. With Numbers 3.1, the first sheet is always
-    #       sheet.xml, not sheet1.xml. With Google, the order of the worksheets is
-    #       independent of a worksheet's filename (i.e. sheet6.xml can be the
-    #       first worksheet).
-    #
-    #       workbook.xml lists the correct order of worksheets and
-    #       workbook.xml.rels lists the filenames for those worksheets.
-    #
-    #       workbook.xml:
-    #         <sheet state="visible" name="IS" sheetId="1" r:id="rId3"/>
-    #         <sheet state="visible" name="BS" sheetId="2" r:id="rId4"/>
-    #       workbook.xml.rel:
-    #         <Relationship Id="rId4" Target="worksheets/sheet5.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
-    #         <Relationship Id="rId3" Target="worksheets/sheet4.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
-    sheet_ids = extract_worksheet_ids(entries, "#{tmpdir}/roo_workbook.xml")
-    sheets = extract_worksheet_rels(entries, "#{tmpdir}/roo_workbook.xml.rels")
-    extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
-
-    entries.each do |entry|
-      path =
-      case entry.name.downcase
-      when /sharedstrings.xml$/
-        "#{tmpdir}/roo_sharedStrings.xml"
-      when /styles.xml$/
-        "#{tmpdir}/roo_styles.xml"
-      when /comments([0-9]+).xml$/
-        # FIXME: Most of the time, The order of the comment files are the same
-        #       the sheet order, i.e. sheet1.xml's comments are in comments1.xml.
-        #       In some situations, this isn't true. The true location of a
-        #       sheet's comment file is in the sheet1.xml.rels file. SEE
-        #       ECMA-376 12.3.3 in "Ecma Office Open XML Part 1".
-        nr = Regexp.last_match[1].to_i
-        @comments_files[nr - 1] = "#{tmpdir}/roo_comments#{nr}"
-      when /sheet([0-9]+).xml.rels$/
-        # FIXME: Roo seems to use sheet[\d].xml.rels for hyperlinks only, but
-        #        it also stores the location for sharedStrings, comments,
-        #        drawings, etc.
-        nr = Regexp.last_match[1].to_i
-        @rels_files[nr - 1] = "#{tmpdir}/roo_rels#{nr}"
+      unless is_stream?(zipfilename_or_stream)
+        process_zipfile_entries Zip::File.open(zipfilename_or_stream).to_a.sort_by(&:name)
+      else
+        stream = Zip::InputStream.open zipfilename_or_stream
+        begin
+          entries = []
+          while (entry = stream.get_next_entry)
+            entries << entry
+          end
+          process_zipfile_entries entries
+        ensure
+          stream.close
+        end
       end
+    end
 
-      entry.extract(path) if path
+    def process_zipfile_entries(entries)
+      # NOTE: When Google or Numbers 3.1 exports to xlsx, the worksheet filenames
+      #       are not in order. With Numbers 3.1, the first sheet is always
+      #       sheet.xml, not sheet1.xml. With Google, the order of the worksheets is
+      #       independent of a worksheet's filename (i.e. sheet6.xml can be the
+      #       first worksheet).
+      #
+      #       workbook.xml lists the correct order of worksheets and
+      #       workbook.xml.rels lists the filenames for those worksheets.
+      #
+      #       workbook.xml:
+      #         <sheet state="visible" name="IS" sheetId="1" r:id="rId3"/>
+      #         <sheet state="visible" name="BS" sheetId="2" r:id="rId4"/>
+      #       workbook.xml.rel:
+      #         <Relationship Id="rId4" Target="worksheets/sheet5.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
+      #         <Relationship Id="rId3" Target="worksheets/sheet4.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
+      sheet_ids = extract_worksheet_ids(entries, "#{@tmpdir}/roo_workbook.xml")
+      sheets = extract_worksheet_rels(entries, "#{@tmpdir}/roo_workbook.xml.rels")
+      extract_sheets_in_order(entries, sheet_ids, sheets, @tmpdir)
+
+      entries.each do |entry|
+        path =
+        case entry.name.downcase
+        when /sharedstrings.xml$/
+          "#{@tmpdir}/roo_sharedStrings.xml"
+        when /styles.xml$/
+          "#{@tmpdir}/roo_styles.xml"
+        when /comments([0-9]+).xml$/
+          # FIXME: Most of the time, The order of the comment files are the same
+          #       the sheet order, i.e. sheet1.xml's comments are in comments1.xml.
+          #       In some situations, this isn't true. The true location of a
+          #       sheet's comment file is in the sheet1.xml.rels file. SEE
+          #       ECMA-376 12.3.3 in "Ecma Office Open XML Part 1".
+          nr = Regexp.last_match[1].to_i
+          @comments_files[nr - 1] = "#{@tmpdir}/roo_comments#{nr}"
+        when /sheet([0-9]+).xml.rels$/
+          # FIXME: Roo seems to use sheet[\d].xml.rels for hyperlinks only, but
+          #        it also stores the location for sharedStrings, comments,
+          #        drawings, etc.
+          nr = Regexp.last_match[1].to_i
+          @rels_files[nr - 1] = "#{@tmpdir}/roo_rels#{nr}"
+        end
+
+        entry.extract(path) if path
+      end
     end
-  end
 
-  def styles
-    @styles ||= Styles.new(File.join(@tmpdir, 'roo_styles.xml'))
-  end
+    def styles
+      @styles ||= Styles.new(File.join(@tmpdir, 'roo_styles.xml'))
+    end
 
-  def shared_strings
-    @shared_strings ||= SharedStrings.new(File.join(@tmpdir, 'roo_sharedStrings.xml'))
-  end
+    def shared_strings
+      @shared_strings ||= SharedStrings.new(File.join(@tmpdir, 'roo_sharedStrings.xml'))
+    end
 
-  def workbook
-    @workbook ||= Workbook.new(File.join(@tmpdir, "roo_workbook.xml"))
-  end
+    def workbook
+      @workbook ||= Workbook.new(File.join(@tmpdir, 'roo_workbook.xml'))
+    end
 
-  def safe_send(object, method, *args)
-    object.send(method, *args) if object && object.respond_to?(method)
+    def safe_send(object, method, *args)
+      object.send(method, *args) if object && object.respond_to?(method)
+    end
   end
 end