write_xlsx 1.11.1 → 1.12.0

data/lib/write_xlsx/package/rich_value_types.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+require 'write_xlsx/package/xml_writer_simple'
+require 'write_xlsx/utility'
+
+module Writexlsx
+  module Package
+    #
+    # RichValueTypes - A class for writing the Excel XLSX rdRichValueTypes.xml file.
+    #
+    # Used in conjunction with Excel::Writer::XLSX
+    #
+    # Copyright 2000-2024, John McNamara, jmcnamara@cpan.org
+    #
+    # Convert to Ruby by Hideo NAKAMURA, nakamura.hideo@gmail.com
+    #
+    class RichValueTypes
+      include Writexlsx::Utility
+
+      def initialize
+        @writer          = Package::XMLWriterSimple.new
+      end
+
+      def set_xml_writer(filename)
+        @writer.set_xml_writer(filename)
+      end
+
+      def assemble_xml_file
+        write_xml_declaration do
+          write_rv_types_info
+        end
+      end
+
+      private
+
+      #
+      # Write the <rvTypesInfo> element.
+      #
+      def write_rv_types_info
+        xmlns = 'http://schemas.microsoft.com/office/spreadsheetml/2017/richdata2'
+        xmlns_mc = 'http://schemas.openxmlformats.org/markup-compatibility/2006'
+        xmlns_x  = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'
+
+        attributes = [
+          ['xmlns',        xmlns],
+          ['xmlns:mc',     xmlns_mc],
+          ['mc:Ignorable', 'x'],
+          ['xmlns:x',      xmlns_x]
+        ]
+
+        key_flags = [
+          ['_Self', %w[ExcludeFromFile ExcludeFromCalcComparison]],
+          ['_DisplayString',          ['ExcludeFromCalcComparison']],
+          ['_Flags',                  ['ExcludeFromCalcComparison']],
+          ['_Format',                 ['ExcludeFromCalcComparison']],
+          ['_SubLabel',               ['ExcludeFromCalcComparison']],
+          ['_Attribution',            ['ExcludeFromCalcComparison']],
+          ['_Icon',                   ['ExcludeFromCalcComparison']],
+          ['_Display',                ['ExcludeFromCalcComparison']],
+          ['_CanonicalPropertyNames', ['ExcludeFromCalcComparison']],
+          ['_ClassificationId',       ['ExcludeFromCalcComparison']]
+        ]
+
+        @writer.tag_elements('rvTypesInfo', attributes) do
+          @writer.tag_elements('global') do
+            @writer.tag_elements('keyFlags') do
+              # Write the keyFlags element.
+              key_flags.each do |key_flag|
+                write_key(key_flag[0], key_flag[1])
+              end
+            end
+          end
+        end
+      end
+
+      #
+      # Write the <key> element.
+      #
+      def write_key(name, flags = [])
+        attributes = [['name',  name]]
+
+        @writer.tag_elements('key', attributes) do
+          flags.each do |flag|
+            write_flag(flag)
+          end
+        end
+      end
+
+      #
+      # Write the <flag> element.
+      #
+      def write_flag(name)
+        attributes = [
+          ['name', name],
+          ['value', 1]
+        ]
+
+        @writer.empty_tag('flag', attributes)
+      end
+    end
+  end
+end

data/lib/write_xlsx/package/table.rb

@@ -12,13 +12,14 @@ module Writexlsx
       class ColumnData
         attr_reader :id
         attr_accessor :name, :format, :formula, :name_format
-        attr_accessor :total_string, :total_function
+        attr_accessor :total_string, :total_function, :custom_total
 
         def initialize(id, param = {})
           @id             = id
           @name           = "Column#{id}"
           @total_string   = ''
           @total_function = ''
+          @custom_total   = ''
           @formula        = ''
           @format         = nil
           @name_format    = nil
@@ -51,6 +52,7 @@ module Writexlsx
 
         add_the_table_columns
         write_the_cell_data_if_supplied
