roo 1.13.2 → 2.10.1

data/lib/roo/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roo
+  ROO_EXCEL_NOTICE   = "Excel support has been extracted to roo-xls due to its dependency on the GPL'd spreadsheet gem. Install roo-xls to use Roo::Excel."
+  ROO_EXCELML_NOTICE = "Excel SpreadsheetML support has been extracted to roo-xls. Install roo-xls to use Roo::Excel2003XML."
+  ROO_GOOGLE_NOTICE = "Google support has been extracted to roo-google. Install roo-google to use Roo::Google."
+end

data/lib/roo/csv.rb

@@ -1,113 +1,141 @@
-require 'csv'
-require 'time'
-
-# The CSV class can read csv files (must be separated with commas) which then
-# can be handled like spreadsheets. This means you can access cells like A5
-# within these files.
-# The CSV class provides only string objects. If you want conversions to other
-# types you have to do it yourself.
-#
-# You can pass options to the underlying CSV parse operation, via the
-# :csv_options option.
-#
-
-class Roo::CSV < Roo::Base
-  def initialize(filename, options = {})
-    super
-  end
-
-  attr_reader :filename
-
-  # Returns an array with the names of the sheets. In CSV class there is only
-  # one dummy sheet, because a csv file cannot have more than one sheet.
-  def sheets
-    ['default']
-  end
-
-  def cell(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    @cell[normalize(row,col)]
-  end
-
-  def celltype(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    @cell_type[normalize(row,col)]
-  end
-
-  def cell_postprocessing(row,col,value)
-    value
-  end
-
-  def csv_options
-    @options[:csv_options] || {}
-  end
-
-  private
-
-  TYPE_MAP = {
-    String => :string,
-    Float => :float,
-    Date => :date,
-    DateTime => :datetime,
-  }
-
-  def celltype_class(value)
-    TYPE_MAP[value.class]
-  end
-
-  def each_row(options, &block)
-    if uri?(filename)
-      make_tmpdir do |tmpdir|
-        tmp_filename = download_uri(filename, tmpdir)
-        CSV.foreach(tmp_filename, options, &block)
-      end
-    else
-      CSV.foreach(filename, options, &block)
-    end
-  end
-
-  def read_cells(sheet=nil)
-    sheet ||= @default_sheet
-    return if @cells_read[sheet]
-    @first_row[sheet] = 1
-    @last_row[sheet] = 0
-    @first_column[sheet] = 1
-    @last_column[sheet] = 1
-    rownum = 1
-    each_row csv_options do |row|
-      row.each_with_index do |elem,i|
-        @cell[[rownum,i+1]] = cell_postprocessing rownum,i+1, elem
-        @cell_type[[rownum,i+1]] = celltype_class @cell[[rownum,i+1]]
-        if i+1 > @last_column[sheet]
-          @last_column[sheet] += 1
-        end
-      end
-      rownum += 1
-      @last_row[sheet] += 1
-    end
-    @cells_read[sheet] = true
-    #-- adjust @first_row if neccessary
-    while !row(@first_row[sheet]).any? and @first_row[sheet] < @last_row[sheet]
-      @first_row[sheet] += 1
-    end
-    #-- adjust @last_row if neccessary
-    while !row(@last_row[sheet]).any? and @last_row[sheet] and
-        @last_row[sheet] > @first_row[sheet]
-      @last_row[sheet] -= 1
-    end
-    #-- adjust @first_column if neccessary
-    while !column(@first_column[sheet]).any? and
-          @first_column[sheet] and
-          @first_column[sheet] < @last_column[sheet]
-      @first_column[sheet] += 1
-    end
-    #-- adjust @last_column if neccessary
-    while !column(@last_column[sheet]).any? and
-          @last_column[sheet] and
-          @last_column[sheet] > @first_column[sheet]
-      @last_column[sheet] -= 1
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "csv"
+require "time"
+
+# The CSV class can read csv files (must be separated with commas) which then
+# can be handled like spreadsheets. This means you can access cells like A5
+# within these files.
+# The CSV class provides only string objects. If you want conversions to other
+# types you have to do it yourself.
+#
+# You can pass options to the underlying CSV parse operation, via the
+# :csv_options option.
+module Roo
+  class CSV < Roo::Base
+    attr_reader :filename
+
+    # Returns an array with the names of the sheets. In CSV class there is only
+    # one dummy sheet, because a csv file cannot have more than one sheet.
+    def sheets
+      ["default"]
+    end
+
+    def cell(row, col, sheet = nil)
+      sheet ||= default_sheet
+      read_cells(sheet)
+      @cell[normalize(row, col)]
+    end
+
+    def celltype(row, col, sheet = nil)
+      sheet ||= default_sheet
+      read_cells(sheet)
+      @cell_type[normalize(row, col)]
+    end
+
+    def cell_postprocessing(_row, _col, value)
+      value
+    end
+
+    def csv_options
+      @options[:csv_options] || {}
+    end
+
+    def set_value(row, col, value, _sheet)
+      @cell[[row, col]] = value
+    end
+
+    def set_type(row, col, type, _sheet)
+      @cell_type[[row, col]] = type
+    end
+
+    private
+
+    TYPE_MAP = {
+      String => :string,
+      Float => :float,
+      Date => :date,
+      DateTime => :datetime,
+    }
+
+    def celltype_class(value)
+      TYPE_MAP[value.class]
+    end
+
+    def read_cells(sheet = default_sheet)
+      sheet ||= default_sheet
+      return if @cells_read[sheet]
+      row_num = 0
+      max_col_num = 0
+
+      each_row csv_options do |row|
+        row_num += 1
+        col_num = 0
+
+        row.each do |elem|
+          col_num += 1
+          coordinate = [row_num, col_num]
+          @cell[coordinate] = elem
+          @cell_type[coordinate] = celltype_class(elem)
+        end
+
+        max_col_num = col_num if col_num > max_col_num
+      end
+
+      set_row_count(sheet, row_num)
+      set_column_count(sheet, max_col_num)
+      @cells_read[sheet] = true
+    end
+
+    def each_row(options, &block)
+      if uri?(filename)
+        each_row_using_tempdir(options, &block)
+      else
+        csv_foreach(filename_or_stream, options, &block)
+      end
+    end
+
+    def each_row_using_tempdir(options, &block)
+      ::Dir.mktmpdir(Roo::TEMP_PREFIX, ENV["ROO_TMP"]) do |tmpdir|
+        tmp_filename = download_uri(filename, tmpdir)
+        csv_foreach(tmp_filename, options, &block)
+      end
+    end
+
+    def csv_foreach(path_or_io, options, &block)
+      if is_stream?(path_or_io)
+        ::CSV.new(path_or_io, **options).each(&block)
+      else
+        ::CSV.foreach(path_or_io, **options, &block)
+      end
+    end
+
+    def set_row_count(sheet, last_row)
+      @first_row[sheet] = 1
+      @last_row[sheet] = last_row
+      @last_row[sheet] = @first_row[sheet] if @last_row[sheet].zero?
+
+      nil
+    end
+
+    def set_column_count(sheet, last_col)
+      @first_column[sheet] = 1
+      @last_column[sheet] = last_col
+      @last_column[sheet] = @first_column[sheet] if @last_column[sheet].zero?
+
+      nil
+    end
+
+    def clean_sheet(sheet)
+      read_cells(sheet)
+
+      @cell.each_pair do |coord, value|
+        @cell[coord] = sanitize_value(value) if value.is_a?(::String)
+      end
+
+      @cleaned[sheet] = true
+    end
+
+    alias_method :filename_or_stream, :filename
+  end
+end

data/lib/roo/errors.rb

@@ -0,0 +1,11 @@
+module Roo
+  # A base error class for Roo. Most errors thrown by Roo should inherit from
+  # this class.
+  class Error < StandardError; end
+
+  # Raised when Roo cannot find a header row that matches the given column
+  # name(s).
+  class HeaderRowNotFoundError < Error; end
+
+  class FileNotFound < Error; end
+end

data/lib/roo/excelx/cell/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "roo/helpers/default_attr_reader"
+
+module Roo
+  class Excelx
+    class Cell
+      class Base
+        extend Roo::Helpers::DefaultAttrReader
+        attr_reader :cell_type, :cell_value, :value
+
+        # FIXME: I think style should be deprecated. Having a style attribute
+        #        for a cell doesn't really accomplish much. It seems to be used
+        #        when you want to export to excelx.
+        attr_reader_with_default default_type: :base, style: 1
+
+
+        # FIXME: Updating a cell's value should be able tochange the cell's type,
+        #        but that isn't currently possible. This will cause weird bugs
+        #        when one changes the value of a Number cell to a String. e.g.
+        #
+        #           cell = Cell::Number(*args)
+        #           cell.value = 'Hello'
+        #           cell.formatted_value # => Some unexpected value
+        #
+        #        Here are two possible solutions to such issues:
+        #        1. Don't allow a cell's value to be updated. Use a method like
+        #          `Sheet.update_cell` instead. The simple solution.
+        #        2. When `cell.value = ` is called, use injection to try and
+        #           change the type of cell on the fly. But deciding what type
+        #           of value to pass to `cell.value=`. isn't always obvious. e.g.
+        #           `cell.value = Time.now` should convert a cell to a DateTime,
+        #           not a Time cell. Time cells would be hard to recognize because
+        #           they are integers. This approach would require a significant
+        #           change to the code as written. The complex solution.
+        #
+        #        If the first solution is used, then this method should be
+        #        deprecated.
+        attr_writer :value
+
+        def initialize(value, formula, excelx_type, style, link, coordinate)
+          @cell_value = value
+          @cell_type = excelx_type if excelx_type
+          @formula = formula if formula
+          @style = style unless style == 1
+          @coordinate = coordinate
+          @value = link ? Roo::Link.new(link, value) : value
+        end
+
+        def type
+          if formula?
+            :formula
+          elsif link?
+            :link
+          else
+            default_type
+          end
+        end
+
+        def formula?
+          !!(defined?(@formula) && @formula)
+        end
+
+        def link?
+          Roo::Link === @value
+        end
+
+        alias_method :formatted_value, :value
+
+        def to_s
+          formatted_value
+        end
+
+        # DEPRECATED: Please use link? instead.
+        def hyperlink
+          warn '[DEPRECATION] `hyperlink` is deprecated.  Please use `link?` instead.'
+          link?
+        end
+
+        # DEPRECATED: Please use link? instead.
+        def link
+          warn '[DEPRECATION] `link` is deprecated.  Please use `link?` instead.'
+          link?
+        end
+
+        # DEPRECATED: Please use cell_value instead.
+        def excelx_value
+          warn '[DEPRECATION] `excelx_value` is deprecated.  Please use `cell_value` instead.'
+          cell_value
+        end
+
+        # DEPRECATED: Please use cell_type instead.
+        def excelx_type
+          warn '[DEPRECATION] `excelx_type` is deprecated.  Please use `cell_type` instead.'
+          cell_type
+        end
+
+        def empty?
+          false
+        end
+
+        def presence
+          empty? ? nil : self
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell/boolean.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Roo
+  class Excelx
+    class Cell
+      class Boolean < Cell::Base
+        attr_reader :value, :formula, :format, :cell_value, :coordinate
+
+        attr_reader_with_default default_type: :boolean, cell_type: :boolean
+
+        def initialize(value, formula, style, link, coordinate)
+          super(value, formula, nil, style, nil, coordinate)
+          @value = link ? Roo::Link.new(link, value) : create_boolean(value)
+        end
+
+        def formatted_value
+          value ? 'TRUE' : 'FALSE'
+        end
+
+        private
+
+        def create_boolean(value)
+          # FIXME: Using a boolean will cause methods like Base#to_csv to fail.
+          #       Roo is using some method to ignore false/nil values.
+          value.to_i == 1
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell/date.rb

@@ -0,0 +1,28 @@
+require 'date'
+
+module Roo
+  class Excelx
+    class Cell
+      class Date < Roo::Excelx::Cell::DateTime
+        attr_reader :value, :formula, :format, :cell_type, :cell_value, :coordinate
+
+        attr_reader_with_default default_type: :date
+
+        def initialize(value, formula, excelx_type, style, link, base_date, coordinate)
+          # NOTE: Pass all arguments to the parent class, DateTime.
+          super
+          @format = excelx_type.last
+          @value = link ? Roo::Link.new(link, value) : create_date(base_date, value)
+        end
+
+        private
+
+        def create_datetime(_,_);  end
+
+        def create_date(base_date, value)
+          base_date + value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell/datetime.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Roo
+  class Excelx
+    class Cell
+      class DateTime < Cell::Base
+        SECONDS_IN_DAY = 60 * 60 * 24
+
+        attr_reader :value, :formula, :format, :cell_value, :coordinate
+
+        attr_reader_with_default default_type: :datetime
+
+        def initialize(value, formula, excelx_type, style, link, base_timestamp, coordinate)
+          super(value, formula, excelx_type, style, nil, coordinate)
+          @format = excelx_type.last
+          @value = link ? Roo::Link.new(link, value) : create_datetime(base_timestamp, value)
+        end
+
+        # Public: Returns formatted value for a datetime. Format's can be an
+        #         standard excel format, or a custom format.
+        #
+        #         Standard formats follow certain conventions. Date fields for
+        #         days, months, and years are separated with hyhens or
+        #         slashes ("-", /") (e.g. 01-JAN, 1/13/15). Time fields for
+        #         hours, minutes, and seconds are separated with a colon (e.g.
+        #         12:45:01).
+        #
+        #         If a custom format follows those conventions, then the custom
+        #         format will be used for the a cell's formatted value.
+        #         Otherwise, the formatted value will be in the following
+        #         format: 'YYYY-mm-dd HH:MM:SS' (e.g. "2015-07-10 20:33:15").
+        #
+        # Examples
+        #    formatted_value #=> '01-JAN'
+        #
+        # Returns a String representation of a cell's value.
+        def formatted_value
+          formatter = @format.downcase.split(' ').map do |part|
+            if (parsed_format = parse_date_or_time_format(part))
+              parsed_format
+            else
+              warn 'Unable to parse custom format. Using "YYYY-mm-dd HH:MM:SS" format.'
+              return @value.strftime('%F %T')
+            end
+          end.join(' ')
+
+          @value.strftime(formatter)
+        end
+
+        private
+
+        def parse_date_or_time_format(part)
+          date_regex = /(?<date>[dmy]+[\-\/][dmy]+([\-\/][dmy]+)?)/
+          time_regex = /(?<time>(\[?[h]\]?+:)?[m]+(:?ss|:?s)?)/
+
+          if part[date_regex] == part
+            formats = DATE_FORMATS
+          elsif part[time_regex]
+            formats = TIME_FORMATS
+          else
+            return false
+          end
+
+          part.gsub(/#{formats.keys.join('|')}/, formats)
+        end
+
+        DATE_FORMATS = {
+          'yyyy' => '%Y',  # Year: 2000
+          'yy' => '%y',    # Year: 00
+          # mmmmm => J-D
+          'mmmm' => '%B',  # Month: January
+          'mmm' => '%^b',   # Month: JAN
+          'mm' => '%m',    # Month: 01
+          'm' => '%-m',    # Month: 1
+          'dddd' => '%A',  # Day of the Week: Sunday
+          'ddd' => '%^a',   # Day of the Week: SUN
+          'dd' => '%d',    # Day of the Month: 01
+          'd' => '%-d'    # Day of the Month: 1
+          # '\\\\'.freeze => ''.freeze,  # NOTE: Fixes a custom format's output.
+        }
+
+        TIME_FORMATS = {
+          'hh' => '%H',    # Hour (24): 01
+          'h' => '%-k',    # Hour (24): 1
+          # 'hh'.freeze => '%I'.freeze,    # Hour (12): 08
+          # 'h'.freeze => '%-l'.freeze,    # Hour (12): 8
+          'mm' => '%M',    # Minute: 01
+          # FIXME: is this used? Seems like 'm' is used for month, not minute.
+          'm' => '%-M',    # Minute: 1
+          'ss' => '%S',    # Seconds: 01
+          's' => '%-S',    # Seconds: 1
+          'am/pm' => '%p', # Meridian: AM
+          '000' => '%3N',  # Fractional Seconds: thousandth.
+          '00' => '%2N',   # Fractional Seconds: hundredth.
+          '0' => '%1N'    # Fractional Seconds: tenths.
+        }
+
+        def create_datetime(base_timestamp, value)
+          timestamp = (base_timestamp + (value.to_f.round(6) * SECONDS_IN_DAY)).round(0)
+          ::Time.at(timestamp).utc.to_datetime
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell/empty.rb

@@ -0,0 +1,20 @@
+
+module Roo
+  class Excelx
+    class Cell
+      class Empty < Cell::Base
+        attr_reader :value, :formula, :format, :cell_type, :cell_value, :coordinate
+
+        attr_reader_with_default default_type: nil, style: nil
+
+        def initialize(coordinate)
+          @coordinate = coordinate
+        end
+
+        def empty?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell/number.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Roo
+  class Excelx
+    class Cell
+      class Number < Cell::Base
+        attr_reader :value, :formula, :format, :cell_value, :coordinate
+
+        # FIXME: change default_type to number. This will break brittle tests.
+        attr_reader_with_default default_type: :float
+
+        def initialize(value, formula, excelx_type, style, link, coordinate)
+          super
+          # FIXME: Excelx_type is an array, but the first value isn't used.
+          @format = excelx_type.last
+          @value = link ? Roo::Link.new(link, value) : create_numeric(value)
+        end
+
+        def create_numeric(number)
+          return number if Excelx::ERROR_VALUES.include?(number)
+          case @format
+          when /%/
+            Float(number)
+          when /\.0/
+            Float(number)
+          else
+            (number.include?('.') || (/\A[-+]?\d+E[-+]?\d+\z/i =~ number)) ? Float(number) : Integer(number, 10)
+          end
+        end
+
+        def formatted_value
+          return @cell_value if Excelx::ERROR_VALUES.include?(@cell_value)
+
+          formatter = generate_formatter(@format)
+          if formatter.is_a? Proc
+            formatter.call(@cell_value)
+          else
+            Kernel.format(formatter, @cell_value)
+          end
+        end
+
+        def generate_formatter(format)
+          # FIXME: numbers can be other colors besides red:
+          # [BLACK], [BLUE], [CYAN], [GREEN], [MAGENTA], [RED], [WHITE], [YELLOW], [COLOR n]
+          case format
+          when /^General$/i then '%.0f'
+          when '0' then '%.0f'
+          when /^(0+)$/ then "%0#{$1.size}d"
+          when /^0\.(0+)$/ then "%.#{$1.size}f"
+          when '#,##0' then number_format('%.0f')
+          when /^#,##0.(0+)$/ then number_format("%.#{$1.size}f")
+          when '0%'
+            proc do |number|
+              Kernel.format('%.0f%%', number.to_f * 100)
+            end
+          when '0.00%'
+            proc do |number|
+              Kernel.format('%.2f%%', number.to_f * 100)
+            end
+          when '0.00E+00' then '%.2E'
+          when '#,##0 ;(#,##0)' then number_format('%.0f', '(%.0f)')
+          when '#,##0 ;[Red](#,##0)' then number_format('%.0f', '[Red](%.0f)')
+          when '#,##0.00;(#,##0.00)' then number_format('%.2f', '(%.2f)')
+          when '#,##0.00;[Red](#,##0.00)' then number_format('%.2f', '[Red](%.2f)')
+            # FIXME: not quite sure what the format should look like in this case.
+          when '##0.0E+0' then '%.1E'
+          when "_-* #,##0.00\\ _€_-;\\-* #,##0.00\\ _€_-;_-* \"-\"??\\ _€_-;_-@_-" then number_format('%.2f', '-%.2f')
+          when '@' then proc { |number| number }
+          when /^(?:_\()?"([^"]*)"(?:\* )?([^_]+)/
+            proc do |number|
+              formatted_number = generate_formatter($2).call(number)
+              "#{$1}#{formatted_number}"
+            end
+          when /^_[- \(]\[\$([^-]*)[^#@]+([^_]+)/
+            proc do |number|
+              formatted_number = generate_formatter($2).call(number)
+              "#{$1}#{formatted_number}"
+            end
+          else
+            raise "Unknown format: #{format.inspect}"
+          end
+        end
+
+        private
+
+        def number_format(formatter, negative_formatter = nil)
+          proc do |number|
+            if negative_formatter
+              formatter = number.to_i > 0 ? formatter : negative_formatter
+              number = number.to_f.abs
+            end
+
+            Kernel.format(formatter, number).reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+          end
+        end
+      end
+    end
+  end
+end