write_xlsx 1.12.3 → 1.15.0

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.12.3"
+WriteXLSX_VERSION = "1.15.0"

data/lib/write_xlsx/workbook/chart_data.rb

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+module Writexlsx
+  class Workbook
+    module ChartData
+      private
+
+      #
+      # Convert a range formula such as Sheet1!$B$1:$B$5 into a sheet name and cell
+      # range such as ( 'Sheet1', 0, 1, 4, 1 ).
+      #
+      def get_chart_range(range) # :nodoc:
+        # Split the range formula into sheetname and cells at the last '!'.
+        pos = range.rindex('!')
+        return nil unless pos
+
+        if pos > 0
+          sheetname = range[0, pos]
+          cells = range[(pos + 1)..-1]
+        end
+
+        # Split the cell range into 2 cells or else use single cell for both.
+        if cells =~ /:/
+          cell_1, cell_2 = cells.split(":")
+        else
+          cell_1 = cells
+          cell_2 = cells
+        end
+
+        # Remove leading/trailing apostrophes and convert escaped quotes to single.
+        sheetname.sub!(/^'/, '')
+        sheetname.sub!(/'$/, '')
+        sheetname.gsub!("''", "'")
+
+        row_start, col_start = xl_cell_to_rowcol(cell_1)
+        row_end,   col_end   = xl_cell_to_rowcol(cell_2)
+
+        # Check that we have a 1D range only.
+        return nil if row_start != row_end && col_start != col_end
+
+        [sheetname, row_start, col_start, row_end, col_end]
+      end
+
+      #
+      # Add "cached" data to charts to provide the numCache and strCache data for
+      # series and title/axis ranges.
+      #
+      def add_chart_data # :nodoc:
+        worksheets = {}
+        seen_ranges = {}
+
+        # Map worksheet names to worksheet objects.
+        @worksheets.each { |worksheet| worksheets[worksheet.name] = worksheet }
+
+        # Build an array of the worksheet charts including any combined charts.
+        @charts.collect { |chart| [chart, chart.combined] }.flatten.compact
+          .each do |chart|
+            chart.formula_ids.each do |range, id|
+              # Skip if the series has user defined data.
+              if chart.formula_data[id]
+                seen_ranges[range] = chart.formula_data[id] unless seen_ranges[range]
+                next
+              # Check to see if the data is already cached locally.
+              elsif seen_ranges[range]
+                chart.formula_data[id] = seen_ranges[range]
+                next
+              end
+
+              # Convert the range formula to a sheet name and cell range.
+              sheetname, *cells = get_chart_range(range)
+
+              # Skip if we couldn't parse the formula.
+              next unless sheetname
+
+              # Handle non-contiguous ranges: (Sheet1!$A$1:$A$2,Sheet1!$A$4:$A$5).
+              # We don't try to parse the ranges. We just return an empty list.
+              if sheetname =~ /^\([^,]+,/
+                chart.formula_data[id] = []
+                seen_ranges[range] = []
+                next
+              end
+
+              # Raise if the name is unknown since it indicates a user error in
+              # a chart series formula.
+              raise "Unknown worksheet reference '#{sheetname}' in range '#{range}' passed to add_series()\n" unless worksheets[sheetname]
+
+              # Add the data to the chart.
+              # And store range data locally to avoid lookup if seen agein.
+              chart.formula_data[id] =
+                seen_ranges[range] = chart_data(worksheets[sheetname], cells)
+            end
+        end
+      end
+
+      def chart_data(worksheet, cells)
+        # Get the data from the worksheet table.
+        data = worksheet.get_range_data(*cells)
+
+        # Convert shared string indexes to strings.
+        data.collect do |token|
+          if token.is_a?(Hash)
+            string = @shared_strings.string(token[:sst_id])
+
+            # Ignore rich strings for now. Deparse later if necessary.
+            if string =~ /^<r>/ && string =~ %r{</r>$}
+              ''
+            else
+              string
+            end
+          else
+            token
+          end
+        end
+      end
+
+      #
+      # Sort internal and user defined names in the same order as used by Excel.
+      # This may not be strictly necessary but unsorted elements caused a lot of
+      # issues in the the Spreadsheet::WriteExcel binary version. Also makes
+      # comparison testing easier.
+      #
+      def sort_defined_names(names) # :nodoc:
+        names.sort do |a, b|
+          name_a  = normalise_defined_name(a[0])
+          name_b  = normalise_defined_name(b[0])
+          sheet_a = normalise_sheet_name(a[2])
+          sheet_b = normalise_sheet_name(b[2])
+          # Primary sort based on the defined name.
+          if name_a > name_b
+            1
+          elsif name_a < name_b
+            -1
+          elsif sheet_a >= sheet_b  # name_a == name_b
+            # Secondary sort based on the sheet name.
+            1
+          else
+            -1
+          end
+        end
+      end
+
+      # Used in the above sort routine to normalise the defined names. Removes any
+      # leading '_xmln.' from internal names and lowercases the strings.
+      def normalise_defined_name(name) # :nodoc:
+        name.sub(/^_xlnm./, '').downcase
+      end
+
+      # Used in the above sort routine to normalise the worksheet names for the
+      # secondary sort. Removes leading quote and lowercases the strings.
+      def normalise_sheet_name(name) # :nodoc:
+        name.sub(/^'/, '').downcase
+      end
+
+      #
+      # Extract the named ranges from the sorted list of defined names. These are
+      # used in the App.xml file.
+      #
+      def extract_named_ranges(defined_names) # :nodoc:
+        named_ranges = []
+
+        defined_names.each do |defined_name|
+          name, index, range = defined_name
+
+          # Skip autoFilter ranges.
+          next if name == '_xlnm._FilterDatabase'
+
+          # We are only interested in defined names with ranges.
+          next unless range =~ /^([^!]+)!/
+
+          sheet_name = ::Regexp.last_match(1)
+
+          # Match Print_Area and Print_Titles xlnm types.
+          if name =~ /^_xlnm\.(.*)$/
+            xlnm_type = ::Regexp.last_match(1)
+            name = "#{sheet_name}!#{xlnm_type}"
+          elsif index != -1
+            name = "#{sheet_name}!#{name}"
+          end
+
+          named_ranges << name
+        end
+
+        named_ranges
+      end
+    end
+  end
+end