+        write_any_columns_formulas_after_the_user_supplied_table_data
         store_filter_cell_positions
       end
 
@@ -78,7 +80,7 @@ module Writexlsx
           # 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)
+          overwrite_the_defaults_with_any_use_defined_values(col_id, col_data, col_num)
 
           # Store the column data.
           @columns << col_data
@@ -89,7 +91,7 @@ module Writexlsx
         end    # Table columns.
       end
 
-      def overrite_the_defaults_with_any_use_defined_values(col_id, col_data, col_num)
+      def overwrite_the_defaults_with_any_use_defined_values(col_id, col_data, col_num)
         # Check if there are user defined values for this column.
         if @param[:columns] && (user_data = @param[:columns][col_id])
           # Map user defined values to internal values.
@@ -156,6 +158,23 @@ module Writexlsx
         end
       end
 
+      def write_any_columns_formulas_after_the_user_supplied_table_data
+        col_id = 0
+
+        (@col1..@col2).each do |col|
+          column_data = @columns[col_id]
+          if ptrue?(column_data) && ptrue?(column_data.formula)
+            formula_format = @col_formats[col_id]
+            formula        = column_data.formula
+
+            (@first_data_row..@last_data_row).each do |row|
+              @worksheet.write_formula(row, col, formula, formula_format)
+            end
+          end
+          col_id += 1
+        end
+      end
+
       def store_filter_cell_positions
         if ptrue?(@param[:autofilter])
           (@col1..@col2).each do |col|
@@ -234,25 +253,45 @@ module Writexlsx
         ]
       end
 
-      def handle_the_column_formula(col_data, col_num, formula, format)
+      def handle_the_column_formula(col_data, _col_num, formula, _format)
         return unless formula
 
-        col_data.formula = formula.sub(/^=/, '').gsub(/@/, '[#This Row],')
+        formula = formula.sub(/^=/, '').gsub(/@/, '[#This Row],')
 
-        (@first_data_row..@last_data_row).each do |row|
-          @worksheet.write_formula(row, col_num, col_data.formula, format)
-        end
+        # Escape any future functions.
+        col_data.formula = @worksheet.prepare_formula(formula, 1)
+
+        # (@first_data_row..@last_data_row).each do |row|
+        #   @worksheet.write_formula(row, col_num, col_data.formula, format)
+        # end
       end
 
       def handle_the_function_for_the_table_row(row2, col_data, col_num, user_data)
-        function = user_data[:total_function].downcase.gsub(/[_\s]/, '')
+        formula = ''
+        function = user_data[:total_function]
+        function = 'countNums' if function == 'count_nums'
+        function = 'stdDev'    if function == 'std_dev'
 
-        function = 'countNums' if function == 'countnums'
-        function = 'stdDev'    if function == 'stddev'
+        subtotals = {
+          average:   101,
+          countNums: 102,
+          count:     103,
+          max:       104,
+          min:       105,
+          stdDev:    106,
+          sum:       109,
+          var:       110
+        }
 
-        col_data.total_function = function
+        if subtotals[function.to_sym]
+          formula = table_function_to_formula(function, col_data.name)
+        else
+          formula = @worksheet.prepare_formula(function, 1)
+          col_data.custom_total = formula
+          function = 'custom'
+        end
 
-        formula = table_function_to_formula(function, col_data.name)
+        col_data.total_function = function
         @worksheet.write_formula(row2, col_num, formula, user_data[:format], user_data[:total_value])
       end
 
@@ -260,10 +299,10 @@ module Writexlsx
       # Convert a table total function to a worksheet formula.
       #
       def table_function_to_formula(function, col_name)
