roo 2.7.1 → 2.8.0

data/lib/roo/excelx/sheet.rb

@@ -4,11 +4,15 @@ module Roo
     class Sheet
       extend Forwardable
 
-      delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files] => :@shared
+      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)
@@ -19,7 +23,14 @@ module Roo
       end
 
       def present_cells
-        @present_cells ||= cells.select { |_, cell| cell && !cell.empty? }
+        @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
@@ -39,33 +50,33 @@ module Roo
 
       def row(row_number)
         first_column.upto(last_column).map do |col|
-          cells[[row_number, col]]
-        end.map { |cell| cell && cell.value }
+          cells[[row_number, col]]&.value
+        end
       end
 
       def column(col_number)
         first_row.upto(last_row).map do |row|
-          cells[[row, col_number]]
-        end.map { |cell| cell && cell.value }
+          cells[[row, col_number]]&.value
+        end
       end
 
       # returns the number of the first non-empty row
       def first_row
-        @first_row ||= present_cells.keys.map { |row, _| row }.min
+        @first_row ||= first_last_row_col[:first_row]
       end
 
       def last_row
-        @last_row ||= present_cells.keys.map { |row, _| row }.max
+        @last_row ||= first_last_row_col[:last_row]
       end
 
       # returns the number of the first non-empty column
       def first_column
-        @first_column ||= present_cells.keys.map { |_, col| col }.min
+        @first_column ||= first_last_row_col[:first_column]
       end
 
       # returns the number of the last non-empty column
       def last_column
-        @last_column ||= present_cells.keys.map { |_, col| col }.max
+        @last_column ||= first_last_row_col[:last_column]
       end
 
       def excelx_format(key)
@@ -107,6 +118,34 @@ module Roo
         (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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'roo/excelx/extractor'
 
@@ -5,7 +7,7 @@ module Roo
   class Excelx
     class SheetDoc < Excelx::Extractor
       extend Forwardable
-      delegate [:styles, :workbook, :shared_strings, :base_date] => :@shared
+      delegate [:workbook] => :@shared
 
       def initialize(path, relationships, shared, options = {})
         super(path)
@@ -19,7 +21,12 @@ module Roo
       end
 
       def hyperlinks(relationships)
-        @hyperlinks ||= extract_hyperlinks(relationships)
+        # If you're sure you're not going to need this hyperlinks you can discard it
+        @hyperlinks ||= if @options[:no_hyperlinks]
+          {}
+        else
+          extract_hyperlinks(relationships)
+        end
       end
 
       # Get the dimensions for the sheet.
@@ -39,13 +46,10 @@ module Roo
       def each_cell(row_xml)
         return [] unless row_xml
         row_xml.children.each do |cell_element|
-          # If you're sure you're not going to need this hyperlinks you can discard it
-          hyperlinks = unless @options[:no_hyperlinks]
-                         key = ::Roo::Utils.ref_to_key(cell_element['r'])
-                         hyperlinks(@relationships)[key]
-                       end
+          coordinate = ::Roo::Utils.extract_coordinate(cell_element["r"])
+          hyperlinks = hyperlinks(@relationships)[coordinate]
 
-          yield cell_from_xml(cell_element, hyperlinks)
+          yield cell_from_xml(cell_element, hyperlinks, coordinate)
         end
       end
 
@@ -53,13 +57,13 @@ module Roo
 
       def cell_value_type(type, format)
         case type
-        when 's'.freeze
+        when 's'
           :shared
-        when 'b'.freeze
+        when 'b'
           :boolean
-        when 'str'.freeze
+        when 'str'
           :string
-        when 'inlineStr'.freeze
+        when 'inlineStr'
           :inlinestr
         else
           Excelx::Format.to_type(format)
@@ -74,42 +78,58 @@ module Roo
       #             </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)
+      #    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 = extract_coordinate(cell_xml['r'])
-        return Excelx::Cell::Empty.new(coordinate) if cell_xml.children.empty?
+      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
-        format = styles.style_format(style)
-        value_type = cell_value_type(cell_xml['t'], format)
+        style = cell_xml["s"].to_i
         formula = nil
 
-        cell_xml.children.each do |cell|
+        cell_xml_children.each do |cell|
           case cell.name
           when 'is'
-            content_arr = cell.search('t').map(&:content)
-            unless content_arr.empty?
-              return Excelx::Cell.create_cell(:string, content_arr.join(''), formula, style, hyperlink, coordinate)
+            content = +""
+            cell.children.each do |inline_str|
+              if inline_str.name == 't'
+                content << inline_str.content
+              end
+            end
+            unless content.empty?
+              return Excelx::Cell.cell_class(:string).new(content, formula, style, hyperlink, coordinate)
             end
           when 'f'
             formula = cell.content
           when 'v'
-            return create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, coordinate)
+            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
 
