write_xlsx 0.85.9 → 1.09.2

data/lib/write_xlsx/utility.rb

@@ -60,7 +60,11 @@ module Writexlsx
       range1 = xl_rowcol_to_cell(row_1, col_1, row_abs_1, col_abs_1)
       range2 = xl_rowcol_to_cell(row_2, col_2, row_abs_2, col_abs_2)
 
-      "#{range1}:#{range2}"
+      if range1 == range2
+        range1
+      else
+        "#{range1}:#{range2}"
+      end
     end
 
     def xl_range_formula(sheetname, row_1, row_2, col_1, col_2)
@@ -104,22 +108,8 @@ module Writexlsx
     # 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.sub(/^\s+/, '').sub(/\s+$/, '').sub(/Z$/, '')
+      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]/
@@ -218,6 +208,25 @@ module Writexlsx
       end
     end
 
+    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 = $~[1]
+          url = url.sub(re, sprintf("%%%x", match.ord))
+        end
+      end
+
+      url
+    end
+
     def absolute_char(absolute)
       absolute ? '$' : ''
     end
@@ -320,7 +329,7 @@ module Writexlsx
       invalids = params.keys - valid_keys
       unless invalids.empty?
         raise WriteXLSXOptionParameterError,
-          "Unknown parameter '#{invalids.join(', ')}' in #{method}."
+              "Unknown parameter '#{invalids.join(', ')}' in #{method}."
       end
       true
     end
@@ -329,11 +338,6 @@ module Writexlsx
     # 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
@@ -361,6 +365,64 @@ module Writexlsx
       end
     end
 
+    #
+    # Convert user defined legend properties to the structure required internally.
+    #
+    def legend_properties(params)
+      legend = Writexlsx::Chart::Legend.new
+
+      legend.position      = params[:position] || 'right'
+      legend.delete_series = params[:delete_series]
+      legend.font          = convert_font_args(params[:font])
+
+      # Set the legend layout.
+      legend.layout = layout_properties(params[:layout])
+
+      # Turn off the legend.
+      if params[:none]
+        legend.position = 'none'
+      end
+
+      # Set the line properties for the legend.
+      line = line_properties(params[:line])
+
+      # Allow 'border' as a synonym for 'line'.
+      if params[:border]
+        line = line_properties(params[:border])
+      end
+
+      # Set the fill properties for the legend.
+      fill = fill_properties(params[:fill])
+
+      # Set the pattern properties for the legend.
+      pattern = pattern_properties(params[:pattern])
+
+      # Set the gradient fill properties for the legend.
+      gradient = gradient_properties(params[:gradient])
+
+      # Pattern fill overrides solid fill.
+      if pattern
+        fill = nil
+      end
+
+      # Gradient fill overrides solid and pattern fills.
+      if gradient
+        pattern = nil
+        fill    = nil
+      end
+
+      # Set the legend layout.
+      layout = layout_properties(params[:layout])
+
+      legend.line     = line
+      legend.fill     = fill
+      legend.pattern  = pattern
+      legend.gradient = gradient
+      legend.layout   = layout
+
+      @legend = legend
+    end
+
     #
     # Convert user defined layout properties to the format required internally.
     #
@@ -372,7 +434,7 @@ module Writexlsx
       # Check for valid properties.
       args.keys.each do |key|
         unless properties.include?(key.to_sym)
-            raise "Property '#{key}' not allowed in layout options\n"
+          raise "Property '#{key}' not allowed in layout options\n"
         end
       end
 
@@ -405,9 +467,9 @@ module Writexlsx
 
     def v_shape_attributes_base(id, z_index)
       [
-       ['id',          "_x0000_s#{id}"],
-       ['type',        type],
-       ['style',       (v_shape_style_base(z_index, vertices) + style_addition).join]
+        ['id',    "_x0000_s#{id}"],
+        ['type',  type],
+        ['style', (v_shape_style_base(z_index, vertices) + style_addition).join]
       ]
     end
 
