axlsx 1.0.17 → 1.1.0

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -1,61 +1,66 @@
 # encoding: UTF-8
+require 'cgi'
 module Axlsx
-  # A cell in a worksheet. 
+  # A cell in a worksheet.
   # Cell stores inforamation requried to serialize a single worksheet cell to xml. You must provde the Row that the cell belongs to and the cells value. The data type will automatically be determed if you do not specify the :type option. The default style will be applied if you do not supply the :style option. Changing the cell's type will recast the value to the type specified. Altering the cell's value via the property accessor will also automatically cast the provided value to the cell's type.
   # @example Manually creating and manipulating Cell objects
-  #   ws = Workbook.new.add_worksheet 
+  #   ws = Workbook.new.add_worksheet
   #   # This is the simple, and recommended way to create cells. Data types will automatically be determined for you.
   #   ws.add_row :values => [1,"fish",Time.now]
   #
   #   # but you can also do this
   #   r = ws.add_row
   #   r.add_cell 1
-  # 
+  #
   #   # or even this
   #   r = ws.add_row
   #   c = Cell.new row, 1, :value=>integer
   #
   #   # cells can also be accessed via Row#cells. The example here changes the cells type, which will automatically updated the value from 1 to 1.0
   #   r.cells.last.type = :float
-  # 
+  #
   # @note The recommended way to generate cells is via Worksheet#add_row
-  # 
+  #
   # @see Worksheet#add_row
   class Cell
 
 
     # An array of available inline styes.
