roo 1.13.1 → 2.10.1

data/lib/roo/excelx/sheet.rb

@@ -0,0 +1,151 @@
+require 'forwardable'
+module Roo
+  class Excelx
+    class Sheet
+      extend Forwardable
+
+      delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files, :image_rels] => :@shared
+
+      attr_reader :images
+
+      def initialize(name, shared, sheet_index, options = {})
+        @name = name
+        @shared = shared
+        @sheet_index = sheet_index
+        @images = Images.new(image_rels[sheet_index]).list
+        @rels = Relationships.new(rels_files[sheet_index])
+        @comments = Comments.new(comments_files[sheet_index])
+        @sheet = SheetDoc.new(sheet_files[sheet_index], @rels, shared, options)
+      end
+
+      def cells
+        @cells ||= @sheet.cells(@rels)
+      end
+
+      def present_cells
+        @present_cells ||= begin
+          warn %{
+[DEPRECATION] present_cells is deprecated. Alternate:
+  with activesupport    => cells[key].presence
+  without activesupport => cells[key]&.presence
+          }
+          cells.select { |_, cell| cell&.presence }
+        end
+      end
+
+      # Yield each row as array of Excelx::Cell objects
+      # accepts options max_rows (int) (offset by 1 for header),
+      # pad_cells (boolean) and offset (int)
+      def each_row(options = {}, &block)
+        row_count = 0
+        options[:offset] ||= 0
+        @sheet.each_row_streaming do |row|
+          break if options[:max_rows] && row_count == options[:max_rows] + options[:offset] + 1
+          if block_given? && !(options[:offset] && row_count < options[:offset])
+            block.call(cells_for_row_element(row, options))
+          end
+          row_count += 1
+        end
+      end
+
+      def row(row_number)
+        first_column.upto(last_column).map do |col|
+          cells[[row_number, col]]&.value
+        end
+      end
+
+      def column(col_number)
+        first_row.upto(last_row).map do |row|
+          cells[[row, col_number]]&.value
+        end
+      end
+
+      # returns the number of the first non-empty row
+      def first_row
+        @first_row ||= first_last_row_col[:first_row]
+      end
+
+      def last_row
+        @last_row ||= first_last_row_col[:last_row]
+      end
+
+      # returns the number of the first non-empty column
+      def first_column
+        @first_column ||= first_last_row_col[:first_column]
+      end
+
+      # returns the number of the last non-empty column
+      def last_column
+        @last_column ||= first_last_row_col[:last_column]
+      end
+
+      def excelx_format(key)
+        cell = cells[key]
+        styles.style_format(cell.style).to_s if cell
+      end
+
+      def hyperlinks
+        @hyperlinks ||= @sheet.hyperlinks(@rels)
+      end
+
+      def comments
+        @comments.comments
+      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
+        end
+        cells
+      end
+
+      def pad_cells(cell, last_column)
+        pad = []
+        (cell.coordinate.column - 1 - last_column).times { pad << nil }
+        pad
+      end
+
+      def first_last_row_col
+        @first_last_row_col ||= begin
+          first_row = last_row = first_col = last_col = nil
+
+          cells.each do |(row, col), cell|
+            next unless cell&.presence
+            first_row ||= row
+            last_row ||= row
+            first_col ||= col
+            last_col ||= col
+
+            if row > last_row
+              last_row = row
+            elsif row < first_row
+              first_row = row
+            end
+
+            if col > last_col
+              last_col = col
+            elsif col < first_col
+              first_col = col
+            end
+          end
+
+          {first_row: first_row, last_row: last_row, first_column: first_col, last_column: last_col}
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/sheet_doc.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class SheetDoc < Excelx::Extractor
+      extend Forwardable
+      delegate [:workbook] => :@shared
+
+      def initialize(path, relationships, shared, options = {})
+        super(path)
+        @shared = shared
+        @options = options
+        @relationships = relationships
+      end
+
+      def cells(relationships)
+        @cells ||= extract_cells(relationships)
+      end
+
+      def hyperlinks(relationships)
+        # If you're sure you're not going to need this hyperlinks you can discard it
+        @hyperlinks ||= if @options[:no_hyperlinks] || !relationships.include_type?("hyperlink")
+          {}
+        else
+          extract_hyperlinks(relationships)
+        end
+      end
+
+      # Get the dimensions for the sheet.
+      # This is the upper bound of cells that might
+      # be parsed. (the document may be sparse so cell count is only upper bound)
+      def dimensions
+        @dimensions ||= extract_dimensions
+      end
+
+      # Yield each row xml element to caller
+      def each_row_streaming(&block)
+        Roo::Utils.each_element(@path, 'row', &block)
+      end
+
+      # Yield each cell as Excelx::Cell to caller for given
+      # row xml
+      def each_cell(row_xml)
+        return [] unless row_xml
+        row_xml.children.each do |cell_element|
+          coordinate = ::Roo::Utils.extract_coordinate(cell_element["r"])
+          hyperlinks = hyperlinks(@relationships)[coordinate]
+
+          yield cell_from_xml(cell_element, hyperlinks, coordinate)
+        end
+      end
+
+      private
+
+      def cell_value_type(type, format)
+        case type
+        when 's'
+          :shared
+        when 'b'
+          :boolean
+        when 'str'
+          :string
+        when 'inlineStr'
+          :inlinestr
+        else
+          Excelx::Format.to_type(format)
+        end
+      end
+
+      # Internal: Creates a cell based on an XML clell..
+      #
+      # cell_xml - a Nokogiri::XML::Element. e.g.
+      #             <c r="A5" s="2">
+      #               <v>22606</v>
+      #             </c>
+      # hyperlink - a String for the hyperlink for the cell or nil when no
+      #             hyperlink is present.
+      # coordinate - a Roo::Excelx::Coordinate for the coordinate for the cell
+      #              or nil to extract coordinate from cell_xml.
+      # empty_cell - an Optional Boolean value.
+      #
+      # Examples
+      #
+      #    cells_from_xml(<Nokogiri::XML::Element>, nil, nil)
+      #    # => <Excelx::Cell::String>
+      #
+      # Returns a type of <Excelx::Cell>.
+      def cell_from_xml(cell_xml, hyperlink, coordinate, empty_cell=true)
+        coordinate ||= ::Roo::Utils.extract_coordinate(cell_xml["r"])
+        cell_xml_children = cell_xml.children
+        return create_empty_cell(coordinate, empty_cell) if cell_xml_children.empty?
+
+        # NOTE: This is error prone, to_i will silently turn a nil into a 0.
+        #       This works by coincidence because Format[0] is General.
+        style = cell_xml["s"].to_i
+        formula = nil
+
+        cell_xml_children.each do |cell|
+          case cell.name
+          when 'is'
+            content = cell.search('t').map(&:content).join
+            unless content.empty?
+              return Excelx::Cell.cell_class(:string).new(content, formula, style, hyperlink, coordinate)
+            end
+          when 'f'
+            formula = cell.content
+          when 'v'
+            format = style_format(style)
+            value_type = cell_value_type(cell_xml["t"], format)
+
+            return create_cell_from_value(value_type, cell, formula, format, style, hyperlink, coordinate)
+          end
+        end
+
+        create_empty_cell(coordinate, empty_cell)
+      end
+
+      def create_empty_cell(coordinate, empty_cell)
+        if empty_cell
+          Excelx::Cell::Empty.new(coordinate)
+        end
+      end
+
+      def create_cell_from_value(value_type, cell, formula, format, style, hyperlink, coordinate)
+        # NOTE: format.to_s can replace excelx_type as an argument for
+        #       Cell::Time, Cell::DateTime, Cell::Date or Cell::Number, but
+        #       it will break some brittle tests.
+        excelx_type = [:numeric_or_formula, format.to_s]
+
+        # NOTE: There are only a few situations where value != cell.content
+        #       1. when a sharedString is used. value = sharedString;
+        #          cell.content = id of sharedString
+        #       2. boolean cells: value = 'TRUE' | 'FALSE'; cell.content = '0' | '1';
+        #          But a boolean cell should use TRUE|FALSE as the formatted value
+        #          and use a Boolean for it's value. Using a Boolean value breaks
+        #          Roo::Base#to_csv.
+        #       3. formula
+        case value_type
+        when :shared
+          cell_content = cell.content.to_i
+          value = shared_strings.use_html?(cell_content) ? shared_strings.to_html[cell_content] : shared_strings[cell_content]
+          Excelx::Cell.cell_class(:string).new(value, formula, style, hyperlink, coordinate)
+        when :boolean, :string
+          value = cell.content
+          Excelx::Cell.cell_class(value_type).new(value, formula, style, hyperlink, coordinate)
+        when :time, :datetime
+          cell_content = cell.content.to_f
+          # NOTE: A date will be a whole number. A time will have be > 1. And
+          #      in general, a datetime will have decimals. But if the cell is
+          #      using a custom format, it's possible to be interpreted incorrectly.
+          #      cell_content.to_i == cell_content && standard_style?=> :date
+          #
+          #      Should check to see if the format is standard or not. If it's a
+          #      standard format, than it's a date, otherwise, it is a datetime.
+          #      @styles.standard_style?(style_id)
+          #      STANDARD_STYLES.keys.include?(style_id.to_i)
+          cell_type = if cell_content < 1.0
+                        :time
+                      elsif (cell_content - cell_content.floor).abs > 0.000001
+                        :datetime
+                      else
+                        :date
+                      end
+          base_value = cell_type == :date ? base_date : base_timestamp
+          Excelx::Cell.cell_class(cell_type).new(cell_content, formula, excelx_type, style, hyperlink, base_value, coordinate)
+        when :date
+          Excelx::Cell.cell_class(:date).new(cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+        else
+          Excelx::Cell.cell_class(:number).new(cell.content, formula, excelx_type, style, hyperlink, coordinate)
+        end
+      end
+
+      def extract_hyperlinks(relationships)
+        return {} unless (hyperlinks = doc.xpath('/worksheet/hyperlinks/hyperlink'))
+
+        hyperlinks.each_with_object({}) do |hyperlink, hash|
+          if relationship = relationships[hyperlink['id']]
+            target_link = relationship['Target']
+            target_link += "##{hyperlink['location']}" if hyperlink['location']
+
+            Roo::Utils.coordinates_in_range(hyperlink["ref"].to_s) do |coord|
+              hash[coord] = target_link
+            end
+          end
+        end
+      end
+
+      def expand_merged_ranges(cells)
+        # Extract merged ranges from xml
+        merges = {}
+        doc.xpath('/worksheet/mergeCells/mergeCell').each do |mergecell_xml|
+          src, dst = mergecell_xml["ref"].split(/:/).map { |ref| ::Roo::Utils.ref_to_key(ref) }
+          next unless cells[src]
+          for row in src[0]..dst[0] do
+            for col in src[1]..dst[1] do
+              next if row == src[0] && col == src[1]
+              merges[[row, col]] = src
+            end
+          end
+        end
+        # Duplicate value into all cells in merged range
+        merges.each do |dst, src|
+          cells[dst] = cells[src]
+        end
+      end
+
+      def extract_cells(relationships)
+        extracted_cells = {}
+        empty_cell = @options[:empty_cell]
+
+        doc.xpath('/worksheet/sheetData/row').each.with_index(1) do |row_xml, ycoord|
+          row_xml.xpath('c').each.with_index(1) do |cell_xml, xcoord|
+            r = cell_xml['r']
+            coordinate =
+              if r.nil?
+                ::Roo::Excelx::Coordinate.new(ycoord, xcoord)
+              else
+                ::Roo::Utils.extract_coordinate(r)
+              end
+
+            cell = cell_from_xml(cell_xml, hyperlinks(relationships)[coordinate], coordinate, empty_cell)
+            extracted_cells[coordinate] = cell if cell
+          end
+        end
+
+        expand_merged_ranges(extracted_cells) if @options[:expand_merged_ranges]
+
+        extracted_cells
+      end
+
+      def extract_dimensions
+        Roo::Utils.each_element(@path, 'dimension') do |dimension|
+          return dimension["ref"]
+        end
+      end
+
+      def style_format(style)
+        @shared.styles.style_format(style)
+      end
+
+      def base_date
+        @shared.base_date
+      end
+
+      def base_timestamp
+        @shared.base_timestamp
+      end
+
+      def shared_strings
+        @shared.shared_strings
+      end
+    end
+  end
+end

data/lib/roo/excelx/styles.rb

@@ -0,0 +1,64 @@
+require 'roo/font'
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class Styles < Excelx::Extractor
+      # convert internal excelx attribute to a format
+      def style_format(style)
+        id = num_fmt_ids[style.to_i]
+        num_fmts[id] || Excelx::Format::STANDARD_FORMATS[id.to_i]
+      end
+
+      def definitions
+        @definitions ||= extract_definitions
+      end
+
+      private
+
+      def num_fmt_ids
+        @num_fmt_ids ||= extract_num_fmt_ids
+      end
+
+      def num_fmts
+        @num_fmts ||= extract_num_fmts
+      end
+
+      def fonts
+        @fonts ||= extract_fonts
+      end
+
+      def extract_definitions
+        doc.xpath('//cellXfs').flat_map do |xfs|
+          xfs.children.map do |xf|
+            fonts[xf['fontId'].to_i]
+          end
+        end
+      end
+
+      def extract_fonts
+        doc.xpath('//fonts/font').map do |font_el|
+          Font.new.tap do |font|
+            font.bold = !font_el.xpath('./b').empty?
+            font.italic = !font_el.xpath('./i').empty?
+            font.underline = !font_el.xpath('./u').empty?
+          end
+        end
+      end
+
+      def extract_num_fmt_ids
+        doc.xpath('//cellXfs').flat_map do |xfs|
+          xfs.children.map do |xf|
+            xf['numFmtId']
+          end
+        end.compact
+      end
+
+      def extract_num_fmts
+        doc.xpath('//numFmt').each_with_object({}) do |num_fmt, hash|
+          hash[num_fmt['numFmtId']] = num_fmt['formatCode']
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/workbook.rb

@@ -0,0 +1,64 @@
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class Workbook < Excelx::Extractor
+      class Label
+        attr_reader :sheet, :row, :col, :name
+
+        def initialize(name, sheet, row, col)
+          @name = name
+          @sheet = sheet
+          @row = row.to_i
+          @col = ::Roo::Utils.letter_to_number(col)
+        end
+
+        def key
+          [@row, @col]
+        end
+      end
+
+      def initialize(path)
+        super
+        fail ArgumentError, 'missing required workbook file' unless doc_exists?
+      end
+
+      def sheets
+        doc.xpath('//sheet')
+      end
+
+      # aka labels
+      def defined_names
+        doc.xpath('//definedName').each_with_object({}) do |defined_name, hash|
+          # "Sheet1!$C$5"
+          sheet, coordinates = defined_name.text.split('!$', 2)
+          next unless coordinates
+          col, row = coordinates.split('$')
+          name = defined_name['name']
+          hash[name] = Label.new(name, sheet, row, col)
+        end
+      end
+
+      def base_timestamp
+        @base_timestamp ||= base_date.to_datetime.to_time.to_i
+      end
+
+      def base_date
+        @base_date ||=
+        begin
+          # Default to 1900 (minus one day due to excel quirk) but use 1904 if
+          # it's set in the Workbook's workbookPr
+          # http://msdn.microsoft.com/en-us/library/ff530155(v=office.12).aspx
+          result = Date.new(1899, 12, 30) # default
+          doc.css('workbookPr[date1904]').each do |workbookPr|
+            if workbookPr['date1904'] =~ /true|1/i
+              result = Date.new(1904, 01, 01)
+              break
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end