roo 2.0.1 → 2.7.1

data/lib/roo/excelx/cell.rb

@@ -1,12 +1,22 @@
 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 :type, :formula, :value, :excelx_type, :excelx_value, :style, :hyperlink, :coordinate
+      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)
@@ -29,10 +39,29 @@ module Roo
         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
@@ -57,20 +86,20 @@ module Roo
       def create_date(date)
         yyyy, mm, dd = date.strftime('%Y-%m-%d').split('-')
 
-        Date.new(yyyy.to_i, mm.to_i, dd.to_i)
+        ::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)
+        ::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)
+        ::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

data/lib/roo/excelx/comments.rb

@@ -20,3 +20,36 @@ module Roo
     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

@@ -8,10 +8,9 @@ module Roo
       private
 
       def doc
-        @doc ||=
-        if doc_exists?
-          ::Roo::Utils.load_xml(@path).remove_namespaces!
-        end
+        raise FileNotFound, "#{@path} file not found" unless doc_exists?
+
+        ::Roo::Utils.load_xml(@path).remove_namespaces!
       end
 
       def doc_exists?

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/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

@@ -3,6 +3,14 @@ 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
@@ -11,13 +19,32 @@ module Roo
         @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
-        doc.xpath('/sst/si').map do |si|
+        document.xpath('/sst/si').map do |si|
           shared_string = ''
           si.children.each do |elem|
             case elem.name
@@ -32,6 +59,99 @@ module Roo
           shared_string
         end
       end
-    end
-  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

@@ -1,12 +1,17 @@
+require 'forwardable'
 module Roo
   class Excelx
     class Sheet
-      def initialize(name, rels_path, sheet_path, comments_path, styles, shared_strings, workbook, options = {})
+      extend Forwardable
+
+      delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files] => :@shared
+
+      def initialize(name, shared, sheet_index, options = {})
         @name = name
-        @rels = Relationships.new(rels_path)
-        @comments = Comments.new(comments_path)
-        @styles = styles
-        @sheet = SheetDoc.new(sheet_path, @rels, @styles, shared_strings, workbook, options)
+        @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
@@ -14,7 +19,7 @@ module Roo
       end
 
       def present_cells
-        @present_cells ||= cells.select { |_, cell| cell && cell.value }
+        @present_cells ||= cells.select { |_, cell| cell && !cell.empty? }
       end
 
       # Yield each row as array of Excelx::Cell objects
@@ -65,7 +70,7 @@ module Roo
 
       def excelx_format(key)
         cell = cells[key]
-        @styles.style_format(cell.style).to_s if cell
+        styles.style_format(cell.style).to_s if cell
       end
 
       def hyperlinks

data/lib/roo/excelx/sheet_doc.rb

@@ -1,15 +1,17 @@
+require 'forwardable'
 require 'roo/excelx/extractor'
 
 module Roo
   class Excelx
     class SheetDoc < Excelx::Extractor
-      def initialize(path, relationships, styles, shared_strings, workbook, options = {})
+      extend Forwardable
+      delegate [:styles, :workbook, :shared_strings, :base_date] => :@shared
+
+      def initialize(path, relationships, shared, options = {})
         super(path)
+        @shared = shared
         @options = options
         @relationships = relationships
-        @styles = styles
-        @shared_strings = shared_strings
-        @workbook = workbook
       end
 
       def cells(relationships)
@@ -37,83 +39,133 @@ module Roo
       def each_cell(row_xml)
         return [] unless row_xml
         row_xml.children.each do |cell_element|
-          key = ::Roo::Utils.ref_to_key(cell_element['r'])
-          yield cell_from_xml(cell_element, hyperlinks(@relationships)[key])
+          # 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
+
+          yield cell_from_xml(cell_element, hyperlinks)
         end
       end
 
       private
 
