roo 2.0.1 → 2.7.1

data/lib/roo/excelx/styles.rb

@@ -51,7 +51,7 @@ module Roo
           xfs.children.map do |xf|
             xf['numFmtId']
           end
-        end
+        end.compact
       end
 
       def extract_num_fmts

data/lib/roo/excelx.rb

@@ -1,10 +1,19 @@
 require 'nokogiri'
 require 'zip/filesystem'
 require 'roo/link'
+require 'roo/tempdir'
 require 'roo/utils'
+require 'forwardable'
+require 'set'
 
 module Roo
   class Excelx < Roo::Base
+    extend Roo::Tempdir
+    extend Forwardable
+
+    ERROR_VALUES = %w(#N/A #REF! #NAME? #DIV/0! #NULL! #VALUE! #NUM!).to_set
+
+    require 'roo/excelx/shared'
     require 'roo/excelx/workbook'
     require 'roo/excelx/shared_strings'
     require 'roo/excelx/styles'
@@ -13,68 +22,10 @@ module Roo
     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
-          :float
-        end
-      end
-
-      module_function :to_type
-    end
+    require 'roo/excelx/coordinate'
+    require 'roo/excelx/format'
 
+    delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files] => :@shared
     ExceedsMaxError = Class.new(StandardError)
 
     # initialization and opening of a spreadsheet file
@@ -87,16 +38,22 @@ module Roo
       cell_max = options.delete(:cell_max)
       sheet_options = {}
       sheet_options[:expand_merged_ranges] = (options[:expand_merged_ranges] || false)
+      sheet_options[:no_hyperlinks] = (options[:no_hyperlinks] || 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)
+        file_type_check(filename_or_stream, %w[.xlsx .xlsm], 'an Excel 2007', file_warning, packed)
+        basename = find_basename(filename_or_stream)
       end
 
-      @tmpdir = make_tmpdir(basename, options[:tmpdir_root])
+      # NOTE: Create temp directory and allow Ruby to cleanup the temp directory
+      #       when the object is garbage collected. Initially, the finalizer was
+      #       created in the Roo::Tempdir module, but that led to a segfault
+      #       when testing in Ruby 2.4.0.
+      @tmpdir = self.class.make_tempdir(self, basename, options[:tmpdir_root])
+      ObjectSpace.define_finalizer(self, self.class.finalize(object_id))
+
+      @shared = Shared.new(@tmpdir)
       @filename = local_filename(filename_or_stream, @tmpdir, packed)
-      @comments_files = []
-      @rels_files = []
       process_zipfile(@filename || filename_or_stream)
 
       @sheet_names = workbook.sheets.map do |sheet|
@@ -106,7 +63,7 @@ module Roo
       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)
+        @sheets[n] = Sheet.new(sheet_name, @shared, n, sheet_options)
         [sheet_name, @sheets[n]]
       end]
 
@@ -116,9 +73,9 @@ module Roo
       end
 
       super
-    rescue => e # clean up any temp files, but only if an error was raised
-      close
-      raise e
+    rescue
+      self.class.finalize_tempdirs(object_id)
+      raise
     end
 
     def method_missing(method, *args)
@@ -187,7 +144,7 @@ module Roo
     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))
+      sheet_for(sheet).cells[key] = Cell.new(value, cell_type, nil, cell_type, value, nil, nil, nil, Coordinate.new(row, col))
     end
 
     # Returns the formula at (row,col).
@@ -239,14 +196,21 @@ module Roo
     # 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)
+      safe_send(sheet_for(sheet).cells[key], :cell_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)
+      safe_send(sheet_for(sheet).cells[key], :cell_value)
+    end
+
+    # returns the internal value of an excelx cell
+    # Note: this is only available within the Excelx class
+    def formatted_value(row, col, sheet = nil)
+      key = normalize(row, col)
+      safe_send(sheet_for(sheet).cells[key], :formatted_value)
     end
 
     # returns the internal format of an excel cell
@@ -259,8 +223,8 @@ module Roo
       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)
