roo 1.13.2 → 2.7.0

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

@@ -0,0 +1,43 @@
+require 'date'
+
+module Roo
+  class Excelx
+    class Cell
+      class Time < Roo::Excelx::Cell::DateTime
+        attr_reader :value, :formula, :format, :cell_value, :link, :coordinate
+
+        def initialize(value, formula, excelx_type, style, link, base_date, coordinate)
+          # NOTE: Pass all arguments to DateTime super class.
+          super
+          @type = :time
+          @format = excelx_type.last
+          @datetime = create_datetime(base_date, value)
+          @value = link? ? Roo::Link.new(link, value) : (value.to_f * 86_400).to_i
+        end
+
+        def formatted_value
+          formatter = @format.gsub(/#{TIME_FORMATS.keys.join('|')}/, TIME_FORMATS)
+          @datetime.strftime(formatter)
+        end
+
+        alias_method :to_s, :formatted_value
+
+        private
+
+        # def create_datetime(base_date, value)
+        #   date = base_date + value.to_f.round(6)
+        #   datetime_string = date.strftime('%Y-%m-%d %H:%M:%S.%N')
+        #   t = round_datetime(datetime_string)
+        #
+        #   ::DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        # end
+
+        # def round_datetime(datetime_string)
+        #   /(?<yyyy>\d+)-(?<mm>\d+)-(?<dd>\d+) (?<hh>\d+):(?<mi>\d+):(?<ss>\d+.\d+)/ =~ datetime_string
+        #
+        #   ::Time.new(yyyy.to_i, mm.to_i, dd.to_i, hh.to_i, mi.to_i, ss.to_r).round(0)
+        # end
+      end
+    end
+  end
+end

data/lib/roo/excelx/cell.rb

@@ -0,0 +1,106 @@
+require 'date'
+require 'roo/excelx/cell/base'
+require 'roo/excelx/cell/boolean'
+require 'roo/excelx/cell/datetime'
+require 'roo/excelx/cell/date'
+require 'roo/excelx/cell/empty'
+require 'roo/excelx/cell/number'
+require 'roo/excelx/cell/string'
+require 'roo/excelx/cell/time'
+
+module Roo
+  class Excelx
+    class Cell
+      attr_reader :formula, :value, :excelx_type, :excelx_value, :style, :hyperlink, :coordinate
+      attr_writer :value
+
+      # DEPRECATED: Please use Cell.create_cell instead.
+      def initialize(value, type, formula, excelx_type, excelx_value, style, hyperlink, base_date, coordinate)
+        warn '[DEPRECATION] `Cell.new` is deprecated.  Please use `Cell.create_cell` instead.'
+        @type = type
+        @formula = formula
+        @base_date = base_date if [:date, :datetime].include?(@type)
+        @excelx_type = excelx_type
+        @excelx_value = excelx_value
+        @style = style
+        @value = type_cast_value(value)
+        @value = Roo::Link.new(hyperlink, @value.to_s) if hyperlink
+        @coordinate = coordinate
+      end
+
+      def type
+        case
+        when @formula
+          :formula
+        when @value.is_a?(Roo::Link)
+          :link
+        else
+          @type
+        end
+      end
+
+      def self.create_cell(type, *values)
+        case type
+        when :string
+          Cell::String.new(*values)
+        when :boolean
+          Cell::Boolean.new(*values)
+        when :number
+          Cell::Number.new(*values)
+        when :date
+          Cell::Date.new(*values)
+        when :datetime
+          Cell::DateTime.new(*values)
+        when :time
+          Cell::Time.new(*values)
+        end
+      end
+
+      # Deprecated: use Roo::Excelx::Coordinate instead.
+      class Coordinate
+        attr_accessor :row, :column
+
+        def initialize(row, column)
+          warn '[DEPRECATION] `Roo::Excel::Cell::Coordinate` is deprecated.  Please use `Roo::Excelx::Coordinate` instead.'
+          @row, @column = row, column
+        end
+      end
+
+      private
+
+      def type_cast_value(value)
+        case @type
+        when :float, :percentage
+          value.to_f
+        when :date
+          create_date(@base_date + value.to_i)
+        when :datetime
+          create_datetime(@base_date + value.to_f.round(6))
+        when :time
+          value.to_f * 86_400
+        else
+          value
+        end
+      end
+
+      def create_date(date)
+        yyyy, mm, dd = date.strftime('%Y-%m-%d').split('-')
+
+        ::Date.new(yyyy.to_i, mm.to_i, dd.to_i)
+      end
+
+      def create_datetime(date)
+        datetime_string = date.strftime('%Y-%m-%d %H:%M:%S.%N')
+        t = round_datetime(datetime_string)
+
+        ::DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+      end
+
+      def round_datetime(datetime_string)
+        /(?<yyyy>\d+)-(?<mm>\d+)-(?<dd>\d+) (?<hh>\d+):(?<mi>\d+):(?<ss>\d+.\d+)/ =~ datetime_string
+
+        ::Time.new(yyyy.to_i, mm.to_i, dd.to_i, hh.to_i, mi.to_i, ss.to_r).round(0)
+      end
+    end
+  end
+end

data/lib/roo/excelx/comments.rb

@@ -0,0 +1,55 @@
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class Comments < Excelx::Extractor
+      def comments
+        @comments ||= extract_comments
+      end
+
+      private
+
+      def extract_comments
+        return {} unless doc_exists?
+
+        Hash[doc.xpath('//comments/commentList/comment').map do |comment|
+          value = (comment.at_xpath('./text/r/t') || comment.at_xpath('./text/t')).text
+          [::Roo::Utils.ref_to_key(comment.attributes['ref'].to_s), value]
+        end]
+      end
+    end
+  end
+end
+# xl/comments1.xml
+#   <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+#   <comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+#     <authors>
+#       <author />
+#     </authors>
+#     <commentList>
+#       <comment ref="B4" authorId="0">
+#         <text>
+#           <r>
+#             <rPr>
+#               <sz val="10" />
+#               <rFont val="Arial" />
+#               <family val="2" />
+#             </rPr>
+#             <t>Comment for B4</t>
+#           </r>
+#         </text>
+#       </comment>
+#       <comment ref="B5" authorId="0">
+#         <text>
+#           <r>
+#             <rPr>
+#             <sz val="10" />
+#             <rFont val="Arial" />
+#             <family val="2" />
+#           </rPr>
+#             <t>Comment for B5</t>
+#           </r>
+#         </text>
+#       </comment>
+#     </commentList>
+#   </comments>

data/lib/roo/excelx/coordinate.rb

@@ -0,0 +1,12 @@
+module Roo
+  class Excelx
+    class Coordinate
+      attr_accessor :row, :column
+
+      def initialize(row, column)
+        @row = row
+        @column = column
+      end
+    end
+  end
+end

data/lib/roo/excelx/extractor.rb

@@ -0,0 +1,21 @@
+module Roo
+  class Excelx
+    class Extractor
+      def initialize(path)
+        @path = path
+      end
+
+      private
+
+      def doc
+        raise FileNotFound, "#{@path} file not found" unless doc_exists?
+
+        ::Roo::Utils.load_xml(@path).remove_namespaces!
+      end
+
+      def doc_exists?
+        @path && File.exist?(@path)
+      end
+    end
+  end
+end

data/lib/roo/excelx/format.rb

@@ -0,0 +1,64 @@
+module Roo
+  class Excelx
+    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
+  end 
+end

data/lib/roo/excelx/relationships.rb

@@ -0,0 +1,25 @@
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class Relationships < Excelx::Extractor
+      def [](index)
+        to_a[index]
+      end
+
+      def to_a
+        @relationships ||= extract_relationships
+      end
+
+      private
+
+      def extract_relationships
+        return [] unless doc_exists?
+
+        Hash[doc.xpath('/Relationships/Relationship').map do |rel|
+          [rel.attribute('Id').text, rel]
+        end]
+      end
+    end
+  end
+end

data/lib/roo/excelx/shared.rb

@@ -0,0 +1,32 @@
+module Roo
+  class Excelx
+    # Public:  Shared class for allowing sheets to share data. This should
+    #          reduce memory usage and reduce the number of objects being passed
+    #          to various inititializers.
+    class Shared
+      attr_accessor :comments_files, :sheet_files, :rels_files
+      def initialize(dir)
+        @dir = dir
+        @comments_files = []
+        @sheet_files = []
+        @rels_files = []
+      end
+
+      def styles
+        @styles ||= Styles.new(File.join(@dir, 'roo_styles.xml'))
+      end
+
+      def shared_strings
+        @shared_strings ||= SharedStrings.new(File.join(@dir, 'roo_sharedStrings.xml'))
+      end
+
+      def workbook
+        @workbook ||= Workbook.new(File.join(@dir, 'roo_workbook.xml'))
+      end
+
+      def base_date
+        workbook.base_date
+      end
+    end
+  end
+end

data/lib/roo/excelx/shared_strings.rb

@@ -0,0 +1,157 @@
+require 'roo/excelx/extractor'
+
+module Roo
+  class Excelx
+    class SharedStrings < Excelx::Extractor
+
+      COMMON_STRINGS = {
+        t: "t",
+        r: "r",
+        html_tag_open: "<html>",
+        html_tag_closed: "</html>"
+      }
+
+      def [](index)
+        to_a[index]
+      end
+
+      def to_a
+        @array ||= extract_shared_strings
+      end
+
+      def to_html
+        @html ||= extract_html
+      end
+
+      # Use to_html or to_a for html returns
+      # See what is happening with commit???
+      def use_html?(index)
+        to_html[index][/<([biu]|sup|sub)>/]
+      end
+
+      private
+
+      def fix_invalid_shared_strings(doc)
+        invalid = { '_x000D_'  => "\n" }
+        xml = doc.to_s
+        return doc unless xml[/#{invalid.keys.join('|')}/]
+
+        ::Nokogiri::XML(xml.gsub(/#{invalid.keys.join('|')}/, invalid))
+      end
+
+      def extract_shared_strings
+        return [] unless doc_exists?
+
+        document = fix_invalid_shared_strings(doc)
+        # read the shared strings xml document
+        document.xpath('/sst/si').map do |si|
+          shared_string = ''
+          si.children.each do |elem|
+            case elem.name
+            when 'r'
+              elem.children.each do |r_elem|
+                shared_string << r_elem.content if r_elem.name == 't'
+              end
+            when 't'
+              shared_string = elem.content
+            end
+          end
+          shared_string
+        end
+      end
+
+      def extract_html
+        return [] unless doc_exists?
+        fix_invalid_shared_strings(doc)
+        # read the shared strings xml document
+        doc.xpath('/sst/si').map do |si|
+          html_string = '<html>'
+          si.children.each do |elem|
+            case elem.name
+            when 'r'
+              html_string << extract_html_r(elem)
+            when 't'
+              html_string << elem.content
+            end # case elem.name
+          end # si.children.each do |elem|
+          html_string << '</html>'
+        end # doc.xpath('/sst/si').map do |si|
+      end # def extract_html
+
+      # The goal of this function is to take the following XML code snippet and create a html tag
+      # r_elem ::: XML Element that is in sharedStrings.xml of excel_book.xlsx
+      # {code:xml}
+      # <r>
+      #   <rPr>
+      #      <i/>
+      #      <b/>
+      #      <u/>
+      #      <vertAlign val="subscript"/>
+      #      <vertAlign val="superscript"/>
+      #   </rPr>
+      #   <t>TEXT</t>
+      # </r>
+      # {code}
+      #
+      # Expected Output ::: "<html><sub|sup><b><i><u>TEXT</u></i></b></sub|/sup></html>"
+      def extract_html_r(r_elem)
+        str = ''
+        xml_elems = {
+          sub: false,
+          sup: false,
+          b:   false,
+          i:   false,
+          u:   false
+        }
+        b, i, u, sub, sup = false, false, false, false, false
+        r_elem.children.each do |elem|
+          case elem.name
+          when 'rPr'
+            elem.children.each do |rPr_elem|
+              case rPr_elem.name
+              when 'b'
+                # set formatting for Bold to true
+                xml_elems[:b] = true
+              when 'i'
+                # set formatting for Italics to true
+                xml_elems[:i] = true
+              when 'u'
+                # set formatting for Underline to true
+                xml_elems[:u] = true
+              when 'vertAlign'
+                # See if the Vertical Alignment is subscript or superscript
+                case rPr_elem.xpath('@val').first.value
+                when 'subscript'
+                  # set formatting for Subscript to true and Superscript to false ... Can't have both
+                  xml_elems[:sub] = true
+                  xml_elems[:sup] = false
+                when 'superscript'
+                  # set formatting for Superscript to true and Subscript to false ... Can't have both
+                  xml_elems[:sup] = true
+                  xml_elems[:sub] = false
+                end
+              end
+            end
+          when 't'
+            str << create_html(elem.content, xml_elems)
+          end
+        end
+        str
+      end # extract_html_r
+
+      # This will return an html string
+      def create_html(text, formatting)
+        tmp_str = ''
+        formatting.each do |elem, val|
+          tmp_str << "<#{elem}>" if val
+        end
+        tmp_str << text
+        reverse_format = Hash[formatting.to_a.reverse]
+        reverse_format.each do |elem, val|
+          tmp_str << "</#{elem}>" if val
+        end
+        tmp_str
+      end
+    end # class SharedStrings < Excelx::Extractor
+  end # class Excelx
+end # module Roo

data/lib/roo/excelx/sheet.rb

@@ -0,0 +1,112 @@
+require 'forwardable'
+module Roo
+  class Excelx
+    class Sheet
+      extend Forwardable
+
+      delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files] => :@shared
+
+      def initialize(name, shared, sheet_index, options = {})
+        @name = name
+        @shared = shared
+        @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 ||= cells.select { |_, cell| cell && !cell.empty? }
+      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]]
+        end.map { |cell| cell && cell.value }
+      end
+
+      def column(col_number)
+        first_row.upto(last_row).map do |row|
+          cells[[row, col_number]]
+        end.map { |cell| cell && cell.value }
+      end
+
+      # returns the number of the first non-empty row
+      def first_row
+        @first_row ||= present_cells.keys.map { |row, _| row }.min
+      end
+
+      def last_row
+        @last_row ||= present_cells.keys.map { |row, _| row }.max
+      end
+
+      # returns the number of the first non-empty column
+      def first_column
+        @first_column ||= present_cells.keys.map { |_, col| col }.min
+      end
+
+      # returns the number of the last non-empty column
+      def last_column
+        @last_column ||= present_cells.keys.map { |_, col| col }.max
+      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
+    end
+  end
+end