write_xlsx 1.13.0 → 1.15.1

data/lib/write_xlsx/utility/date_time.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module DateTime
+      #
+      # 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.
+      #
+      def convert_date_time(date_time_string)       # :nodoc:
+        date_time = date_time_string.to_s.sub(/^\s+/, '').sub(/\s+$/, '').sub(/Z$/, '')
+
+        # 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/
+
+        days      = 0 # Number of days since epoch
+        seconds   = 0 # Time expressed as fraction of 24h hours in seconds
+
+        # 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   = ::Regexp.last_match(1).to_i
+            min    = ::Regexp.last_match(2).to_i
+            sec    = ::Regexp.last_match(4).to_f
+          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   = ::Regexp.last_match(1).to_i
+          month  = ::Regexp.last_match(2).to_i
+          day    = ::Regexp.last_match(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 || year  > 9999
+        return nil if month < 1     || month > 12
+        return nil if day   < 1     || 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? && 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
+    end
+  end
+end

data/lib/write_xlsx/utility/dimensions.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+require 'write_xlsx/constants'
+
+module Writexlsx
+  module Utility
+    module Dimensions
+      include Constants
+
+      def check_dimensions(row, col)
+        raise WriteXLSXDimensionError if !row || row >= ROW_MAX || !col || col >= COL_MAX
+
+        0
+      end
+
+      #
+      # Check that row and col are valid and store max and min values for use in
+      # other methods/elements.
+      #
+      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
+end

data/lib/write_xlsx/utility/drawing.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module Drawing
+      #
+      # Convert vertices from pixels to points.
+      #
+      def pixels_to_points(vertices)
+        _col_start, _row_start, _x1,    _y1,
+        _col_end,   _row_end,   _x2,    _y2,
+        left,      top,       width, height  = vertices.flatten
+
+        left   *= 0.75
+        top    *= 0.75
+        width  *= 0.75
+        height *= 0.75
+
+        [left, top, width, height]
+      end
+
+      def v_shape_attributes_base(id)
+        [
+          ['id',    "_x0000_s#{id}"],
+          ['type',  type]
+        ]
+      end
+
+      def v_shape_style_base(z_index, vertices)
+        left, top, width, height = pixels_to_points(vertices)
+
+        left_str    = float_to_str(left)
+        top_str     = float_to_str(top)
+        width_str   = float_to_str(width)
+        height_str  = float_to_str(height)
+        z_index_str = float_to_str(z_index)
+
+        shape_style_base(left_str, top_str, width_str, height_str, z_index_str)
+      end
+
+      def shape_style_base(left_str, top_str, width_str, height_str, z_index_str)
+        [
+          'position:absolute;',
+          'margin-left:',
+          left_str, 'pt;',
+          'margin-top:',
+          top_str, 'pt;',
+          'width:',
+          width_str, 'pt;',
+          'height:',
+          height_str, 'pt;',
+          'z-index:',
+          z_index_str, ';'
+        ]
+      end
+
+      #
+      # Write the <v:fill> element.
+      #
+      def write_fill
+        @writer.empty_tag('v:fill', fill_attributes)
+      end
+
+      #
+      # Write the <v:path> element.
+      #
+      def write_comment_path(gradientshapeok, connecttype)
+        attributes = []
+
+        attributes << %w[gradientshapeok t] if gradientshapeok
+        attributes << ['o:connecttype', connecttype]
+
+        @writer.empty_tag('v:path', attributes)
+      end
+
+      #
+      # Write the <x:Anchor> element.
+      #
+      def write_anchor
+        col_start, row_start, x1, y1, col_end, row_end, x2, y2 = @vertices
+        data = [col_start, x1, row_start, y1, col_end, x2, row_end, y2].join(', ')
+
+        @writer.data_element('x:Anchor', data)
+      end
+
+      #
+      # Write the <x:AutoFill> element.
+      #
+      def write_auto_fill
+        @writer.data_element('x:AutoFill', 'False')
+      end
+
+      #
+      # Write the <div> element.
+      #
+      def write_div(align, font = nil)
+        style = "text-align:#{align}"
+        attributes = [['style', style]]
+
+        @writer.tag_elements('div', attributes) do
+          if font
+            # Write the font element.
+            write_font(font)
+          end
+        end
+      end
+
+      #
+      # Write the <font> element.
+      #
+      def write_font(font)
+        caption = font[:_caption]
+        face    = 'Calibri'
+        size    = 220
+        color   = '#000000'
+
+        attributes = [
+          ['face',  face],
+          ['size',  size],
+          ['color', color]
+        ]
+        @writer.data_element('font', caption, attributes)
+      end
+
+      #
+      # Write the <v:stroke> element.
+      #
+      def write_stroke
+        attributes = [%w[joinstyle miter]]
+
+        @writer.empty_tag('v:stroke', attributes)
+      end
+    end
+  end
+end

data/lib/write_xlsx/utility/rich_text.rb

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module RichText
+      def underline_attributes(underline)
+        case underline
+        when 2
+          [%w[val double]]
+        when 33
+          [%w[val singleAccounting]]
+        when 34
+          [%w[val doubleAccounting]]
+        else
+          []    # Default to single underline.
+        end
+      end
+
+      #
+      # Convert user defined font values into private hash values.
+      #
+      def convert_font_args(params)
+        return unless params
+
+        font = params_to_font(params)
+
+        # Convert font size units.
+        font[:_size] *= 100 if font[:_size] && font[:_size] != 0
+
+        # Convert rotation into 60,000ths of a degree.
+        font[:_rotation] = 60_000 * font[:_rotation].to_i if ptrue?(font[:_rotation])
+
+        font
+      end
+
+      def params_to_font(params)
+        {
+          _name:         params[:name],
+          _color:        params[:color],
+          _size:         params[:size],
+          _bold:         params[:bold],
+          _italic:       params[:italic],
+          _underline:    params[:underline],
+          _pitch_family: params[:pitch_family],
+          _charset:      params[:charset],
+          _baseline:     params[:baseline] || 0,
+          _rotation:     params[:rotation]
+        }
+      end
+
+      #
+      # Get the font style attributes from a font hash.
+      #
+      def get_font_style_attributes(font)
+        return [] unless font
+        return [] unless font.respond_to?(:[])
+
+        attributes = []
+        attributes << ['sz', font[:_size]]      if ptrue?(font[:_size])
+        attributes << ['b',  font[:_bold]]      if font[:_bold]
+        attributes << ['i',  font[:_italic]]    if font[:_italic]
+        attributes << %w[u sng]                 if font[:_underline]
+
+        # Turn off baseline when testing fonts that don't have it.
+        attributes << ['baseline', font[:_baseline]] if font[:_baseline] != -1
+        attributes
+      end
+
+      #
+      # Get the font latin attributes from a font hash.
+      #
+      def get_font_latin_attributes(font)
+        return [] unless font
+        return [] unless font.respond_to?(:[])
+
+        attributes = []
+        attributes << ['typeface', font[:_name]]            if ptrue?(font[:_name])
+        attributes << ['pitchFamily', font[:_pitch_family]] if font[:_pitch_family]
+        attributes << ['charset', font[:_charset]]          if font[:_charset]
+
+        attributes
+      end
+
+      #
+      # Write the <c:txPr> element.
+      #
+      def write_tx_pr(font, is_y_axis = nil) # :nodoc:
+        rotation = nil
+        rotation = font[:_rotation] if font && font.respond_to?(:[]) && font[:_rotation]
+        @writer.tag_elements('c:txPr') do
+          # Write the a:bodyPr element.
+          write_a_body_pr(rotation, is_y_axis)
+          # Write the a:lstStyle element.
+          write_a_lst_style
+          # Write the a:p element.
+          write_a_p_formula(font)
+        end
+      end
+
+      #
+      # Write the <a:bodyPr> element.
+      #
+      def write_a_body_pr(rot, is_y_axis = nil) # :nodoc:
+        rot = -5400000 if !rot && ptrue?(is_y_axis)
+        attributes = []
+        if rot
+          if rot == 16_200_000
+            # 270 deg/stacked angle.
+            attributes << ['rot',  0]
+            attributes << %w[vert wordArtVert]
+          elsif rot == 16_260_000
+            # 271 deg/stacked angle.
+            attributes << ['rot',  0]
+            attributes << %w[vert eaVert]
+          else
+            attributes << ['rot',  rot]
+            attributes << %w[vert horz]
+          end
+        end
+
+        @writer.empty_tag('a:bodyPr', attributes)
+      end
+
+      #
+      # Write the <a:lstStyle> element.
+      #
+      def write_a_lst_style # :nodoc:
+        @writer.empty_tag('a:lstStyle')
+      end
+
+      #
+      # Write the <a:p> element for formula titles.
+      #
+      def write_a_p_formula(font = nil) # :nodoc:
+        @writer.tag_elements('a:p') do
+          # Write the a:pPr element.
+          write_a_p_pr_formula(font)
+          # Write the a:endParaRPr element.
+          write_a_end_para_rpr
+        end
+      end
+
+      #
+      # Write the <a:pPr> element for formula titles.
+      #
+      def write_a_p_pr_formula(font) # :nodoc:
+        @writer.tag_elements('a:pPr') { write_a_def_rpr(font) }
+      end
+
+      #
+      # Write the <a:defRPr> element.
+      #
+      def write_a_def_rpr(font = nil) # :nodoc:
+        write_def_rpr_r_pr_common(
+          font,
+          get_font_style_attributes(font),
+          'a:defRPr'
+        )
+      end
+
+      def write_def_rpr_r_pr_common(font, style_attributes, tag)  # :nodoc:
+        latin_attributes = get_font_latin_attributes(font)
+        has_color = ptrue?(font) && ptrue?(font[:_color])
+
+        if !latin_attributes.empty? || has_color
+          @writer.tag_elements(tag, style_attributes) do
+            write_a_solid_fill(color: font[:_color]) if has_color
+            write_a_latin(latin_attributes) unless latin_attributes.empty?
+          end
+        else
+          @writer.empty_tag(tag, style_attributes)
+        end
+      end
+
+      #
+      # Write the <a:endParaRPr> element.
+      #
+      def write_a_end_para_rpr # :nodoc:
+        @writer.empty_tag('a:endParaRPr', [%w[lang en-US]])
+      end
+    end
+  end
+end

data/lib/write_xlsx/utility/sheetname_quoting.rb

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module SheetnameQuoting
+      #
+      # Sheetnames used in references should be quoted if they contain any spaces,
+      # special characters or if the look like something that isn't a sheet name.
+      # TODO. We need to handle more special cases.
+      #
+      def quote_sheetname(sheetname) # :nodoc:
+        name = sheetname.dup
+        return name if already_quoted_sheetname?(name)
+        return name unless sheetname_needs_quoting?(name)
+
+        "'#{escape_sheetname(name)}'"
+      end
+
+      private
+
+      def already_quoted_sheetname?(name)
+        name.start_with?("'")
+      end
+
+      def escape_sheetname(name)
+        name.gsub("'", "''")
+      end
+
+      def sheetname_needs_quoting?(name)
+        contains_non_identifier_chars?(name) ||
+          starts_with_digit_or_dot?(name) ||
+          valid_a1_reference_name?(name) ||
+          starts_with_rc_reference?(name) ||
+          single_rc_reference?(name)
+      end
+
+      def contains_non_identifier_chars?(name)
+        name.match?(/[^\p{L}\p{N}_.]/)
+      end
+
+      def starts_with_digit_or_dot?(name)
+        name.match?(/^[\p{N}.]/)
+      end
+
+      def valid_a1_reference_name?(name)
+        upcased = name.upcase
+        return false unless upcased.match?(/^[A-Z]{1,3}\d+$/)
+
+        row, col = xl_cell_to_rowcol(upcased)
+        row.between?(0, 1_048_575) && col.between?(0, 16_383)
+      end
+
+      def starts_with_rc_reference?(name)
+        upcased = name.upcase
+
+        if (match = upcased.match(/^R(\d+)/))
+          return match[1].to_i.between?(1, 1_048_576)
+        end
+
+        if (match = upcased.match(/^R?C(\d+)/))
+          return match[1].to_i.between?(1, 16_384)
+        end
+
+        false
+      end
+
+      def single_rc_reference?(name)
+        %w[R C RC].include?(name.upcase)
+      end
+    end
+  end
+end

data/lib/write_xlsx/utility/string_width.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module StringWidth
+      MAX_DIGIT_WIDTH    = 7    # For Calabri 11.  # :nodoc:
+      PADDING            = 5                       # :nodoc:
+      DEFAULT_COL_PIXELS = 64
+      CHAR_WIDTHS = {
+        ' '  =>  3, '!' =>  5, '"' =>  6, '#' =>  7, '$' =>  7, '%' => 11,
+        '&'  => 10, "'" =>  3, '(' =>  5, ')' =>  5, '*' =>  7, '+' =>  7,
+        ','  =>  4, '-' =>  5, '.' =>  4, '/' =>  6, '0' =>  7, '1' =>  7,
+        '2'  =>  7, '3' =>  7, '4' =>  7, '5' =>  7, '6' =>  7, '7' =>  7,
+        '8'  =>  7, '9' =>  7, ':' =>  4, ';' =>  4, '<' =>  7, '=' =>  7,
+        '>'  =>  7, '?' =>  7, '@' => 13, 'A' =>  9, 'B' =>  8, 'C' =>  8,
+        'D'  =>  9, 'E' =>  7, 'F' =>  7, 'G' =>  9, 'H' =>  9, 'I' =>  4,
+        'J'  =>  5, 'K' =>  8, 'L' =>  6, 'M' => 12, 'N' => 10, 'O' => 10,
+        'P'  =>  8, 'Q' => 10, 'R' =>  8, 'S' =>  7, 'T' =>  7, 'U' =>  9,
+        'V'  =>  9, 'W' => 13, 'X' =>  8, 'Y' =>  7, 'Z' =>  7, '[' =>  5,
+        '\\' =>  6, ']' =>  5, '^' =>  7, '_' =>  7, '`' =>  4, 'a' =>  7,
+        'b'  =>  8, 'c' =>  6, 'd' =>  8, 'e' =>  8, 'f' =>  5, 'g' =>  7,
+        'h'  =>  8, 'i' =>  4, 'j' =>  4, 'k' =>  7, 'l' =>  4, 'm' => 12,
+        'n'  =>  8, 'o' =>  8, 'p' =>  8, 'q' =>  8, 'r' =>  5, 's' =>  6,
+        't'  =>  5, 'u' =>  8, 'v' =>  7, 'w' => 11, 'x' =>  7, 'y' =>  7,
+        'z'  =>  6, '{' =>  5, '|' =>  7, '}' =>  5, '~' =>  7
+      }.freeze
+
+      #
+      # xl_string_pixel_width($string)
+      #
+      # Get the pixel width of a string based on individual character widths taken
+      # from Excel. UTF8 characters are given a default width of 8.
+      #
+      # Note, Excel adds an additional 7 pixels padding to a cell.
+      #
+      def xl_string_pixel_width(string)
+        length = 0
+        string.to_s.chars.each { |char| length += CHAR_WIDTHS[char] || 8 }
+
+        length
+      end
+    end
+  end
+end

data/lib/write_xlsx/utility/url.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module Url
+      def escape_url(url)
+        unless url =~ /%[0-9a-fA-F]{2}/
+          # Escape the URL escape symbol.
+          url = url.gsub("%", "%25")
+
+          # Escape whitespae in URL.
+          url = url.gsub(/[\s\x00]/, '%20')
+
+          # Escape other special characters in URL.
+          re = /(["<>\[\]`^{}])/
+          while re =~ url
+            match = $LAST_MATCH_INFO[1]
+            url = url.sub(re, sprintf("%%%x", match.ord))
+          end
+        end
+
+        url
+      end
+    end
+  end
+end

data/lib/write_xlsx/utility/xml_primitives.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  module Utility
+    module XmlPrimitives
+      #
+      # Write the <color> element.
+      #
+      def write_color(name, value, writer = @writer) # :nodoc:
+        attributes = [[name, value]]
+
+        writer.empty_tag('color', attributes)
+      end
+
+      def write_xml_declaration
+        @writer.xml_decl
+        yield
+        @writer.crlf
+        @writer.close
+      end
+
+      def r_id_attributes(id)
+        ['r:id', "rId#{id}"]
+      end
+
+      def xml_str
+        @writer.string
+      end
+    end
+  end
+end

data/lib/write_xlsx/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WriteXLSX_VERSION = "1.13.0"
+WriteXLSX_VERSION = "1.15.1"