-        Excelx::Cell::Empty.new(coordinate)
+        create_empty_cell(coordinate)
       end
 
-      def create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, coordinate)
+      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.
@@ -125,11 +145,12 @@ module Roo
         #       3. formula
         case value_type
         when :shared
-          value = shared_strings.use_html?(cell.content.to_i) ? shared_strings.to_html[cell.content.to_i] : shared_strings[cell.content.to_i]
-          Excelx::Cell.create_cell(:string, value, formula, style, hyperlink, coordinate)
+          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.create_cell(value_type, value, formula, style, hyperlink, coordinate)
+          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
@@ -148,35 +169,32 @@ module Roo
                       else
                         :date
                       end
-          Excelx::Cell.create_cell(cell_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+          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.create_cell(value_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+          Excelx::Cell.cell_class(:date).new(cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
         else
-          Excelx::Cell.create_cell(:number, cell.content, formula, excelx_type, style, hyperlink, coordinate)
+          Excelx::Cell.cell_class(:number).new(cell.content, formula, excelx_type, style, hyperlink, coordinate)
         end
       end
 
-      def extract_coordinate(coordinate)
-        row, column = ::Roo::Utils.split_coordinate(coordinate)
-
-        Excelx::Coordinate.new(row, column)
-      end
-
       def extract_hyperlinks(relationships)
         return {} unless (hyperlinks = doc.xpath('/worksheet/hyperlinks/hyperlink'))
 
-        Hash[hyperlinks.map do |hyperlink|
-          if hyperlink.attribute('id') && (relationship = relationships[hyperlink.attribute('id').text])
-            [::Roo::Utils.ref_to_key(hyperlink.attributes['ref'].to_s), relationship.attribute('Target').text]
+        hyperlinks.each_with_object({}) do |hyperlink, hash|
+          if relationship = relationships[hyperlink['id']]
+            target_link = relationship['Target']
+            target_link += "##{hyperlink['location']}" if hyperlink['location']
+            hash[::Roo::Utils.ref_to_key(hyperlink["ref"].to_s)] = target_link
           end
-        end.compact]
+        end
       end
 
       def expand_merged_ranges(cells)
         # Extract merged ranges from xml
         merges = {}
         doc.xpath('/worksheet/mergeCells/mergeCell').each do |mergecell_xml|
-          tl, br = mergecell_xml['ref'].split(/:/).map { |ref| ::Roo::Utils.ref_to_key(ref) }
+          tl, br = mergecell_xml["ref"].split(/:/).map { |ref| ::Roo::Utils.ref_to_key(ref) }
           for row in tl[0]..br[0] do
             for col in tl[1]..br[1] do
               next if row == tl[0] && col == tl[1]
@@ -191,10 +209,14 @@ module Roo
       end
 
       def extract_cells(relationships)
-        extracted_cells = Hash[doc.xpath('/worksheet/sheetData/row/c').map do |cell_xml|
-          key = ::Roo::Utils.ref_to_key(cell_xml['r'])
-          [key, cell_from_xml(cell_xml, hyperlinks(relationships)[key])]
-        end]
+        extracted_cells = {}
+        empty_cell = @options[:empty_cell]
+
+        doc.xpath('/worksheet/sheetData/row/c').each do |cell_xml|
+          coordinate = ::Roo::Utils.extract_coordinate(cell_xml["r"])
+          cell = cell_from_xml(cell_xml, hyperlinks(relationships)[coordinate], coordinate, empty_cell)
+          extracted_cells[coordinate] = cell if cell
+        end
 
         expand_merged_ranges(extracted_cells) if @options[:expand_merged_ranges]
 
@@ -203,9 +225,25 @@ module Roo
 
       def extract_dimensions
         Roo::Utils.each_element(@path, 'dimension') do |dimension|
-          return dimension.attributes['ref'].value
+          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

@@ -55,9 +55,9 @@ module Roo
       end
 
       def extract_num_fmts
-        Hash[doc.xpath('//numFmt').map do |num_fmt|
-          [num_fmt['numFmtId'], num_fmt['formatCode']]
-        end]
+        doc.xpath('//numFmt').each_with_object({}) do |num_fmt, hash|
+          hash[num_fmt['numFmtId']] = num_fmt['formatCode']
+        end
       end
     end
   end

data/lib/roo/excelx/workbook.rb

@@ -29,13 +29,17 @@ module Roo
 
       # aka labels
       def defined_names
-        Hash[doc.xpath('//definedName').map do |defined_name|
+        doc.xpath('//definedName').each_with_object({}) do |defined_name, hash|
           # "Sheet1!$C$5"
           sheet, coordinates = defined_name.text.split('!$', 2)
           col, row = coordinates.split('$')
           name = defined_name['name']
-          [name, Label.new(name, sheet, row, col)]
-        end]
+          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

data/lib/roo/helpers/default_attr_reader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Roo
+  module Helpers
+    module DefaultAttrReader
+      def attr_reader_with_default(attr_hash)
+        attr_hash.each do |attr_name, default_value|
+          instance_variable = :"@#{attr_name}"
+          define_method attr_name do
+            if instance_variable_defined? instance_variable
+              instance_variable_get instance_variable
+            else
+              default_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roo/helpers/weak_instance_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module Roo
+  module Helpers
+    module WeakInstanceCache
+      private
+
+      def instance_cache(key)
+        object = nil
+
+        if instance_variable_defined?(key) && (ref = instance_variable_get(key)) && ref.weakref_alive?
+          begin
+            object = ref.__getobj__
+          rescue => e
+            unless (defined?(::WeakRef::RefError) && e.is_a?(::WeakRef::RefError)) || (defined?(RefError) && e.is_a?(RefError))
+              raise e
+            end
+          end
+        end
+
+        unless object
+          object = yield
+          ObjectSpace.define_finalizer(object, instance_cache_finalizer(key))
+          instance_variable_set(key, WeakRef.new(object))
+        end
+
+        object
+      end
+
+      def instance_cache_finalizer(key)
+        proc do |object_id|
+          if instance_variable_defined?(key) && (ref = instance_variable_get(key)) && (!ref.weakref_alive? || ref.__getobj__.object_id == object_id)
+            remove_instance_variable(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roo/open_office.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'nokogiri'
 require 'cgi'
@@ -11,9 +13,9 @@ module Roo
   class OpenOffice < Roo::Base
     extend Roo::Tempdir
 
-    ERROR_MISSING_CONTENT_XML = 'file missing required content.xml'.freeze
-    XPATH_FIND_TABLE_STYLES   = "//*[local-name()='automatic-styles']".freeze
-    XPATH_LOCAL_NAME_TABLE    = "//*[local-name()='table']".freeze
+    ERROR_MISSING_CONTENT_XML = 'file missing required content.xml'
+    XPATH_FIND_TABLE_STYLES   = "//*[local-name()='automatic-styles']"
+    XPATH_LOCAL_NAME_TABLE    = "//*[local-name()='table']"
 
     # initialization and opening of a spreadsheet file
     # values for packed: :zip
@@ -561,7 +563,7 @@ module Roo
     end
 
     def read_labels
-      @label ||= Hash[doc.xpath('//table:named-range').map do |ne|
+      @label ||= doc.xpath('//table:named-range').each_with_object({}) do |ne, hash|
         #-
         # $Sheet1.$C$5
         #+
@@ -569,8 +571,8 @@ module Roo
         sheetname, coords = attribute(ne, 'cell-range-address').to_s.split('.$')
         col, row          = coords.split('$')
         sheetname         = sheetname[1..-1] if sheetname[0, 1] == '$'
-        [name, [sheetname, row, col]]
-      end]
+        hash[name] = [sheetname, row, col]
+      end
     end
 
     def read_styles(style_elements)