roo 2.3.0 → 2.10.1

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/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,15 +1,21 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'nokogiri'
 require 'cgi'
 require 'zip/filesystem'
 require 'roo/font'
+require 'roo/tempdir'
 require 'base64'
+require 'openssl'
 
 module Roo
   class OpenOffice < Roo::Base
-    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
+    extend Roo::Tempdir
+
+    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
@@ -19,15 +25,32 @@ module Roo
 
       @only_visible_sheets = options[:only_visible_sheets]
       file_type_check(filename, '.ods', 'an Roo::OpenOffice', file_warning, packed)
-      @tmpdir   = make_tmpdir(File.basename(filename), 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, find_basename(filename), options[:tmpdir_root])
+      ObjectSpace.define_finalizer(self, self.class.finalize(object_id))
       @filename = local_filename(filename, @tmpdir, packed)
       # TODO: @cells_read[:default] = false
       open_oo_file(options)
       super(filename, options)
       initialize_default_variables
-    rescue => e # clean up any temp files, but only if an error was raised
-      close
-      raise e
+
+      unless @table_display.any?
+        doc.xpath(XPATH_FIND_TABLE_STYLES).each do |style|
+          read_table_styles(style)
+        end
+      end
+
+      @sheet_names = doc.xpath(XPATH_LOCAL_NAME_TABLE).map do |sheet|
+        if !@only_visible_sheets || @table_display[attribute(sheet, 'style-name')]
+          sheet.attributes['name'].value
+        end
+      end.compact
+    rescue
+      self.class.finalize_tempdirs(object_id)
+      raise
     end
 
     def open_oo_file(options)
@@ -132,16 +155,7 @@ module Roo
     end
 
     def sheets
-      unless @table_display.any?
-        doc.xpath(XPATH_FIND_TABLE_STYLES).each do |style|
-          read_table_styles(style)
-        end
-      end
-      doc.xpath(XPATH_LOCAL_NAME_TABLE).map do |sheet|
-        if !@only_visible_sheets || @table_display[attribute(sheet, 'style-name')]
-          sheet.attributes['name'].value
-        end
-      end.compact
+      @sheet_names
     end
 
     # version of the Roo::OpenOffice document
@@ -285,7 +299,6 @@ module Roo
           algorithm_node['manifest:initialisation-vector']
         )
         key_derivation_name = key_derivation_node['manifest:key-derivation-name']
-        key_size            = key_derivation_node['manifest:key-size'].to_i
         iteration_count     = key_derivation_node['manifest:iteration-count'].to_i
         salt                = Base64.decode64(key_derivation_node['manifest:salt'])
 
@@ -294,10 +307,8 @@ module Roo
           start_key_generation_node[
             'manifest:start-key-generation-name'
           ]
-        key_generation_size = start_key_generation_node['manifest:key-size'].to_i
 
         hashed_password = password
-        key             = nil
 
         if key_generation_name == 'http://www.w3.org/2000/09/xmldsig#sha256'
 
@@ -337,7 +348,7 @@ module Roo
     def find_cipher(*args)
       fail ArgumentError, 'Unknown algorithm ' + algorithm unless args[0] == 'http://www.w3.org/2001/04/xmlenc#aes256-cbc'
 
-      cipher = OpenSSL::Cipher.new('AES-256-CBC')
+      cipher = ::OpenSSL::Cipher.new('AES-256-CBC')
       cipher.decrypt
       cipher.padding = 0
       cipher.key     = find_cipher_key(cipher, *args[1..4])
@@ -350,7 +361,7 @@ module Roo
     def find_cipher_key(*args)
       fail ArgumentError, 'Unknown key derivation name ', args[1] unless args[1] == 'PBKDF2'
 
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(args[2], args[3], args[4], args[0].key_len)
+      ::OpenSSL::PKCS5.pbkdf2_hmac_sha1(args[2], args[3], args[4], args[0].key_len)
     end
 
     # Block decrypt raw bytes from the zip file based on the cipher
@@ -412,7 +423,10 @@ module Roo
       @style[sheet][key] = style_name
       case @cell_type[sheet][key]
       when :float
-        @cell[sheet][key] = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
+        value = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
+        value = 'true' if formula == '=TRUE()'
+        value = 'false' if formula == '=FALSE()'
+        @cell[sheet][key] = value
       when :percentage
         @cell[sheet][key] = v.to_f
       when :string
@@ -506,7 +520,7 @@ module Roo
                         str_v += child.content #.text
                       end
                     end