@@ -425,17 +487,17 @@ module Writexlsx
 
     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, ';'
+        '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
 
@@ -500,10 +562,10 @@ module Writexlsx
       color   = '#000000'
 
       attributes = [
-                    ['face',  face],
-                    ['size',  size],
-                    ['color', color]
-                   ]
+        ['face',  face],
+        ['size',  size],
+        ['color', color]
+      ]
       @writer.data_element('font', caption, attributes)
     end
 
@@ -543,6 +605,91 @@ module Writexlsx
       line_fill_properties(fill)
     end
 
+    #
+    # Convert user defined pattern properties to the structure required internally.
+    #
+    def pattern_properties(args) # :nodoc:
+      pattern = {}
+
+      return nil unless args
+
+      # Check the pattern type is present.
+      return nil unless args.has_key?(:pattern)
+
+      # Check the foreground color is present.
+      retuen nil unless args.has_key?(:fg_color)
+
+      types = {
+        'percent_5'                 => 'pct5',
+        'percent_10'                => 'pct10',
+        'percent_20'                => 'pct20',
+        'percent_25'                => 'pct25',
+        'percent_30'                => 'pct30',
+        'percent_40'                => 'pct40',
+
+        'percent_50'                => 'pct50',
+        'percent_60'                => 'pct60',
+        'percent_70'                => 'pct70',
+        'percent_75'                => 'pct75',
+        'percent_80'                => 'pct80',
+        'percent_90'                => 'pct90',
+
+        'light_downward_diagonal'   => 'ltDnDiag',
+        'light_upward_diagonal'     => 'ltUpDiag',
+        'dark_downward_diagonal'    => 'dkDnDiag',
+        'dark_upward_diagonal'      => 'dkUpDiag',
+        'wide_downward_diagonal'    => 'wdDnDiag',
+        'wide_upward_diagonal'      => 'wdUpDiag',
+
+        'light_vertical'            => 'ltVert',
+        'light_horizontal'          => 'ltHorz',
+        'narrow_vertical'           => 'narVert',
+        'narrow_horizontal'         => 'narHorz',
+        'dark_vertical'             => 'dkVert',
+        'dark_horizontal'           => 'dkHorz',
+
+        'dashed_downward_diagonal'  => 'dashDnDiag',
+        'dashed_upward_diagonal'    => 'dashUpDiag',
+        'dashed_horizontal'         => 'dashHorz',
+        'dashed_vertical'           => 'dashVert',
+        'small_confetti'            => 'smConfetti',
+        'large_confetti'            => 'lgConfetti',
+
+        'zigzag'                    => 'zigZag',
+        'wave'                      => 'wave',
+        'diagonal_brick'            => 'diagBrick',
+        'horizontal_brick'          => 'horzBrick',
+        'weave'                     => 'weave',
+        'plaid'                     => 'plaid',
+
+        'divot'                     => 'divot',
+        'dotted_grid'               => 'dotGrid',
+        'dotted_diamond'            => 'dotDmnd',
+        'shingle'                   => 'shingle',
+        'trellis'                   => 'trellis',
+        'sphere'                    => 'sphere',
+
+        'small_grid'                => 'smGrid',
+        'large_grid'                => 'lgGrid',
+        'small_check'               => 'smCheck',
+        'large_check'               => 'lgCheck',
+        'outlined_diamond'          => 'openDmnd',
+        'solid_diamond'             => 'solidDmnd'
+      }
+
+      # Check for valid types.
+      if types[args[:pattern]]
+        pattern[:pattern] = types[args[:pattern]]
+      else
+        raise "Unknown pattern type '#{args[:pattern]}'"
+      end
+
+      pattern[:bg_color] = args[:bg_color] || '#FFFFFF'
+      pattern[:fg_color] = args[:fg_color]
+
+      pattern
+    end
+
     def line_fill_properties(params)
       return { :_defined => 0 } unless params
       ret = params.dup
