write_xlsx 0.58.0 → 0.59.0

data/lib/write_xlsx/package/relationships.rb

@@ -44,7 +44,17 @@ module Writexlsx
       #
       def add_package_relationship(type, target)
         type   = Package_schema + type
-        target = target + '.xml'
+        target = target
+
+        @rels.push([type, target])
+      end
+
+      #
+      # Add container relationship to XLSX .rels xml files. Uses MS schema.
+      #
+      def add_ms_package_relationship(type, target)
+        schema = 'http://schemas.microsoft.com/office/2006/relationships'
+        type = schema + type
 
         @rels.push([type, target])
       end

data/lib/write_xlsx/package/table.rb

@@ -8,11 +8,47 @@ module Writexlsx
     class Table
       include Writexlsx::Utility
 
-      attr_writer :properties
+      class ColumnData
+        attr_reader :id
+        attr_accessor :name, :format, :formula
+        attr_accessor :total_string, :total_function
+
+        def initialize(id, param = {})
+          @id             = id
+          @name           = "Column#{id}"
+          @total_string   = ''
+          @total_function = ''
+          @formula        = ''
+          @format         = nil
+          @user_data      = param[id-1] if param
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(worksheet, id, *args)
+        @worksheet = worksheet
+        @writer  = Package::XMLWriterSimple.new
+        @id      = id
+
+        @row1, @row2, @col1, @col2, @param = handle_args(*args)
+        @columns = []
+        @col_formats = []
+
+        # Set the data range rows (without the header and footer).
+        @first_data_row = @row1
+        @first_data_row += 1 if ptrue?(@param[:header_row])
+        @last_data_row  = @row2
+        @last_data_row  -= 1 if @param[:total_row]
 
-      def initialize
-        @writer = Package::XMLWriterSimple.new
-        @properties = {}
+        set_the_table_options
+        set_the_table_style
+        set_the_table_name
+        set_the_table_and_autofilter_ranges
+        set_the_autofilter_range
+
+        add_the_table_columns
+        write_the_cell_data_if_supplied
       end
 
       def set_xml_writer(filename)
@@ -41,33 +77,237 @@ module Writexlsx
         @writer.close
       end
 
-      #
-      # Set the document properties.
-      #
-      def set_properties(properties)
-        @properties = properties
+      def add_the_table_columns
+        col_id = 0
+        (@col1..@col2).each do |col_num|
+          # Set up the default column data.
+          col_data = Package::Table::ColumnData.new(col_id + 1, @param[:columns])
+
+          overrite_the_defaults_with_any_use_defined_values(col_id, col_data, col_num)
+
+          # Store the column data.
+          @columns << col_data
+
+          write_the_column_headers_to_the_worksheet(col_num, col_data)
+
+          col_id += 1
+        end    # Table columns.
+      end
+
+      def overrite_the_defaults_with_any_use_defined_values(col_id, col_data, col_num)
+        if @param[:columns]
+          # Check if there are user defined values for this column.
+          if user_data = @param[:columns][col_id]
+            # Map user defined values to internal values.
+            if user_data[:header] && !user_data[:header].empty?
+              col_data.name = user_data[:header]
+            end
+            # Handle the column formula.
+            handle_the_column_formula(
+                                      col_data, col_num, user_data[:formula], user_data[:format]
+                                      )
+
+            # Handle the function for the total row.
+            if user_data[:total_function]
+              handle_the_function_for_the_table_row(
+                                                    @row2, col_data, col_num,
+                                                    user_data[:total_function],
+                                                    user_data[:format]
+                                                    )
+            elsif user_data[:total_string]
+              total_label_only(
+                               @row2, col_num, col_data, user_data[:total_string], user_data[:format]
+                               )
+            end
+
+            # Get the dxf format index.
+            if user_data[:format]
+              col_data.format = user_data[:format].get_dxf_index
+            end
+
+            # Store the column format for writing the cell data.
+            # It doesn't matter if it is undefined.
+            @col_formats[col_id] = user_data[:format]
+          end
+        end
+      end
+
+      def write_the_column_headers_to_the_worksheet(col_num, col_data)
+        if @param[:header_row] != 0
+          @worksheet.write_string(@row1, col_num, col_data.name)
+        end
+      end
+
+      def write_the_cell_data_if_supplied
+        return unless @param[:data]
+
+        data = @param[:data]
+        i = 0    # For indexing the row data.
+        (@first_data_row..@last_data_row).each do |row|
+          next unless data[i]
+
+          j = 0    # For indexing the col data.
+          (@col1..@col2).each do |col|
+            token = data[i][j]
+            @worksheet.write(row, col, token, @col_formats[j]) if token
+            j += 1
+          end
+          i += 1
+        end
       end
 
       private
 