-                    str_v.gsub!(/&apos;/, "'") # special case not supported by unescapeHTML
+                    str_v = str_v.gsub(/&apos;/, "'") # special case not supported by unescapeHTML
                     str_v = CGI.unescapeHTML(str_v)
                   end # == 'p'
                 end
@@ -552,7 +566,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
         #+
@@ -560,8 +574,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)

data/lib/roo/spreadsheet.rb

@@ -24,8 +24,14 @@ module Roo
           options[:file_warning] = :ignore
           extension.tr('.', '').downcase.to_sym
         else
-          res = ::File.extname((path =~ /\A#{::URI.regexp}\z/) ? ::URI.parse(::URI.encode(path)).path : path)
-          res.tr('.', '').downcase.to_sym
+          parsed_path =
+            if path =~ /\A#{::URI::DEFAULT_PARSER.make_regexp}\z/
+              # path is 7th match
+              Regexp.last_match[7]
+            else
+              path
+            end
+          ::File.extname(parsed_path).tr('.', '').downcase.to_sym
         end
       end
     end

data/lib/roo/tempdir.rb

@@ -0,0 +1,24 @@
+module Roo
+  module Tempdir
+    def finalize_tempdirs(object_id)
+      if @tempdirs && (dirs_to_remove = @tempdirs[object_id])
+        @tempdirs.delete(object_id)
+        dirs_to_remove.each do |dir|
+          # Pass force=true to avoid an exception (and thus warnings in Ruby 3.1) if dir has
+          # already been removed. This can occur when the finalizer is called both in a forked
+          # child process and in the parent.
+          ::FileUtils.remove_entry(dir, true)
+        end
+      end
+    end
+
+    def make_tempdir(object, prefix, root)
+      root ||= ENV["ROO_TMP"]
+      # NOTE: This folder is cleaned up by finalize_tempdirs.
+      ::Dir.mktmpdir("#{Roo::TEMP_PREFIX}#{prefix}", root).tap do |tmpdir|
+        @tempdirs ||= Hash.new { |h, k| h[k] = [] }
+        @tempdirs[object.object_id] << tmpdir
+      end
+    end
+  end
+end

data/lib/roo/utils.rb

@@ -1,42 +1,56 @@
+# frozen_string_literal: true
+
 module Roo
   module Utils
     extend self
 
-    def split_coordinate(str)
-      @split_coordinate ||= {}
+    LETTERS = ('A'..'Z').to_a
+
+    def extract_coordinate(s)
+      num = letter_num = 0
+      num_only = false
 
-      @split_coordinate[str] ||= begin
-        letter, number = split_coord(str)
-        x = letter_to_number(letter)
-        y = number
-        [y, x]
+      s.each_byte do |b|
+        if !num_only && (index = char_index(b))
+          letter_num *= 26
+          letter_num += index
+        elsif index = num_index(b)
+          num_only = true
+          num *= 10
+          num += index
+        else
+          fail ArgumentError
+        end
       end
+      fail ArgumentError if letter_num == 0 || !num_only
+
+      Excelx::Coordinate.new(num, letter_num)
     end
 
-    alias_method :ref_to_key, :split_coordinate
+    alias_method :ref_to_key, :extract_coordinate
 
-    def split_coord(s)
-      if s =~ /([a-zA-Z]+)([0-9]+)/
-        letter = Regexp.last_match[1]
-        number = Regexp.last_match[2].to_i
-      else
-        fail ArgumentError
-      end
-      [letter, number]
+    def split_coordinate(str)
+      warn "[DEPRECATION] `Roo::Utils.split_coordinate` is deprecated.  Please use `Roo::Utils.extract_coordinate` instead."
+      extract_coordinate(str)
+    end
+
+
+
+    def split_coord(str)
+      coord = extract_coordinate(str)
+      [number_to_letter(coord.column), coord.row]
     end
 
     # convert a number to something like 'AB' (1 => 'A', 2 => 'B', ...)
     def number_to_letter(num)
-      results = []
-      num = num.to_i
+      result = +""
 
-      while (num > 0)
-        mod = (num - 1) % 26
-        results = [(65 + mod).chr] + results
-        num = ((num - mod) / 26)
+      until num.zero?
+        num, index = (num - 1).divmod(26)
+        result.prepend(LETTERS[index])
       end
 
-      results.join
+      result
     end
 
     def letter_to_number(letters)
@@ -56,11 +70,30 @@ module Roo
       cells = str.split(':')
       return 1 if cells.count == 1
       raise ArgumentError.new("invalid range string: #{str}. Supported range format 'A1:B2'") if cells.count != 2
-      x1, y1 = split_coordinate(cells[0])
-      x2, y2 = split_coordinate(cells[1])
+      x1, y1 = extract_coordinate(cells[0])
+      x2, y2 = extract_coordinate(cells[1])
       (x2 - (x1 - 1)) * (y2 - (y1 - 1))
     end
 
+    def coordinates_in_range(str)
+      return to_enum(:coordinates_in_range, str) unless block_given?
+      coordinates = str.split(":", 2).map! { |s| extract_coordinate s }
+
+      case coordinates.size
+      when 1
+        yield coordinates[0]
+      when 2
+        tl, br = coordinates
+        rows = tl.row..br.row
+        cols = tl.column..br.column
+        rows.each do |row|
+          cols.each do |column|
+            yield Excelx::Coordinate.new(row, column)
+          end
+        end
+      end
+    end
+
     def load_xml(path)
       ::File.open(path, 'rb') do |file|
         ::Nokogiri::XML(file)
@@ -69,10 +102,27 @@ module Roo
 
     # Yield each element of a given type ('row', 'c', etc.) to caller
     def each_element(path, elements)
+      elements = Array(elements)
       Nokogiri::XML::Reader(::File.open(path, 'rb'), nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).each do |node|
-        next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT && Array(elements).include?(node.name)
+        next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT && elements.include?(node.name)
         yield Nokogiri::XML(node.outer_xml).root if block_given?
       end
     end
+
+    private
+
+    def char_index(byte)
+      if byte >= 65 && byte <= 90
+        byte - 64
+      elsif byte >= 97 && byte <= 122
+        byte - 96
+      end
+    end
+
+    def num_index(byte)
+      if byte >= 48 && byte <= 57
+        byte - 48
+      end
+    end
   end
 end

data/lib/roo/version.rb

@@ -1,3 +1,3 @@
 module Roo
-  VERSION = '2.3.0'
+  VERSION = "2.10.1"
 end

data/lib/roo.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'roo/version'
 require 'roo/constants'
 require 'roo/errors'
 require 'roo/spreadsheet'
@@ -9,6 +12,8 @@ module Roo
   autoload :Excelx,       'roo/excelx'
   autoload :CSV,          'roo/csv'
 
+  TEMP_PREFIX = 'roo_'
+
   CLASS_FOR_EXTENSION = {
     ods: Roo::OpenOffice,
     xlsx: Roo::Excelx,

data/roo.gemspec

@@ -4,22 +4,32 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'roo/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'roo'
-  spec.version       = Roo::VERSION
-  spec.authors       = ['Thomas Preymesser', 'Hugh McGowan', 'Ben Woosley', 'Oleksandr Simonov', 'Steven Daniels']
-  spec.email         = ['ruby.ruby.ruby.roo@gmail.com', 'oleksandr@simonov.me']
-  spec.summary       = 'Roo can access the contents of various spreadsheet files.'
-  spec.description   = "Roo can access the contents of various spreadsheet files. It can handle\n* OpenOffice\n* Excelx\n* LibreOffice\n* CSV"
-  spec.homepage      = 'http://github.com/roo-rb/roo'
-  spec.license       = 'MIT'
+  spec.name                   = 'roo'
+  spec.version                = Roo::VERSION
+  spec.authors                = ['Thomas Preymesser', 'Hugh McGowan', 'Ben Woosley', 'Oleksandr Simonov', 'Steven Daniels', 'Anmol Chopra']
+  spec.email                  = ['ruby.ruby.ruby.roo@gmail.com', 'oleksandr@simonov.me']
+  spec.summary                = 'Roo can access the contents of various spreadsheet files.'
+  spec.description            = "Roo can access the contents of various spreadsheet files. It can handle\n* OpenOffice\n* Excelx\n* LibreOffice\n* CSV"
+  spec.homepage               = 'https://github.com/roo-rb/roo'
+  spec.license                = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files                  = `git ls-files -z`.split("\x0")
   spec.files.reject! { |fn| fn.include?('test/files') }
-  spec.require_paths = ['lib']
+  spec.require_paths          = ['lib']
+
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    spec.required_ruby_version  = ">= 2.6.0"
+  else
+    spec.required_ruby_version  = ">= 2.7.0"
+  end
 
   spec.add_dependency 'nokogiri', '~> 1'
-  spec.add_dependency 'rubyzip', '~> 1.1', '< 2.0.0'
+  spec.add_dependency 'rubyzip', '>= 1.3.0', '< 3.0.0'
 
-  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'minitest', '~> 5.4', '>= 5.4.3'
+  spec.add_development_dependency 'rack', '~> 1.6', '< 2.0.0'
+  if RUBY_VERSION >= '3.0.0'
+    spec.add_development_dependency 'matrix'
+  end
 end