+      !cell || cell.empty? ||
+        (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
     end
 
     # shows the internal representation of all cells
@@ -321,7 +285,12 @@ module Roo
     # 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 }
+      sheet = sheet_for(options.delete(:sheet))
+      if block_given?
+        sheet.each_row(options) { |row| yield row }
+      else
+        sheet.to_enum(:each_row, options)
+      end
     end
 
     private
@@ -394,11 +363,14 @@ module Roo
       end
     end
 
+    # Extracts the sheets in order, but it will ignore sheets that are not
+    # worksheets.
     def extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
-      sheet_ids.each_with_index do |id, i|
+      (sheet_ids & sheets.keys).each_with_index do |id, i|
         name = sheets[id]
-        entry = entries.find { |e| e.name =~ /#{name}$/ }
+        entry = entries.find { |e| "/#{e.name}" =~ /#{name}$/ }
         path = "#{tmpdir}/roo_sheet#{i + 1}"
+        sheet_files << path
         @sheet_files << path
         entry.extract(path)
       end
@@ -409,19 +381,13 @@ module Roo
       @sheet_files = []
 
       unless is_stream?(zipfilename_or_stream)
-        process_zipfile_entries Zip::File.open(zipfilename_or_stream).to_a.sort_by(&:name)
+        zip_file = Zip::File.open(zipfilename_or_stream)
       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
+        zip_file = Zip::CentralDirectory.new
+        zip_file.read_from_stream zipfilename_or_stream
       end
+
+      process_zipfile_entries zip_file.to_a.sort_by(&:name)
     end
 
     def process_zipfile_entries(entries)
@@ -458,31 +424,23 @@ module Roo
           #       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}"
+          comments_files[nr - 1] = "#{@tmpdir}/roo_comments#{nr}"
+        when %r{chartsheets/_rels/sheet([0-9]+).xml.rels$}
+          # NOTE: Chart sheet relationship files were interfering with
+          #       worksheets.
+          nil
         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}"
+          rels_files[nr - 1] = "#{@tmpdir}/roo_rels#{nr}"
         end
 
         entry.extract(path) if path
       end
     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 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)
     end

data/lib/roo/formatters/base.rb

@@ -0,0 +1,15 @@
+module Roo
+  module Formatters
+    module Base
+      # converts an integer value to a time string like '02:05:06'
+      def integer_to_timestring(content)
+        h = (content / 3600.0).floor
+        content -= h * 3600
+        m = (content / 60.0).floor
+        content -= m * 60
+        s = content
+        Kernel.format("%02d:%02d:%02d", h, m, s)
+      end
+    end
+  end
+end

data/lib/roo/formatters/csv.rb

@@ -0,0 +1,84 @@
+module Roo
+  module Formatters
+    module CSV
+      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
+
+      private
+
+      # Write all cells to the csv file. File can be a filename or nil. If the
+      # file argument is nil the output goes to STDOUT
+      def write_csv_content(file = nil, sheet = nil, separator = ",")
+        file ||= STDOUT
+        return unless first_row(sheet) # The sheet is empty
+
+        1.upto(last_row(sheet)) do |row|
+          1.upto(last_column(sheet)) do |col|
+            # TODO: use CSV.generate_line
+            file.print(separator) if col > 1
+            file.print cell_to_csv(row, col, sheet)
+          end
+          file.print("\n")
+        end
+      end
+
+      # The content of a cell in the csv output
+      def cell_to_csv(row, col, sheet)
+        return "" if empty?(row, col, sheet)
+
+        onecell = cell(row, col, sheet)
+
+        case celltype(row, col, sheet)
+        when :string
+          %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+        when :boolean
+          # TODO: this only works for excelx
+          onecell = self.sheet_for(sheet).cells[[row, col]].formatted_value
+          %("#{onecell.gsub('"', '""').downcase}")
+        when :float, :percentage
+          if onecell == onecell.to_i
+            onecell.to_i.to_s
+          else
+            onecell.to_s
+          end
+        when :formula
+          case onecell
+          when String
+            %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+          when Integer
+            onecell.to_s
+          when Float
+            if onecell == onecell.to_i
+              onecell.to_i.to_s
+            else
+              onecell.to_s
+            end
+          when Date, DateTime, TrueClass, FalseClass
+            onecell.to_s
+          else
+            fail "unhandled onecell-class #{onecell.class}"
+          end
+        when :date, :datetime
+          onecell.to_s
+        when :time
+          integer_to_timestring(onecell)
+        when :link
+          %("#{onecell.url.gsub('"', '""')}")
+        else
+          fail "unhandled celltype #{celltype(row, col, sheet)}"
+        end || ""
+      end
+    end
+  end
+end

data/lib/roo/formatters/matrix.rb

@@ -0,0 +1,23 @@
+module Roo
+  module Formatters
+    module Matrix
+      # 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
+    end
+  end
+end

data/lib/roo/formatters/xml.rb

@@ -0,0 +1,31 @@
+# returns an XML representation of all sheets of a spreadsheet file
+module Roo
+  module Formatters
+    module XML
+      def to_xml
+        Nokogiri::XML::Builder.new do |xml|
+          xml.spreadsheet do
+            sheets.each do |sheet|
+              self.default_sheet = sheet
+              xml.sheet(name: sheet) do |x|
+                if first_row && last_row && first_column && last_column
+                  # sonst gibt es Fehler bei leeren Blaettern
+                  first_row.upto(last_row) do |row|
+                    first_column.upto(last_column) do |col|
+                      next if empty?(row, col)
+
+                      x.cell(cell(row, col),
+                      row: row,
+                      column: col,
+                      type: celltype(row, col))
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end.to_xml
+      end
+    end
+  end
+end

data/lib/roo/formatters/yaml.rb

@@ -0,0 +1,40 @@
+module Roo
+  module Formatters
+    module YAML
+      # 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 an empty string if there is no first_row, i.e. the sheet is empty
+        return "" unless first_row
+
+        from_row ||= first_row(sheet)
+        to_row ||= last_row(sheet)
+        from_column ||= first_column(sheet)
+        to_column ||= last_column(sheet)
+
+        result = "--- \n"
+        from_row.upto(to_row) do |row|
+          from_column.upto(to_column) do |col|
+            next if empty?(row, col, sheet)
+
+            result << "cell_#{row}_#{col}: \n"
+            prefix.each do|k, v|
+              result << "  #{k}: #{v} \n"
+            end
+            result << "  row: #{row} \n"
+            result << "  col: #{col} \n"
+            result << "  celltype: #{celltype(row, col, sheet)} \n"
+            value = cell(row, col, sheet)
+            if celltype(row, col, sheet) == :time
+              value = integer_to_timestring(value)
+            end
+            result << "  value: #{value} \n"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/roo/libre_office.rb

@@ -1,5 +1,4 @@
 require 'roo/open_office'
 
 # LibreOffice is just an alias for Roo::OpenOffice class
-class Roo::LibreOffice < Roo::OpenOffice
-end
+Roo::LibreOffice = Roo::OpenOffice

data/lib/roo/link.rb

@@ -1,9 +1,28 @@
+require 'uri'
+
 module Roo
   class Link < String
+    # FIXME: Roo::Link inherits from String. A link cell is_a?(Roo::Link). **It is
+    #        the only situation where a cells `value` is always a String**. Link
+    #        cells have a nifty `to_uri` method, but this method isn't easily
+    #        reached. (e.g. `sheet.sheet_for(nil).cells[[row,column]]).value.to_uri`;
+    #        `sheet.hyperlink(row, column)` doesn't use `to_uri`).
+    #
+    #        1. Add different types of links (String, Numeric, Date, DateTime, etc.)
+    #        2. Remove Roo::Link.
+    #        3. Don't inherit the string and pass the cell's value.
+    #
+    #        I don't know the historical reasons for the Roo::Link, but right now
+    #        it seems uneccessary. I'm in favor of keeping it just in case.
+    #
+    #        I'm also in favor of passing the cell's value to Roo::Link. The
+    #        cell.value's class would still be Roo::Link, but the value itself
+    #        would depend on what type of cell it is (Numeric, Date, etc.).
+    #
     attr_reader :href
-    alias :url :href
+    alias_method :url, :href
 
-    def initialize(href='', text=href)
+    def initialize(href = '', text = href)
       super(text)
       @href = href
     end