-    INLINE_STYLES = ['value', 'type', 'font_name', 'charset', 
-                         'family', 'b', 'i', 'strike','outline', 
-                         'shadow', 'condense', 'extend', 'u', 
+    # TODO change this to a hash where each key defines attr name and validator (and any info the validator requires)
+    # then move it out to a module so we can re-use in in other classes.
+    # needs to define bla=(v) and bla methods on the class that hook into a
+    # set_attr method that kicks the suplied validator and updates the instance_variable
+    # for the key
+    INLINE_STYLES = ['value', 'type', 'font_name', 'charset',
+                         'family', 'b', 'i', 'strike','outline',
+                         'shadow', 'condense', 'extend', 'u',
                          'vertAlign', 'sz', 'color', 'scheme']
 
-
     # The index of the cellXfs item to be applied to this cell.
-    # @return [Integer] 
+    # @return [Integer]
     # @see Axlsx::Styles
     attr_reader :style
 
     # The row this cell belongs to.
     # @return [Row]
     attr_reader :row
-    
-    # The cell's data type. Currently only four types are supported, :time, :float, :integer and :string.
-    # Changing the type for a cell will recast the value into that type. If no type option is specified in the constructor, the type is 
+
+    # The cell's data type. Currently only six types are supported, :date, :time, :float, :integer, :string and :boolean.
+    # Changing the type for a cell will recast the value into that type. If no type option is specified in the constructor, the type is
     # automatically determed.
     # @see Cell#cell_type_from_value
-    # @return [Symbol] The type of data this cell's value is cast to. 
-    # @raise [ArgumentExeption] Cell.type must be one of [:time, :float, :integer, :string]
-    # @note 
+    # @return [Symbol] The type of data this cell's value is cast to.
+    # @raise [ArgumentExeption] Cell.type must be one of [:date, time, :float, :integer, :string, :boolean]
+    # @note
     #  If the value provided cannot be cast into the type specified, type is changed to :string and the following logic is applied.
-    #   :string to :integer or :float, type coversions always return 0 or 0.0    
+    #   :string to :integer or :float, type conversions always return 0 or 0.0
     #   :string, :integer, or :float to :time conversions always return the original value as a string and set the cells type to :string.
     #  No support is currently implemented for parsing time strings.
     attr_reader :type
     # @see type
-    def type=(v) 
-      RestrictionValidator.validate "Cell.type", [:time, :float, :integer, :string], v      
-      @type=v 
+    def type=(v)
+      RestrictionValidator.validate "Cell.type", [:date, :time, :float, :integer, :string, :boolean], v
+      @type=v
       self.value = @value unless @value.nil?
     end
 
@@ -68,103 +73,118 @@ module Axlsx
       #TODO: consider doing value based type determination first?
       @value = cast_value(v)
     end
-    
+
+
+    # Indicates that the cell has one or more of the custom cell styles applied.
+    # @return [Boolean]
+    def is_text_run?
+      @is_text_run ||= false
+    end
+
+
     # The inline font_name property for the cell
     # @return [String]
     attr_reader :font_name
     # @see font_name
-    def font_name=(v) Axlsx::validate_string(v); @font_name = v; end
+    def font_name=(v) set_run_style :validate_string, :font_name, v; end
 
     # The inline charset property for the cell
     # @return [String]
     attr_reader :charset
     # @see charset
-    def charset=(v) Axlsx::validate_unsigned_int(v); @charset = v; end
+    def charset=(v) set_run_style :validate_unsigned_int, :charset, v; end
 
     # The inline family property for the cell
     # @return [String]
     attr_reader :family
     # @see family
-    def family=(v) Axlsx::validate_string(v); @family = v; end
+    def family=(v) set_run_style :validate_string, :family, v; end
 
     # The inline bold property for the cell
     # @return [Boolean]
     attr_reader :b
     # @see b
-    def b=(v) Axlsx::validate_boolean(v); @b = v; end
+    def b=(v) set_run_style :validate_boolean, :b, v; end
 
     # The inline italic property for the cell
     # @return [Boolean]
     attr_reader :i
     # @see i
-    def i=(v) Axlsx::validate_boolean(v); @i = v; end
+    def i=(v) set_run_style :validate_boolean, :i, v; end
 
     # The inline strike property for the cell
     # @return [Boolean]
     attr_reader :strike
     # @see strike
-    def strike=(v) Axlsx::validate_boolean(v); @strike = v; end
+    def strike=(v) set_run_style :validate_boolean, :strike, v; end
 
     # The inline outline property for the cell
     # @return [Boolean]
     attr_reader :outline
     # @see outline
-    def outline=(v) Axlsx::validate_boolean(v); @outline = v; end
+    def outline=(v) set_run_style :validate_boolean, :outline, v; end
 
     # The inline shadow property for the cell
     # @return [Boolean]
     attr_reader :shadow
     # @see shadow
-    def shadow=(v) Axlsx::validate_boolean(v); @shadow = v; end
+    def shadow=(v) set_run_style :validate_boolean, :shadow, v; end
 
     # The inline condense property for the cell
     # @return [Boolean]
     attr_reader :condense
     # @see condense
-    def condense=(v) Axlsx::validate_boolean(v); @condense = v; end
+    def condense=(v) set_run_style :validate_boolean, :condense, v; end
 
     # The inline extend property for the cell
     # @return [Boolean]
     attr_reader :extend
     # @see extend
-    def extend=(v) Axlsx::validate_boolean(v); @extend = v; end
+    def extend=(v) set_run_style :validate_boolean, :extend, v; end
 
     # The inline underline property for the cell
     # @return [Boolean]
     attr_reader :u
     # @see u
-    def u=(v) Axlsx::validate_boolean(v); @u = v; end
+    def u=(v) set_run_style :validate_boolean, :u, v; end
 
     # The inline color property for the cell
     # @return [Color]
     attr_reader :color
     # @param [String] The 8 character representation for an rgb color #FFFFFFFF"
-    def color=(v) 
+    def color=(v)
       @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+      @has_run_style = true
     end
 
     # The inline sz property for the cell
     # @return [Boolean]
     attr_reader :sz
     # @see sz
-    def sz=(v) Axlsx::validate_unsigned_int(v); @sz = v; end
+    def sz=(v) set_run_style :validate_unsigned_int, :sz, v; end
 
     # The inline vertical alignment property for the cell
     # this must be one of [:baseline, :subscript, :superscript]
     # @return [Symbol]
     attr_reader :vertAlign
     # @see vertAlign
-    def vertAlign=(v) RestrictionValidator.validate "Cell.vertAlign", [:baseline, :subscript, :superscript], v; @vertAlign = v; end
+    def vertAlign=(v)
+      RestrictionValidator.validate "Cell.vertAlign", [:baseline, :subscript, :superscript], v
+      set_run_style nil, :vertAlign, v
+    end
 
     # The inline scheme property for the cell
     # this must be one of [:none, major, minor]
     # @return [Symbol]
     attr_reader :scheme
     # @see scheme
-    def scheme=(v) RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v; @scheme = v; end
+    def scheme=(v)
+      RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v
+      set_run_style nil, :scheme, v
+    end
 
     # @param [Row] row The row this cell belongs to.
-    # @param [Any] value The value associated with this cell. 
+    # @param [Any] value The value associated with this cell.
     # @option options [Symbol] type The intended data type for this cell. If not specified the data type will be determined internally based on the vlue provided.
     # @option options [Integer] style The index of the cellXfs item to be applied to this cell. If not specified, the default style (0) will be applied.
     # @option options [String] font_name
@@ -183,9 +203,11 @@ module Axlsx
     # @option options [String] color an 8 letter rgb specification
     # @option options [Symbol] scheme must be one of :none, major, :minor
     def initialize(row, value="", options={})
-      self.row=row      
+      self.row=row
+      @font_name = @charset = @family = @b = @i = @strike = @outline = @shadow = nil
+      @condense = @u = @vertAlign = @sz = @color = @scheme = @extend = @ssti = nil
       @styles = row.worksheet.workbook.styles
-      @row.cells << self      
+      @row.cells << self
       options.each do |o|
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
       end
@@ -197,19 +219,14 @@ module Axlsx
     # The Shared Strings Table index for this cell
     # @return [Integer]
     attr_reader :ssti
-    
+
     # equality comparison to test value, type and inline style attributes
     # this is how we work out if the cell needs to be added or already exists in the shared strings table
-    def shareable(v)
-
-      #using reject becase 1.8.7 select returns an array...
-      v_hash = v.instance_values.reject { |k, v| !INLINE_STYLES.include?(k) }
-      self_hash = self.instance_values.reject { |k, v| !INLINE_STYLES.include?(k) }
-      # required as color is an object, and the comparison will fail even though both use the same color.
-      v_hash['color'] = v_hash['color'].instance_values if v_hash['color']
+    def shareable_hash
+      self_hash = {}
+      INLINE_STYLES.each { |style| self_hash[style] = self.instance_variable_get("@" + style) }
       self_hash['color'] = self_hash['color'].instance_values if self_hash['color']
-
-      v_hash == self_hash
+      self_hash
     end
 
     # @return [Integer] The index of the cell in the containing row.
@@ -219,16 +236,17 @@ module Axlsx
 
     # @return [String] The alpha(column)numeric(row) reference for this sell.
     # @example Relative Cell Reference
-    #   ws.rows.first.cells.first.r #=> "A1" 
+    #   ws.rows.first.cells.first.r #=> "A1"
+    # @note this will be discontinued in 1.1.0 -  prefer Axlsx.cell_r
     def r
-      "#{col_ref}#{@row.index+1}"      
+      "#{Axlsx::col_ref(index)}#{@row.index+1}"
     end
 
     # @return [String] The absolute alpha(column)numeric(row) reference for this sell.
     # @example Absolute Cell Reference
-    #   ws.rows.first.cells.first.r #=> "$A$1" 
+    #   ws.rows.first.cells.first.r #=> "$A$1"
     def r_abs
-      "$#{r.split('').join('$')}"
+      "$#{r.match(%r{([A-Z]+)([0-9]+)})[1,2].join('$')}"
     end
 
     # @return [Integer] The cellXfs item index applied to this cell.
@@ -255,109 +273,102 @@ module Axlsx
                     target.r
                   end
       self.row.worksheet.merge_cells "#{self.r}:#{range_end}" unless range_end.nil?
-    end              
-
-    # builds an xml text run based on this cells attributes. This is extracted from to_xml so that shared strings can use it.
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this output will be added to.
-    # @return [String] the xml for this cell's text run
-    def run_xml(xml)
-      if (self.instance_values.keys & INLINE_STYLES).size > 0
-        xml.r {
-          xml.rPr {
-            xml.rFont(:val=>@font_name) if @font_name
-            xml.charset(:val=>@charset) if @charset
-            xml.family(:val=>@family) if @family
-            xml.b(:val=>@b) if @b
-            xml.i(:val=>@i) if @i
-            xml.strike(:val=>@strike) if @strike
-            xml.outline(:val=>@outline) if @outline
-            xml.shadow(:val=>@shadow) if @shadow
-            xml.condense(:val=>@condense) if @condense
-            xml.extend(:val=>@extend) if @extend
-            @color.to_xml(xml) if @color
-            xml.sz(:val=>@sz) if @sz
-            xml.u(:val=>@u) if @u
-            # :baseline, :subscript, :superscript
-            xml.vertAlign(:val=>@vertAlign) if @verAlign
-            # :none, major, :minor
-            xml.scheme(:val=>@scheme) if @scheme
-          }
-          xml.t @value.to_s
-        }
+    end
+
+    # builds an xml text run based on this cells attributes.
+    # @param [String] str The string instance this run will be concated to.
+    # @return [String]
+    def run_xml_string(str = '')
+      if is_text_run?
+        data = self.instance_values.reject{|key, value| value == nil }
+        keys = data.keys & INLINE_STYLES
+        keys.delete ['value', 'type']
+        str << "<r><rPr>"
+        keys.each do |key|
+          case key
+          when 'font_name'
+            str << "<rFont val='"<< @font_name << "'/>"
+          when 'color'
+            str << data[key].to_xml_string
+          else
+            "<" << key.to_s << " val='" << data[key].to_s << "'/>"
+          end
+        end
+        str << "</rPr>" << "<t>" << value.to_s << "</t></r>"
       else
-        xml.t @value.to_s
-      end        
+        str << "<t>" << value.to_s << "</t>"
+      end
+      str
     end
 
     # Serializes the cell
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @param [Integer] r_index The row index for the cell
+    # @param [Integer] c_index The cell index in the row.
+    # @param [String] str The string index the cell content will be appended to. Defaults to empty string.
     # @return [String] xml text for the cell
-    def to_xml(xml)      
-      if @type == :string 
+    def to_xml_string(r_index, c_index, str = '')
+      return str if @value.nil?
+      str << '<c r="' << Axlsx::cell_r(c_index, r_index) << '" s="' << @style.to_s << '" '
+      case @type
+      when :string
         #parse formula
         if @value.start_with?('=')
-          xml.c(:r => r, :t=>:str, :s=>style) {
-            xml.f @value.to_s.gsub('=', '')
-          }
+          str  << 't="str"><f>' << @value.to_s.gsub('=', '') << '</f>'
         else
           #parse shared
           if @ssti
-            xml.c(:r => r, :s=>style, :t => :s) { xml.v ssti }
+            str << 't="s"><v>' << @ssti.to_s << '</v>'
           else
-            #parse inline string
-            xml.c(:r => r, :s=>style, :t => :inlineStr) {
-              xml.is {
-                run_xml(xml)
-              }
-            }
+            str << 't="inlineStr"><is>' << run_xml_string << '</is>'
           end
         end
-      elsif @type == :time
-        # Using hardcoded offsets here as some operating systems will not except a 'negative' offset from the ruby epoc.
-        epoc1900 = -2209021200 #Time.local(1900, 1, 1) 
-        epoc1904 = -2082877200 #Time.local(1904, 1, 1) 
-        epoc = Workbook.date1904 ? epoc1904 : epoc1900
-        v = ((@value.localtime.to_f - epoc) /60.0/60.0/24.0).to_f
-        xml.c(:r => r, :s => style) { xml.v v }
+      when :date
+        # TODO: See if this is subject to the same restriction as Time below
+        str << '><v>' << DateTimeConverter::date_to_serial(@value).to_s << '</v>'
+      when :time
+        str << '><v>' << DateTimeConverter::time_to_serial(@value).to_s << '</v>'
+      when :boolean
+        str << 't="b"><v>' << @value.to_s << '</v>'
       else
-        xml.c(:r => r, :s => style) { xml.v value }
+        str << '><v>' << @value.to_s << '</v>'
       end
+      str << '</c>'
     end
 
-    private 
+    private
+
+    # Utility method for setting inline style attributes
+    def set_run_style( validator, attr, value)
+      return unless INLINE_STYLES.include?(attr.to_s)
+      Axlsx.send(validator, value) unless validator == nil
+      self.instance_variable_set :"@#{attr.to_s}", value
+      @is_text_run = true
+    end
 
     # @see ssti
-    def ssti=(v) 
+    def ssti=(v)
       Axlsx::validate_unsigned_int(v)
       @ssti = v
     end
 
     # assigns the owning row for this cell.
     def row=(v) DataTypeValidator.validate "Cell.row", Row, v; @row=v end
-    
-    # converts the column index into alphabetical values.
-    # @note This follows the standard spreadsheet convention of naming columns A to Z, followed by AA to AZ etc.
-    # @return [String]
-    def col_ref
-      chars = []
-      index = self.index
-      while index >= 26 do
-        chars << ((index % 26) + 65).chr
-        index /= 26
-      end
-      chars << ((chars.empty? ? index : index-1) + 65).chr
-      chars.reverse.join
-    end
 
-    # Determines the cell type based on the cell value. 
+    # Determines the cell type based on the cell value.
     # @note This is only used when a cell is created but no :type option is specified, the following rules apply:
-    #   1. If the value is an instance of Time, the type is set to :time
-    #   2. :float and :integer types are determined by regular expression matching.
-    #   3. Anything that does not meet either of the above is determined to be :string.
+    #   1. If the value is an instance of Date, the type is set to :date
+    #   2. If the value is an instance of Time, the type is set to :time
+    #   3. If the value is an instance of TrueClass or FalseClass, the type is set to :boolean
+    #   4. :float and :integer types are determined by regular expression matching.
+    #   5. Anything that does not meet either of the above is determined to be :string.
     # @return [Symbol] The determined type
-    def cell_type_from_value(v)      
-      if v.is_a? Time
+    def cell_type_from_value(v)
+      if v.is_a?(Date)
+        :date
+      elsif v.is_a?(Time)
         :time
+      elsif v.is_a?(TrueClass) || v.is_a?(FalseClass)
+        :boolean
       elsif v.to_s.match(/\A[+-]?\d+?\Z/) #numeric
         :integer
       elsif v.to_s.match(/\A[+-]?\d+\.\d+?\Z/) #float
@@ -367,22 +378,28 @@ module Axlsx
       end
     end
 
-    # Cast the value into this cells data type. 
-    # @note 
+    # Cast the value into this cells data type.
+    # @note
     #   About Time - Time in OOXML is *different* from what you might expect. The history as to why is interesting,  but you can safely assume that if you are generating docs on a mac, you will want to specify Workbook.1904 as true when using time typed values.
     # @see Axlsx#date1904
     def cast_value(v)
-      if (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
+      return nil if v.nil?
+      if @type == :date
+        self.style = STYLE_DATE if self.style == 0
+        v
+      elsif (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
         self.style = STYLE_DATE if self.style == 0
         v.respond_to?(:to_time) ? v.to_time : v
       elsif @type == :float
         v.to_f
       elsif @type == :integer
         v.to_i
+      elsif @type == :boolean
+        v ? 1 : 0
       else
         @type = :string
-        v.to_s
+        ::CGI.escapeHTML(v.to_s)
       end
-    end    
+    end
   end
 end

data/lib/axlsx/workbook/worksheet/col.rb

@@ -0,0 +1,114 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The Col class defines column attributes for columns in sheets.
+  class Col
+
+    # First column affected by this 'column info' record.
+    # @return [Integer]
+    attr_reader :min
+
+    # Last column affected by this 'column info' record.
+    # @return [Integer]
+    attr_reader :max
+
+    # Flag indicating if the specified column(s) is set to 'best fit'. 'Best fit' is set to true under these conditions:
+    # The column width has never been manually set by the user, AND The column width is not the default width
+    # 'Best fit' means that when numbers are typed into a cell contained in a 'best fit' column, the column width should
+    #  automatically resize to display the number. [Note: In best fit cases, column width must not be made smaller, only larger. end note]
+    # @return [Boolean]
+    attr_reader :bestFit
+
+    # Flag indicating if the outlining of the affected column(s) is in the collapsed state.
+    # @return [Boolean]
+    attr_reader :collapsed
+
+    # Flag indicating if the affected column(s) are hidden on this worksheet.
+    # @return [Boolean]
+    attr_reader :hidden
+
+    # Outline level of affected column(s). Range is 0 to 7.
+    # @return [Integer]
+    attr_reader :outlineLevel
+
+    # Flag indicating if the phonetic information should be displayed by default for the affected column(s) of the worksheet.
+    # @return [Boolean]
+    attr_reader :phonetic
+
+    # Default style for the affected column(s). Affects cells not yet allocated in the column(s). In other words, this style applies to new columns.
+    # @return [Integer]
+    attr_reader :style
+
+    # The width of the column
+    # @return [Numeric]
+    attr_reader :width
+
+    # @return [Boolean]
+    attr_reader :customWidth
+
+    # @see Col#collapsed
+    def collapsed=(v)
+      Axlsx.validate_boolean(v)
+      @collapsed = v
+    end
+
+    # @see Col#hidden
+    def hidden=(v)
+      Axlsx.validate_boolean(v)
+      @hidden = v
+    end
+
+    # @see Col#outline
+    def outlineLevel=(v)
+      Axlsx.validate_boolean(v)
+      @outlineLevel = v
+    end
+
+    # @see Col#phonetic
+    def phonetic=(v)
+      Axlsx.validate_boolean(v)
+      @phonetic = v
+    end
+
+    # @see Col#style
+    def style=(v)
+      Axlsx.validate_unsigned_int(v)
+      @style = v
+    end
+
+   # @see Col#width
+    def width=(v)
+      Axlsx.validate_unsigned_numeric(v) unless v == nil
+      @customWidth = @bestFit = v != nil
+      @width = v
+    end
+
+    # Create a new Col objects
+    # @param min First column affected by this 'column info' record.
+    # @param max Last column affected by this 'column info' record.
+    # @option options [Boolean] collapsed see Col#collapsed
+    # @option options [Boolean] hidden see Col#hidden
+    # @option options [Boolean] outlineLevel see Col#outlineLevel
+    # @option options [Boolean] phonetic see Col#phonetic
+    # @option options [Integer] style see Col#style
+    # @option options [Numeric] width see Col#width
+    def initialize(min, max, options={})
+      Axlsx.validate_unsigned_int(max)
+      Axlsx.validate_unsigned_int(min)
+      @min = min
+      @max = max
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+
+    # Serialize this columns data to an xml string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      attrs = self.instance_values.reject{ |key, value| value == nil }
+      str << '<col ' << attrs.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ') << '/>'
+    end
+
+  end
+end

data/lib/axlsx/workbook/worksheet/date_time_converter.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+require "date"
+
+module Axlsx
+  # The DateTimeConverter class converts both data and time types to their apprpriate excel serializations
+  class DateTimeConverter
+
+    # The date_to_serial method converts Date objects to the equivelant excel serialized forms
+    # @param [Date] date the date to be serialized
+    # @return [Numeric]
+    def self.date_to_serial(date)
+      epoch = Axlsx::Workbook::date1904 ? Date.new(1904) : Date.new(1899, 12, 30)
+      (date-epoch).to_f
+    end
+
+    # The time_to_serial methond converts a Time object its excel serialized form.
+    # @param [Time] time the time to be serialized
+    # @return [Numeric]
+    def self.time_to_serial(time)
+      # Using hardcoded offsets here as some operating systems will not except
+      # a 'negative' offset from the ruby epoch.
+      epoch1900 = -2209161600 # Time.utc(1899, 12, 30).to_i
+      epoch1904 = -2082844800 # Time.utc(1904, 1, 1).to_i
+      seconds_per_day = 86400 # 60*60*24
+      epoch = Axlsx::Workbook::date1904 ? epoch1904 : epoch1900
+      (time.to_f - epoch)/seconds_per_day
+    end
+  end
+end