-      def cell_from_xml(cell_xml, hyperlink)
-        # This is error prone, to_i will silently turn a nil into a 0
-        # and it works by coincidence that Format[0] is general
-        style = cell_xml['s'].to_i   # should be here
-        # c: <c r="A5" s="2">
-        # <v>22606</v>
-        # </c>, format: , tmp_type: float
-        value_type =
-        case cell_xml['t']
-        when 's'
+      def cell_value_type(type, format)
+        case type
+        when 's'.freeze
           :shared
-        when 'b'
+        when 'b'.freeze
           :boolean
-        when 'str'
+        when 'str'.freeze
           :string
-        when 'inlineStr'
+        when 'inlineStr'.freeze
           :inlinestr
         else
-          format = @styles.style_format(style)
           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.
+      #
+      # Examples
+      #
+      #    cells_from_xml(<Nokogiri::XML::Element>, 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?
+
+        # 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)
         formula = nil
-        row, column = ::Roo::Utils.split_coordinate(cell_xml['r'])
+
         cell_xml.children.each do |cell|
           case cell.name
           when 'is'
-            cell.children.each do |inline_str|
-              if inline_str.name == 't'
-                return Excelx::Cell.new(inline_str.content, :string, formula, :string, inline_str.content, style, hyperlink, @workbook.base_date, Excelx::Cell::Coordinate.new(row, column))
-              end
+            content_arr = cell.search('t').map(&:content)
+            unless content_arr.empty?
+              return Excelx::Cell.create_cell(:string, content_arr.join(''), formula, style, hyperlink, coordinate)
             end
           when 'f'
             formula = cell.content
           when 'v'
-            if [:time, :datetime].include?(value_type) && cell.content.to_f >= 1.0
-              value_type =
-              if (cell.content.to_f - cell.content.to_f.floor).abs > 0.000001
-                :datetime
-              else
-                :date
-              end
-            end
-            excelx_type = [:numeric_or_formula, format.to_s]
-            value =
-            case value_type
-            when :shared
-              value_type = :string
-              excelx_type = :string
-              @shared_strings[cell.content.to_i]
-            when :boolean
-              (cell.content.to_i == 1 ? 'TRUE' : 'FALSE')
-            when :date, :time, :datetime
-              cell.content
-            when :formula
-              cell.content.to_f
-            when :string
-              excelx_type = :string
-              cell.content
-            else
-              value_type = :float
-              cell.content
-            end
-            return Excelx::Cell.new(value, value_type, formula, excelx_type, cell.content, style, hyperlink, @workbook.base_date, Excelx::Cell::Coordinate.new(row, column))
+            return create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, coordinate)
           end
         end
-        Excelx::Cell.new(nil, nil, nil, nil, nil, nil, nil, nil, Excelx::Cell::Coordinate.new(row, column))
+
+        Excelx::Cell::Empty.new(coordinate)
+      end
+
+      def create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, 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
+          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)
+        when :boolean, :string
+          value = cell.content
+          Excelx::Cell.create_cell(value_type, 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
+          Excelx::Cell.create_cell(cell_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+        when :date
+          Excelx::Cell.create_cell(value_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+        else
+          Excelx::Cell.create_cell(:number, 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)
-        Hash[doc.xpath('/worksheet/hyperlinks/hyperlink').map do |hyperlink|
+        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]
           end
@@ -154,47 +206,6 @@ module Roo
           return dimension.attributes['ref'].value
         end
       end
-
-=begin
-Datei 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>Kommentar fuer B4</t>
-          </r>
-        </text>
-      </comment>
-      <comment ref="B5" authorId="0">
-        <text>
-          <r>
-            <rPr>
-            <sz val="10" />
-            <rFont val="Arial" />
-            <family val="2" />
-          </rPr>
-          <t>Kommentar fuer B5</t>
-        </r>
-      </text>
-    </comment>
-  </commentList>
-  </comments>
-=end
-=begin
-    if @comments_doc[self.sheets.index(sheet)]
-      read_comments(sheet)
-    end
-=end
     end
   end
 end