-        col_name = col_name.gsub(/'/, "''")
-                           .gsub(/#/, "'#")
-                           .gsub(/\[/, "'[")
-                           .gsub(/\]/, "']")
+        col_name = col_name.gsub("'", "''")
+                           .gsub("#", "'#")
+                           .gsub("[", "'[")
+                           .gsub("]", "']")
 
         subtotals = {
           average:   101,
@@ -395,10 +434,16 @@ module Writexlsx
 
         attributes << [:dataDxfId, col_data.format] if col_data.format
 
-        if ptrue?(col_data.formula)
+        if ptrue?(col_data.formula) || ptrue?(col_data.custom_total)
           @writer.tag_elements('tableColumn', attributes) do
-            # Write the calculatedColumnFormula element.
-            write_calculated_column_formula(col_data.formula)
+            if ptrue?(col_data.formula)
+              # Write the calculatedColumnFormula element.
+              write_calculated_column_formula(col_data.formula)
+            end
+            if ptrue?(col_data.custom_total)
+              # Write the totalsRowFormula element.
+              write_totals_row_formula(col_data.custom_total)
+            end
           end
         else
           @writer.empty_tag('tableColumn', attributes)
@@ -425,6 +470,15 @@ module Writexlsx
       def write_calculated_column_formula(formula)
         @writer.data_element('calculatedColumnFormula', formula)
       end
+
+      #
+      # _write_totals_row_formula()
+      #
+      # Write the <totalsRowFormula> element.
+      #
+      def write_totals_row_formula(formula)
+        @writer.data_element('totalsRowFormula', formula)
+      end
     end
   end
 end

data/lib/write_xlsx/package/xml_writer_simple.rb

@@ -29,33 +29,28 @@ module Writexlsx
         io_write(str)
       end
 
-      def tag_elements(tag, attributes = [])
+      def tag_elements(tag, attributes = nil)
         start_tag(tag, attributes)
         yield
         end_tag(tag)
       end
 
-      def tag_elements_str(tag, attributes = [])
+      def tag_elements_str(tag, attributes = nil)
         start_tag_str(tag, attributes) +
           yield +
           end_tag_str(tag)
       end
 
-      def start_tag(tag, attr = [])
+      def start_tag(tag, attr = nil)
         io_write(start_tag_str(tag, attr))
       end
 
-      def start_tag_str(tag, attr = [])
-        if attr.empty?
-          result = @tag_start_cache[tag]
-          unless result
-            result = "<#{tag}>"
-            @tag_start_cache[tag] = result
-          end
+      def start_tag_str(tag, attr = nil)
+        if attr.nil? || attr.empty?
+          @tag_start_cache[tag] ||= "<#{tag}>"
         else
-          result = "<#{tag}#{key_vals(attr)}>"
+          "<#{tag}#{key_vals(attr)}>"
         end
-        result
       end
 
       def end_tag(tag)
@@ -63,28 +58,15 @@ module Writexlsx
       end
 
       def end_tag_str(tag)
-        result = @tag_end_cache[tag]
-        unless result
-          result = "</#{tag}>"
-          @tag_end_cache[tag] = result
-        end
-        result
+        @tag_end_cache[tag] ||= "</#{tag}>"
       end
 
-      def empty_tag(tag, attr = [])
+      def empty_tag(tag, attr = nil)
         str = "<#{tag}#{key_vals(attr)}/>"
         io_write(str)
       end
 
-      def empty_tag_encoded(tag, attr = [])
-        io_write(empty_tag_encoded_str(tag, attr))
-      end
-
-      def empty_tag_encoded_str(tag, attr = [])
-        "<#{tag}#{key_vals(attr)}/>"
-      end
-
-      def data_element(tag, data, attr = [])
+      def data_element(tag, data, attr = nil)
         tag_elements(tag, attr) { io_write(escape_data(data)) }
       end
 
@@ -126,31 +108,37 @@ module Writexlsx
 
       private
 
-      def key_val(key, val)
-        %( #{key}="#{val}")
-      end
-
       def key_vals(attribute)
-        attribute
-          .inject('') { |str, attr| str + key_val(attr.first, escape_attributes(attr.last)) }
+        if attribute
+          result = "".dup
+          attribute.each do |attr|
+            # Generate and concat %( #{key}="#{val}") values for attribute pair
+            result << " "
+            result << attr.first.to_s
+            result << '="'
+            result << escape_attributes(attr.last).to_s
+            result << '"'
+          end
+          result
+        end
       end
 
       def escape_attributes(str = '')
-        return str unless str.to_s =~ /["&<>\n]/
+        return str unless str.respond_to?(:match) && str =~ /["&<>\n]/
 
         str
-          .gsub(/&/, "&amp;")
-          .gsub(/"/, "&quot;")
-          .gsub(/</, "&lt;")
-          .gsub(/>/, "&gt;")
-          .gsub(/\n/, "&#xA;")
+          .gsub("&", "&amp;")
+          .gsub('"', "&quot;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\n", "&#xA;")
       end
 
       def escape_data(str = '')
-        if str.to_s =~ /[&<>]/
-          str.gsub(/&/, '&amp;')
-             .gsub(/</, '&lt;')
-             .gsub(/>/, '&gt;')
+        if str.respond_to?(:match) && str =~ /[&<>]/
+          str.gsub("&", '&amp;')
+             .gsub("<", '&lt;')
+             .gsub(">", '&gt;')
         else
           str
         end

data/lib/write_xlsx/sheets.rb

@@ -252,9 +252,13 @@ module Writexlsx
         ['sheetId', sheet_id]
       ]
 
-      attributes << %w[state hidden] if sheet.hidden?
+      if sheet.hidden?
+        attributes << %w[state hidden]
+      elsif sheet.very_hidden?
+        attributes << %w[state veryHidden]
+      end
       attributes << r_id_attributes(sheet_id)
-      writer.empty_tag_encoded('sheet', attributes)
+      writer.empty_tag('sheet', attributes)
     end
   end
 end

data/lib/write_xlsx/sparkline.rb

@@ -43,13 +43,13 @@ module Writexlsx
       # Cleanup the input ranges.
       @ranges.collect! do |range|
         # Remove the absolute reference $ symbols.
-        range = range.gsub(/\$/, '')
+        range = range.gsub("$", '')
         # Convert a simple range into a full Sheet1!A1:D1 range.
         range = "#{sheetname}!#{range}" unless range =~ /!/
         range
       end
       # Cleanup the input locations.
-      @locations.collect! { |location| location.gsub(/\$/, '') }
+      @locations.collect! { |location| location.gsub("$", '') }
 
       # Map options.
       @high      = param[:high_point]

data/lib/write_xlsx/utility.rb

@@ -31,10 +31,12 @@ module Writexlsx
     #
     # xl_rowcol_to_cell($row, col, row_absolute, col_absolute)
     #
-    def xl_rowcol_to_cell(row, col, row_absolute = false, col_absolute = false)
-      row += 1      # Change from 0-indexed to 1 indexed.
+    def xl_rowcol_to_cell(row_or_name, col, row_absolute = false, col_absolute = false)
+      if row_or_name.is_a?(Integer)
+        row_or_name += 1      # Change from 0-indexed to 1 indexed.
+      end
       col_str = xl_col_to_name(col, col_absolute)
-      "#{col_str}#{absolute_char(row_absolute)}#{row}"
+      "#{col_str}#{absolute_char(row_absolute)}#{row_or_name}"
     end
 
     #
@@ -53,7 +55,7 @@ module Writexlsx
 
       # Convert base26 column string to number
       # All your Base are belong to us.
-      chars = col.split(//)
+      chars = col.split("")
       expn = 0
       col = 0
 
@@ -112,7 +114,7 @@ module Writexlsx
     #
     def xl_string_pixel_width(string)
       length = 0
-      string.to_s.split(//).each { |char| length += CHAR_WIDTHS[char] || 8 }
+      string.to_s.split("").each { |char| length += CHAR_WIDTHS[char] || 8 }
 
       length
     end
@@ -128,7 +130,7 @@ module Writexlsx
       name = sheetname.dup
       if name =~ /\W/ && !(name =~ /^'/)
         # Double quote and single quoted strings.
-        name = name.gsub(/'/, "''")
+        name = name.gsub("'", "''")
         name = "'#{name}'"
       end
       name
@@ -159,7 +161,7 @@ module Writexlsx
       seconds   = 0 # Time expressed as fraction of 24h hours in seconds
 
       # Split into date and time.
-      date, time = date_time.split(/T/)
+      date, time = date_time.split("T")
 
       # We allow the time portion of the input DateTime to be optional.
       if time
@@ -207,7 +209,7 @@ module Writexlsx
       # becomes 100 for 4 and 100 year leapdays and 400 for 400 year leapdays.
       #
       epoch   = date_1904? ? 1904 : 1900
-      offset  = date_1904? ?    4 :    0
+      offset  = date_1904? ? 4 : 0
       norm    = 300
       range   = year - epoch
 
@@ -248,7 +250,7 @@ module Writexlsx
     def escape_url(url)
       unless url =~ /%[0-9a-fA-F]{2}/
         # Escape the URL escape symbol.
-        url = url.gsub(/%/, "%25")
+        url = url.gsub("%", "%25")
 
         # Escape whitespae in URL.
         url = url.gsub(/[\s\x00]/, '%20')
@@ -986,6 +988,178 @@ module Writexlsx
     def write_a_end_para_rpr # :nodoc:
       @writer.empty_tag('a:endParaRPr', [%w[lang en-US]])
     end
+
+    #
+    # Extract information from the image file such as dimension, type, filename,
+    # and extension. Also keep track of previously seen images to optimise out
+    # any duplicates.
+    #
+    def get_image_properties(filename)
+      # Note the image_id, and previous_images mechanism isn't currently used.
+      x_dpi = 96
+      y_dpi = 96
+
+      workbook = @workbook || self
+
+      # Open the image file and import the data.
+      data = File.binread(filename)
+      md5  = Digest::MD5.hexdigest(data)
+      if data.unpack1('x A3') == 'PNG'
+        # Test for PNGs.
+        type, width, height, x_dpi, y_dpi = process_png(data)
+        workbook.image_types[:png] = 1
+      elsif data.unpack1('n') == 0xFFD8
+        # Test for JPEG files.
+        type, width, height, x_dpi, y_dpi = process_jpg(data, filename)
+        workbook.image_types[:jpeg] = 1
+      elsif data.unpack1('A4') == 'GIF8'
+        # Test for GIFs.
+        type, width, height, x_dpi, y_dpi = process_gif(data, filename)
+        workbook.image_types[:gif] = 1
+      elsif data.unpack1('A2') == 'BM'
+        # Test for BMPs.
+        type, width, height = process_bmp(data, filename)
+        workbook.image_types[:bmp] = 1
+      else
+        # TODO. Add Image::Size to support other types.
+        raise "Unsupported image format for file: #{filename}\n"
+      end
+
+      # Set a default dpi for images with 0 dpi.
+      x_dpi = 96 if x_dpi == 0
+      y_dpi = 96 if y_dpi == 0
+
+      [type, width, height, File.basename(filename), x_dpi, y_dpi, md5]
+    end
+
+    #
+    # Extract width and height information from a PNG file.
+    #
+    def process_png(data)
+      type   = 'png'
+      width  = 0
+      height = 0
+      x_dpi  = 96
+      y_dpi  = 96
+
+      offset = 8
+      data_length = data.size
+
+      # Search through the image data to read the height and width in th the
+      # IHDR element. Also read the DPI in the pHYs element.
+      while offset < data_length
+
+        length = data[offset + 0, 4].unpack1("N")
+        png_type   = data[offset + 4, 4].unpack1("A4")
+
+        case png_type
+        when "IHDR"
+          width  = data[offset + 8, 4].unpack1("N")
+          height = data[offset + 12, 4].unpack1("N")
+        when "pHYs"
+          x_ppu = data[offset +  8, 4].unpack1("N")
+          y_ppu = data[offset + 12, 4].unpack1("N")
+          units = data[offset + 16, 1].unpack1("C")
+
+          if units == 1
+            x_dpi = x_ppu * 0.0254
+            y_dpi = y_ppu * 0.0254
+          end
+        end
+
+        offset = offset + length + 12
+
+        break if png_type == "IEND"
+      end
+      raise "#{filename}: no size data found in png image.\n" unless height
+
+      [type, width, height, x_dpi, y_dpi]
+    end
+
+    def process_jpg(data, filename)
+      type     = 'jpeg'
+      x_dpi    = 96
+      y_dpi    = 96
+
+      offset = 2
+      data_length = data.bytesize
+
+      # Search through the image data to read the JPEG markers.
+      while offset < data_length
+        marker  = data[offset + 0, 2].unpack1("n")
+        length  = data[offset + 2, 2].unpack1("n")
+
+        # Read the height and width in the 0xFFCn elements
+        # (Except C4, C8 and CC which aren't SOF markers).
+        if (marker & 0xFFF0) == 0xFFC0 &&
+           marker != 0xFFC4 && marker != 0xFFCC
+          height = data[offset + 5, 2].unpack1("n")
+          width  = data[offset + 7, 2].unpack1("n")
+        end
+
+        # Read the DPI in the 0xFFE0 element.
+        if marker == 0xFFE0
+          units     = data[offset + 11, 1].unpack1("C")
+          x_density = data[offset + 12, 2].unpack1("n")
+          y_density = data[offset + 14, 2].unpack1("n")
+
+          if units == 1
+            x_dpi = x_density
+            y_dpi = y_density
+          elsif units == 2
+            x_dpi = x_density * 2.54
+            y_dpi = y_density * 2.54
+          end
+        end
+
+        offset += length + 2
+        break if marker == 0xFFDA
+      end
+
+      raise "#{filename}: no size data found in jpeg image.\n" unless height
+
+      [type, width, height, x_dpi, y_dpi]
+    end
+
+    #
+    # Extract width and height information from a GIF file.
+    #
+    def process_gif(data, filename)
+      type  = 'gif'
+      x_dpi = 96
+      y_dpi = 96
+
+      width  = data[6, 2].unpack1("v")
+      height = data[8, 2].unpack1("v")
+
+      raise "#{filename}: no size data found in gif image.\n" if height.nil?
+
+      [type, width, height, x_dpi, y_dpi]
+    end
+
+    # Extract width and height information from a BMP file.
+    def process_bmp(data, filename)       # :nodoc:
+      type     = 'bmp'
+
+      # Check that the file is big enough to be a bitmap.
+      raise "#{filename} doesn't contain enough data." if data.bytesize <= 0x36
+
+      # Read the bitmap width and height. Verify the sizes.
+      width, height = data.unpack("x18 V2")
+      raise "#{filename}: largest image width #{width} supported is 65k." if width > 0xFFFF
+      raise "#{filename}: largest image height supported is 65k." if height > 0xFFFF
+
+      # Read the bitmap planes and bpp data. Verify them.
+      planes, bitcount = data.unpack("x26 v2")
+      raise "#{filename} isn't a 24bit true color bitmap." unless bitcount == 24
+      raise "#{filename}: only 1 plane supported in bitmap image." unless planes == 1
+
+      # Read the bitmap compression. Verify compression.
+      compression = data.unpack1("x30 V")
+      raise "#{filename}: compression not supported in bitmap image." unless compression == 0
+
+      [type, width, height]
+    end
   end
 
   module WriteDPtPoint

data/lib/write_xlsx/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WriteXLSX_VERSION = "1.11.1"
+WriteXLSX_VERSION = "1.12.0"