-      #
-      # Write the XML declaration.
-      #
-      def write_xml_declaration
-        @writer.xml_decl('UTF-8', 1)
+      def handle_args(*args)
+        # Check for a cell reference in A1 notation and substitute row and column
+        row1, col1, row2, col2, param = row_col_notation(args)
+
+        # Check for a valid number of args.
+        raise "Not enough parameters to add_table()" if [row1, col1, row2, col2].include?(nil)
+
+        # Check that row and col are valid without storing the values.
+        check_dimensions_and_update_max_min_values(row1, col1, 1, 1)
+        check_dimensions_and_update_max_min_values(row2, col2, 1, 1)
+
+        # Swap last row/col for first row/col as necessary.
+        row1, row2 = row2, row1 if row1 > row2
+        col1, col2 = col2, col1 if col1 > col2
+
+      # The final hash contains the validation parameters.
+        param ||= {}
+
+        # Turn on Excel's defaults.
+        param[:banded_rows] ||= 1
+        param[:header_row]  ||= 1
+        param[:autofilter]  ||= 1
+
+        # If the header row if off the default is to turn autofilter off.
+        param[:autofilter] = 0 if param[:header_row] == 0
+
+        check_parameter(param, valid_table_parameter, 'add_table')
+
+        [row1, row2, col1, col2, param]
+      end
+
+      # List of valid input parameters.
+      def valid_table_parameter
+        [
+         :autofilter,
+         :banded_columns,
+         :banded_rows,
+         :columns,
+         :data,
+         :first_column,
+         :header_row,
+         :last_column,
+         :name,
+         :style,
+         :total_row
+        ]
+      end
+
+      def handle_the_column_formula(col_data, col_num, formula, format)
+        return unless formula
+
+        # Remove the leading = from formula.
+        formula.sub!(/^=/, '')
+        # Covert Excel 2010 "@" ref to 2007 "#This Row".
+        formula.gsub!(/@/,'[#This Row],')
+
+        col_data.formula = formula
+
+        (@first_data_row..@last_data_row).each do |row|
+          @worksheet.write_formula(row, col_num, formula, format)
+        end
+      end
+
+      def handle_the_function_for_the_table_row(row2, col_data, col_num, total_function, format)
+        function = total_function
+
+        # Massage the function name.
+        function = function.downcase
+        function.gsub!(/_/, '')
+        function.gsub!(/\s/,'')
+
+        function = 'countNums' if function == 'countnums'
+        function = 'stdDev'    if function == 'stddev'
+
+        col_data.total_function = function
+
+        formula = table_function_to_formula(function, col_data.name)
+        @worksheet.write_formula(row2, col_num, formula, format)
       end
 
       #
-      # Write the <autoFilter> element.
+      # Convert a table total function to a worksheet formula.
       #
-      def write_auto_filter
-        autofilter = @properties[:_autofilter]
+      def table_function_to_formula(function, col_name)
+        subtotals = {
+          :average   => 101,
+          :countNums => 102,
+          :count     => 103,
+          :max       => 104,
+          :min       => 105,
+          :stdDev    => 107,
+          :sum       => 109,
+          :var       => 110
+        }
+
+        unless func_num = subtotals[function.to_sym]
+          raise "Unsupported function '#{function}' in add_table()"
+        end
+        "SUBTOTAL(#{func_num},[#{col_name}])"
+      end
 
-        return unless autofilter
+      # Total label only (not a function).
+      def total_label_only(row2, col_num, col_data, total_string, format)
+        col_data.total_string = total_string
 
-        attributes = ['ref', autofilter]
+        @worksheet.write_string(row2, col_num, total_string, format)
+      end
 