@@ -605,22 +752,236 @@ module Writexlsx
         [options.dup, default_format_properties.dup]
       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.
+      if ptrue?(font[:_rotation])
+        font[:_rotation] = 60_000 * font[:_rotation].to_i
+      end
+
+      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
+
+    #
+    # Write the <c:txPr> element.
+    #
+    def write_tx_pr(font, is_y_axis = nil) # :nodoc:
+      rotation = nil
+      if font && font.respond_to?(:[]) && font[:_rotation]
+        rotation = font[:_rotation]
+      end
+      @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 << ['vert', 'wordArtVert']
+        elsif rot == 16_260_000
+          # 271 deg/stacked angle.
+          attributes << ['rot',  0]
+          attributes << ['vert', 'eaVert']
+        else
+          attributes << ['rot',  rot]
+          attributes << ['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
+          if has_color
+            write_a_solid_fill(:color => font[:_color])
+          end
+          if !latin_attributes.empty?
+            write_a_latin(latin_attributes)
+          end
+        end
+      else
+        @writer.empty_tag(tag, style_attributes)
+      end
+    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 <a:solidFill> element.
+    #
+    def write_a_solid_fill(fill) # :nodoc:
+      @writer.tag_elements('a:solidFill') do
+        if fill[:color]
+          # Write the a:srgbClr element.
+          write_a_srgb_clr(color(fill[:color]), fill[:transparency])
+        end
+      end
+    end
+
+    #
+    # Write the <a:srgbClr> element.
+    #
+    def write_a_srgb_clr(color, transparency = nil) # :nodoc:
+      tag        = 'a:srgbClr'
+      attributes = [ ['val', color] ]
+
+      if ptrue?(transparency)
+        @writer.tag_elements(tag, attributes) do
+          write_a_alpha(transparency)
+        end
+      else
+        @writer.empty_tag(tag, attributes)
+      end
+    end
+
+    #
+    # Convert the user specified colour index or string to a rgb colour.
+    #
+    def color(color_code) # :nodoc:
+      if color_code and color_code =~ /^#[0-9a-fA-F]{6}$/
+        # Convert a HTML style #RRGGBB color.
+        color_code.sub(/^#/, '').upcase
+      else
+        index = Format.color(color_code)
+        raise "Unknown color '#{color_code}' used in chart formatting." unless index
+        palette_color(index)
+      end
+    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 << ['u',  'sng']             if font[:_underline]
+
+      # Turn off baseline when testing fonts that don't have it.
+      if font[:_baseline] != -1
+        attributes << ['baseline', font[:_baseline]]
+      end
+      attributes
+    end
+
+    #
+    # Write the <a:endParaRPr> element.
+    #
+    def write_a_end_para_rpr # :nodoc:
+      @writer.empty_tag('a:endParaRPr', [ ['lang', 'en-US'] ])
+    end
   end
 
   module WriteDPtPoint
-      #
-      # Write an individual <c:dPt> element. Override the parent method to add
-      # markers.
-      #
-      def write_d_pt_point(index, point)
-        @writer.tag_elements('c:dPt') do
-          # Write the c:idx element.
-          write_idx(index)
-          @writer.tag_elements('c:marker') do
-            # Write the c:spPr element.
-            write_sp_pr(point)
-          end
+    #
+    # Write an individual <c:dPt> element. Override the parent method to add
+    # markers.
+    #
+    def write_d_pt_point(index, point)
+      @writer.tag_elements('c:dPt') do
+        # Write the c:idx element.
+        write_idx(index)
+        @writer.tag_elements('c:marker') do
+          # Write the c:spPr element.
+          write_sp_pr(point)
         end
       end
+    end
   end
 end

data/lib/write_xlsx/version.rb

@@ -1 +1 @@
-WriteXLSX_VERSION = "0.85.9"
+WriteXLSX_VERSION = "1.09.2"