roo 2.1.1 → 2.2.0

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/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/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)
@@ -44,75 +46,118 @@ module Roo
 
       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))
+                return Excelx::Cell.create_cell(:string, inline_str.content, formula, style, hyperlink, coordinate)
               end
             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))
+      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[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)
+        # FIXME: select the valid hyperlinks and then map those.
         Hash[doc.xpath('/worksheet/hyperlinks/hyperlink').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]
@@ -154,47 +199,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

data/lib/roo/link.rb

@@ -1,9 +1,28 @@
+require 'uri'
+
 module Roo
   class Link < String
+    # FIXME: Roo::Link inherits from String. A link cell is_a?(Roo::Link). **It is
+    #        the only situation where a cells `value` is always a String**. Link
+    #        cells have a nifty `to_uri` method, but this method isn't easily
+    #        reached. (e.g. `sheet.sheet_for(nil).cells[[row,column]]).value.to_uri`;
+    #        `sheet.hyperlink(row, column)` doesn't use `to_uri`).
+    #
+    #        1. Add different types of links (String, Numeric, Date, DateTime, etc.)
+    #        2. Remove Roo::Link.
+    #        3. Don't inherit the string and pass the cell's value.
+    #
+    #        I don't know the historical reasons for the Roo::Link, but right now
+    #        it seems uneccessary. I'm in favor of keeping it just in case.
+    #
+    #        I'm also in favor of passing the cell's value to Roo::Link. The
+    #        cell.value's class would still be Roo::Link, but the value itself
+    #        would depend on what type of cell it is (Numeric, Date, etc.).
+    #
     attr_reader :href
-    alias :url :href
+    alias_method :url, :href
 
-    def initialize(href='', text=href)
+    def initialize(href = '', text = href)
       super(text)
       @href = href
     end

data/lib/roo/open_office.rb

@@ -3,6 +3,7 @@ require 'nokogiri'
 require 'cgi'
 require 'zip/filesystem'
 require 'roo/font'
+require 'base64'
 
 module Roo
   class OpenOffice < Roo::Base
@@ -410,7 +411,9 @@ module Roo
       @style[sheet] ||= {}
       @style[sheet][key] = style_name
       case @cell_type[sheet][key]
-      when :float, :percentage
+      when :float
+        @cell[sheet][key] = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
+      when :percentage
         @cell[sheet][key] = v.to_f
       when :string
         @cell[sheet][key] = str_v

data/lib/roo/version.rb

@@ -1,3 +1,3 @@
 module Roo
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/roo.gemspec

@@ -6,7 +6,7 @@ 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']
+  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"