-        @writer.empty_tag('autoFilter', attributes)
+      def set_the_table_options
+        @show_first_col   = ptrue?(@param[:first_column])   ? 1 : 0
+        @show_last_col    = ptrue?(@param[:last_column])    ? 1 : 0
+        @show_row_stripes = ptrue?(@param[:banded_rows])    ? 1 : 0
+        @show_col_stripes = ptrue?(@param[:banded_columns]) ? 1 : 0
+        @header_row_count = ptrue?(@param[:header_row])     ? 1 : 0
+        @totals_row_shown = ptrue?(@param[:total_row])      ? 1 : 0
+      end
+
+      def set_the_table_style
+        if @param[:style]
+          @style = @param[:style]
+          # Remove whitespace from style name.
+          @style.gsub!(/\s/, '')
+        else
+          @style = "TableStyleMedium9"
+        end
+      end
+
+      def set_the_table_name
+        if @param[:name]
+          @name = @param[:name]
+        else
+          # Set a default name.
+          @name = "Table#{id}"
+        end
+      end
+
+      def set_the_table_and_autofilter_ranges
+        @range   = xl_range(@row1, @row2,          @col1, @col2)
+        @a_range = xl_range(@row1, @last_data_row, @col1, @col2)
+      end
+
+      def set_the_autofilter_range
+        @autofilter = @a_range if ptrue?(@param[:autofilter])
+      end
+
+      #
+      # Write the XML declaration.
+      #
+      def write_xml_declaration
+        @writer.xml_decl('UTF-8', 1)
       end
 
       #
@@ -76,26 +316,20 @@ module Writexlsx
       def write_table
         schema           = 'http://schemas.openxmlformats.org/'
         xmlns            = "#{schema}spreadsheetml/2006/main"
-        id               = @properties[:id]
-        name             = @properties[:_name]
-        display_name     = @properties[:_name]
-        ref              = @properties[:_range]
-        totals_row_shown = @properties[:_totals_row_shown]
-        header_row_count = @properties[:_header_row_count]
 
         attributes = [
                       'xmlns',       xmlns,
                       'id',          id,
-                      'name',        name,
-                      'displayName', display_name,
-                      'ref',         ref
+                      'name',        @name,
+                      'displayName', @name,
+                      'ref',         @range
                      ]
 
-        unless ptrue?(header_row_count)
+        unless ptrue?(@header_row_count)
           attributes << 'headerRowCount' << 0
         end
 
-        if ptrue?(totals_row_shown)
+        if ptrue?(@totals_row_shown)
           attributes << 'totalsRowCount' << 1
         else
           attributes << 'totalsRowShown' << 0
@@ -107,11 +341,9 @@ module Writexlsx
       # Write the <autoFilter> element.
       #
       def write_auto_filter
-        autofilter = @properties[:_autofilter]
-
-        return unless ptrue?(autofilter)
+        return unless ptrue?(@autofilter)
 
-        attributes = ['ref', autofilter]
+        attributes = ['ref', @autofilter]
 
         @writer.empty_tag('autoFilter', attributes)
       end
@@ -120,14 +352,12 @@ module Writexlsx
       # Write the <tableColumns> element.
       #
       def write_table_columns
-        columns = @properties[:_columns]
-
-        count = columns.size
+        count = @columns.size
 
         attributes = ['count', count]
 
         @writer.tag_elements('tableColumns', attributes) do
-          columns.each {|col_data| write_table_column(col_data)}
+          @columns.each {|col_data| write_table_column(col_data)}
         end
       end
 
@@ -136,24 +366,24 @@ module Writexlsx
       #
       def write_table_column(col_data)
         attributes = [
-                      'id',   col_data[:_id],
-                      'name', col_data[:_name]
+                      'id',   col_data.id,
+                      'name', col_data.name
                      ]
 
-        if ptrue?(col_data[:_total_string])
-          attributes << :totalsRowLabel << col_data[:_total_string]
-        elsif ptrue?(col_data[:_total_function])
-          attributes << :totalsRowFunction << col_data[:_total_function]
+        if ptrue?(col_data.total_string)
+          attributes << :totalsRowLabel << col_data.total_string
+        elsif ptrue?(col_data.total_function)
+          attributes << :totalsRowFunction << col_data.total_function
         end
 
-        if col_data[:_format]
-          attributes << :dataDxfId << col_data[:_format]
+        if col_data.format
+          attributes << :dataDxfId << col_data.format
         end
 
-        if ptrue?(col_data[:_formula])
+        if ptrue?(col_data.formula)
           @writer.tag_elements('tableColumn', attributes) do
             # Write the calculatedColumnFormula element.
-            write_calculated_column_formula(col_data[:_formula])
+            write_calculated_column_formula(col_data.formula)
           end
         else
           @writer.empty_tag('tableColumn', attributes)
@@ -164,20 +394,12 @@ module Writexlsx
       # Write the <tableStyleInfo> element.
       #
       def write_table_style_info
-        props = @properties
-
-        name                = props[:_style]
-        show_first_column   = props[:_show_first_col]
-        show_last_column    = props[:_show_last_col]
-        show_row_stripes    = props[:_show_row_stripes]
-        show_column_stripes = props[:_show_col_stripes]
-
         attributes = [
-                      'name',              name,
-                      'showFirstColumn',   show_first_column,
-                      'showLastColumn',    show_last_column,
-                      'showRowStripes',    show_row_stripes,
-                      'showColumnStripes', show_column_stripes
+                      'name',              @style,
+                      'showFirstColumn',   @show_first_col,
+                      'showLastColumn',    @show_last_col,
+                      'showRowStripes',    @show_row_stripes,
+                      'showColumnStripes', @show_col_stripes
                      ]
 
         @writer.empty_tag('tableStyleInfo', attributes)

data/lib/write_xlsx/utility.rb

@@ -91,6 +91,140 @@ module Writexlsx
       "=#{sheetname}!#{range1}:#{range2}"
     end
 
+    def check_dimensions(row, col)
+      if !row || row >= ROW_MAX || !col || col >= COL_MAX
+        raise WriteXLSXDimensionError
+      end
+      0
+    end
+
+    #
+    # convert_date_time(date_time_string)
+    #
+    # The function takes a date and time in ISO8601 "yyyy-mm-ddThh:mm:ss.ss" format
+    # and converts it to a decimal number representing a valid Excel date.
+    #
+    # Dates and times in Excel are represented by real numbers. The integer part of
+    # the number stores the number of days since the epoch and the fractional part
+    # stores the percentage of the day in seconds. The epoch can be either 1900 or
+    # 1904.
+    #
+    # Parameter: Date and time string in one of the following formats:
+    #               yyyy-mm-ddThh:mm:ss.ss  # Standard
+    #               yyyy-mm-ddT             # Date only
+    #                         Thh:mm:ss.ss  # Time only
+    #
+    # Returns:
+    #            A decimal number representing a valid Excel date, or
+    #            nil if the date is invalid.
+    #
+    def convert_date_time(date_time_string)       #:nodoc:
+      date_time = date_time_string
+
+      days      = 0 # Number of days since epoch
+      seconds   = 0 # Time expressed as fraction of 24h hours in seconds
+
+      # Strip leading and trailing whitespace.
+      date_time.sub!(/^\s+/, '')
+      date_time.sub!(/\s+$/, '')
+
+      # Check for invalid date char.
+      return nil if date_time =~ /[^0-9T:\-\.Z]/
+
+      # Check for "T" after date or before time.
+      return nil unless date_time =~ /\dT|T\d/
+
+      # Strip trailing Z in ISO8601 date.
+      date_time.sub!(/Z$/, '')
+
+      # Split into date and time.
+      date, time = date_time.split(/T/)
+
+      # We allow the time portion of the input DateTime to be optional.
+      if time
+        # Match hh:mm:ss.sss+ where the seconds are optional
+        if time =~ /^(\d\d):(\d\d)(:(\d\d(\.\d+)?))?/
+          hour   = $1.to_i
+          min    = $2.to_i
+          sec    = $4.to_f || 0
+        else
+          return nil # Not a valid time format.
+        end
+
+        # Some boundary checks
+        return nil if hour >= 24
+        return nil if min  >= 60
+        return nil if sec  >= 60
+
+        # Excel expresses seconds as a fraction of the number in 24 hours.
+        seconds = (hour * 60* 60 + min * 60 + sec) / (24.0 * 60 * 60)
+      end
+
+      # We allow the date portion of the input DateTime to be optional.
+      return seconds if date == ''
+
+      # Match date as yyyy-mm-dd.
+      if date =~ /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+        year   = $1.to_i
+        month  = $2.to_i
+        day    = $3.to_i
+      else
+        return nil  # Not a valid date format.
+      end
+
+      # Set the epoch as 1900 or 1904. Defaults to 1900.
+      # Special cases for Excel.
+      unless date_1904?
+        return      seconds if date == '1899-12-31' # Excel 1900 epoch
+        return      seconds if date == '1900-01-00' # Excel 1900 epoch
+        return 60 + seconds if date == '1900-02-29' # Excel false leapday
+      end
+
+
+      # We calculate the date by calculating the number of days since the epoch
+      # and adjust for the number of leap days. We calculate the number of leap
+      # days by normalising the year in relation to the epoch. Thus the year 2000
+      # becomes 100 for 4 and 100 year leapdays and 400 for 400 year leapdays.
+      #
+      epoch   = date_1904? ? 1904 : 1900
+      offset  = date_1904? ?    4 :    0
+      norm    = 300
+      range   = year - epoch
+
+      # Set month days and check for leap year.
+      mdays   = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+      leap    = 0
+      leap    = 1  if year % 4 == 0 && year % 100 != 0 || year % 400 == 0
+      mdays[1]   = 29 if leap != 0
+
+      # Some boundary checks
+      return nil if year  < epoch or year  > 9999
+      return nil if month < 1     or month > 12
+      return nil if day   < 1     or day   > mdays[month - 1]
+
+      # Accumulate the number of days since the epoch.
+      days = day                               # Add days for current month
+      (0 .. month-2).each do |m|
+        days += mdays[m]                      # Add days for past months
+      end
+      days += range * 365                      # Add days for past years
+      days += ((range)                /  4)    # Add leapdays
+      days -= ((range + offset)       /100)    # Subtract 100 year leapdays
+      days += ((range + offset + norm)/400)    # Add 400 year leapdays
+      days -= leap                             # Already counted above
+
+      # Adjust for Excel erroneously treating 1900 as a leap year.
+      days += 1 if !date_1904? and days > 59
+
+      date_time = sprintf("%0.10f", days + seconds)
+      date_time = date_time.sub(/\.?0+$/, '') if date_time =~ /\./
+      if date_time =~ /\./
+        date_time.to_f
+      else
+        date_time.to_i
+      end
+    end
+
     def absolute_char(absolute)
       absolute ? '$' : ''
     end
@@ -115,6 +249,15 @@ module Writexlsx
       $stderr.puts("Warning: calling deprecated method #{method}. This method will be removed in a future release.")
     end
 
+    # Check for a cell reference in A1 notation and substitute row and column
+    def row_col_notation(args)   # :nodoc:
+      if args[0] =~ /^\D/
+        substitute_cellref(*args)
+      else
+        args
+      end
+    end
+
     #
     # Substitute an Excel cell reference in A1 notation for  zero based row and
     # column values in an argument list.
@@ -159,6 +302,15 @@ module Writexlsx
       end
     end
 
+    #
+    # Write the <color> element.
+    #
+    def write_color(writer, name, value) #:nodoc:
+      attributes = [name, value]
+
+      writer.empty_tag('color', attributes)
+    end
+
     #
     # return perl's boolean result
     #
@@ -178,5 +330,32 @@ module Writexlsx
       end
       true
     end
+
+    #
+    # Check that row and col are valid and store max and min values for use in
+    # other methods/elements.
+    #
+    # The ignore_row/ignore_col flags is used to indicate that we wish to
+    # perform the dimension check without storing the value.
+    #
+    # The ignore flags are use by set_row() and data_validate.
+    #
+    def check_dimensions_and_update_max_min_values(row, col, ignore_row = 0, ignore_col = 0)       #:nodoc:
+      check_dimensions(row, col)
+      store_row_max_min_values(row) if ignore_row == 0
+      store_col_max_min_values(col) if ignore_col == 0
+
+      0
+    end
+
+    def store_row_max_min_values(row)
+      @dim_rowmin = row if !@dim_rowmin || (row < @dim_rowmin)
+      @dim_rowmax = row if !@dim_rowmax || (row > @dim_rowmax)
+    end
+
+    def store_col_max_min_values(col)
+      @dim_colmin = col if !@dim_colmin || (col < @dim_colmin)
+      @dim_colmax = col if !@dim_colmax || (col > @dim_colmax)
+    end
   end
 end

data/lib/write_xlsx/version.rb

@@ -1,5 +1,5 @@
 require 'write_xlsx/workbook'
 
 class WriteXLSX < Writexlsx::Workbook
-  VERSION = "0.58.0"
+  VERSION = "0.59.0"
 end

data/lib/write_xlsx/workbook.rb

@@ -25,6 +25,7 @@ module Writexlsx
     attr_reader :image_types, :images
     attr_reader :shared_strings
     attr_accessor :table_count
+    attr_reader :vba_project
     #
     # A new Excel workbook is created using the new() constructor
     # which accepts either a filename or an IO object as a parameter.
@@ -756,6 +757,13 @@ module Writexlsx
       @doc_properties = params.dup
     end
 
+    #
+    # Add a vbaProject binary to the XLSX file.
+    #
+    def add_vba_project(vba_project)
+      @vba_project = vba_project
+    end
+
     #
     # Change the RGB components of the elements in the colour palette.
     #
@@ -1066,7 +1074,12 @@ module Writexlsx
         'lastEdited', 4,
         'lowestEdited', 4,
         'rupBuild', 4505
-      ]
+                   ]
+
+      if @vba_project
+        attributes << :codeName << '{37E998C4-C9E5-D4B9-71C8-EB1FF731991C}'
+      end
+
       @writer.empty_tag('fileVersion', attributes)
     end