caxlsx 3.3.0 → 4.0.0

data/lib/axlsx/workbook/worksheet/pivot_table_cache_definition.rb

@@ -1,10 +1,10 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 module Axlsx
   # Table
   # @note Worksheet#add_pivot_table is the recommended way to create tables for your worksheets.
   # @see README for examples
   class PivotTableCacheDefinition
-
     include Axlsx::OptionsParser
 
     # Creates a new PivotTable object
@@ -26,7 +26,7 @@ module Axlsx
     # The part name for this table
     # @return [String]
     def pn
-      "#{PIVOT_TABLE_CACHE_DEFINITION_PN % (index+1)}"
+      format(PIVOT_TABLE_CACHE_DEFINITION_PN, index + 1)
     end
 
     # The identifier for this cache
@@ -45,22 +45,21 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << ('<pivotCacheDefinition xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '" invalid="1" refreshOnLoad="1" recordCount="0">')
-      str <<   '<cacheSource type="worksheet">'
-      str << (    '<worksheetSource ref="' << pivot_table.range << '" sheet="' << pivot_table.data_sheet.name << '"/>')
-      str <<   '</cacheSource>'
-      str << (  '<cacheFields count="' << pivot_table.header_cells_count.to_s << '">')
+      str << '<pivotCacheDefinition xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '" invalid="1" refreshOnLoad="1" recordCount="0">'
+      str << '<cacheSource type="worksheet">'
+      str << '<worksheetSource ref="' << pivot_table.range << '" sheet="' << pivot_table.data_sheet.name << '"/>'
+      str << '</cacheSource>'
+      str << '<cacheFields count="' << pivot_table.header_cells_count.to_s << '">'
       pivot_table.header_cells.each do |cell|
-        str << (  '<cacheField name="' << cell.clean_value << '" numFmtId="0">')
+        str << '<cacheField name="' << cell.clean_value << '" numFmtId="0">'
         str <<     '<sharedItems count="0">'
         str <<     '</sharedItems>'
-        str <<   '</cacheField>'
+        str << '</cacheField>'
       end
-      str <<   '</cacheFields>'
+      str << '</cacheFields>'
       str << '</pivotCacheDefinition>'
     end
-
   end
 end

data/lib/axlsx/workbook/worksheet/pivot_tables.rb

@@ -1,11 +1,12 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # A simple, self serializing class for storing pivot tables
   class PivotTables < SimpleTypedList
-
     # creates a new Tables object
     def initialize(worksheet)
       raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+
       super PivotTable
       @worksheet = worksheet
     end
@@ -17,8 +18,8 @@ module Axlsx
     # returns the relationships required by this collection
     def relationships
       return [] if empty?
-      map{ |pivot_table| Relationship.new(pivot_table, PIVOT_TABLE_R, "../#{pivot_table.pn}") }
+
+      map { |pivot_table| Relationship.new(pivot_table, PIVOT_TABLE_R, "../#{pivot_table.pn}") }
     end
   end
-
 end

data/lib/axlsx/workbook/worksheet/print_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Options for printing a worksheet. All options are boolean and false by default.
   #
@@ -5,7 +7,6 @@ module Axlsx
   # @see Worksheet#print_options
   # @see Worksheet#initialize
   class PrintOptions
-
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
     include Axlsx::Accessors
@@ -32,7 +33,7 @@ module Axlsx
     # @note As all attributes default to "false" according to the xml schema definition, the generated xml includes only those attributes that are set to true.
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag 'printOptions', str
     end
   end

data/lib/axlsx/workbook/worksheet/protected_range.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Protected Range class represents a set of cells in the worksheet
   # @note the recommended way to manage protected ranges with via Worksheet#protect_range
   # @see Worksheet#protect_range
   class ProtectedRange
-
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
 
-   # Initializes a new protected range object
+    # Initializes a new protected range object
     # @option [String] sqref The cell range reference to protect. This can be an absolute or a relateve range however, it only applies to the current sheet.
     # @option [String] name An optional name for the protected name.
-    def initialize(options={})
+    def initialize(options = {})
       parse_options options
       yield self if block_given?
     end
@@ -40,8 +41,8 @@ module Axlsx
     # @param [String] str if this string object is provided we append
     # our output to that object. Use this - it helps limit the number of
     # objects created during serialization
-    def to_xml_string(str="")
+    def to_xml_string(str = +'')
       serialized_tag 'protectedRange', str
-    end 
+    end
   end
 end

data/lib/axlsx/workbook/worksheet/protected_ranges.rb

@@ -1,13 +1,14 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # A self serializing collection of ranges that should be protected in
   # the worksheet
   class ProtectedRanges < SimpleTypedList
-
     attr_reader :worksheet
 
     def initialize(worksheet)
       raise ArgumentError, 'You must provide a worksheet' unless worksheet.is_a?(Worksheet)
+
       super ProtectedRange
       @worksheet = worksheet
     end
@@ -15,20 +16,21 @@ module Axlsx
     # Adds a protected range
     # @param [Array|String] cells A string range reference or array of cells that will be protected
     def add_range(cells)
-     sqref = if cells.is_a?(String)
-               cells
-             elsif cells.is_a?(SimpleTypedList) || cells.is_a?(Array)
-               Axlsx::cell_range(cells, false)
-             end
-     self << ProtectedRange.new(:sqref => sqref, :name => "Range#{size}")
-     last
+      sqref = if cells.is_a?(String)
+                cells
+              elsif cells.is_a?(SimpleTypedList) || cells.is_a?(Array)
+                Axlsx.cell_range(cells, false)
+              end
+      self << ProtectedRange.new(sqref: sqref, name: "Range#{size}")
+      last
     end
 
     # Serializes the protected ranges
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       return if empty?
+
       str << '<protectedRanges>'
       each { |range| range.to_xml_string(str) }
       str << '</protectedRanges>'

data/lib/axlsx/workbook/worksheet/rich_text.rb

@@ -1,13 +1,13 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # A simple, self serializing class for storing TextRuns
   class RichText < SimpleTypedList
-
     # creates a new RichText collection
     # @param [String] text -optional The text to use in creating the first RichTextRun
     # @param [Object] options -optional The options to use in creating the first RichTextRun
     # @yield [RichText] self
-    def initialize(text = nil, options={})
+    def initialize(text = nil, options = {})
       super(RichTextRun)
       add_run(text, options) unless text.nil?
       yield self if block_given?
@@ -34,7 +34,7 @@ module Axlsx
     # Creates and adds a RichTextRun to this collectino
     # @param [String] text The text to use in creating a new RichTextRun
     # @param [Object] options The options to use in creating the new RichTextRun
-    def add_run(text, options={})
+    def add_run(text, options = {})
       self << RichTextRun.new(text, options)
     end
 
@@ -47,8 +47,8 @@ module Axlsx
     # renders the RichTextRuns in this collection
     # @param [String] str
     # @return [String]
-    def to_xml_string(str='')
-      each{ |run| run.to_xml_string(str) }
+    def to_xml_string(str = +'')
+      each { |run| run.to_xml_string(str) }
       str
     end
   end

data/lib/axlsx/workbook/worksheet/rich_text_run.rb

@@ -1,8 +1,8 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # The RichTextRun class creates and self serializing text run.
   class RichTextRun
-
     include Axlsx::OptionsParser
 
     attr_reader :value
@@ -13,7 +13,7 @@ module Axlsx
                      :shadow, :condense, :extend, :u,
                      :vertAlign, :sz, :color, :scheme].freeze
 
-    def initialize(value, options={})
+    def initialize(value, options = {})
       self.value = value
       parse_options(options)
     end
@@ -27,6 +27,7 @@ module Axlsx
     # The inline font_name property for the cell
     # @return [String]
     attr_reader :font_name
+
     # @see font_name
     def font_name=(v) set_run_style :validate_string, :font_name, v; end
 
@@ -53,6 +54,7 @@ module Axlsx
     # 255  OEM_CHARSET
     # @return [String]
     attr_reader :charset
+
     # @see charset
     def charset=(v) set_run_style :validate_unsigned_int, :charset, v; end
 
@@ -64,6 +66,7 @@ module Axlsx
     # 4 Script
     # 5 Decorative
     attr_reader :family
+
     # @see family
     def family=(v)
       set_run_style :validate_family, :family, v.to_i
@@ -72,42 +75,49 @@ module Axlsx
     # The inline bold property for the cell
     # @return [Boolean]
     attr_reader :b
+
     # @see b
     def b=(v) set_run_style :validate_boolean, :b, v; end
 
     # The inline italic property for the cell
     # @return [Boolean]
     attr_reader :i
+
     # @see i
     def i=(v) set_run_style :validate_boolean, :i, v; end
 
     # The inline strike property for the cell
     # @return [Boolean]
     attr_reader :strike
+
     # @see strike
     def strike=(v) set_run_style :validate_boolean, :strike, v; end
 
     # The inline outline property for the cell
     # @return [Boolean]
     attr_reader :outline
+
     # @see outline
     def outline=(v) set_run_style :validate_boolean, :outline, v; end
 
     # The inline shadow property for the cell
     # @return [Boolean]
     attr_reader :shadow
+
     # @see shadow
     def shadow=(v) set_run_style :validate_boolean, :shadow, v; end
 
     # The inline condense property for the cell
     # @return [Boolean]
     attr_reader :condense
+
     # @see condense
     def condense=(v) set_run_style :validate_boolean, :condense, v; end
 
     # The inline extend property for the cell
     # @return [Boolean]
     attr_reader :extend
+
     # @see extend
     def extend=(v) set_run_style :validate_boolean, :extend, v; end
 
@@ -117,23 +127,26 @@ module Axlsx
     # @return [String]
     # @note true is for backwards compatability and is reassigned to :single
     attr_reader :u
+
     # @see u
     def u=(v)
-      v = :single if (v == true || v == 1 || v == :true || v == 'true')
+      v = :single if v == true || v == 1 || v == :true || v == 'true'
       set_run_style :validate_cell_u, :u, v
     end
 
     # The inline color property for the cell
     # @return [Color]
     attr_reader :color
+
     # @param [String] v The 8 character representation for an rgb color #FFFFFFFF"
     def color=(v)
-      @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+      @color = v.is_a?(Color) ? v : Color.new(rgb: v)
     end
 
     # The inline sz property for the cell
     # @return [Inteter]
     attr_reader :sz
+
     # @see sz
     def sz=(v) set_run_style :validate_unsigned_int, :sz, v; end
 
@@ -141,6 +154,7 @@ module Axlsx
     # this must be one of [:baseline, :subscript, :superscript]
     # @return [Symbol]
     attr_reader :vertAlign
+
     # @see vertAlign
     def vertAlign=(v)
       RestrictionValidator.validate :cell_vertAlign, [:baseline, :subscript, :superscript], v
@@ -151,6 +165,7 @@ module Axlsx
     # this must be one of [:none, major, minor]
     # @return [Symbol]
     attr_reader :scheme
+
     # @see scheme
     def scheme=(v)
       RestrictionValidator.validate :cell_scheme, [:none, :major, :minor], v
@@ -162,6 +177,7 @@ module Axlsx
     # @return [Array]
     def autowidth(widtharray)
       return if value.nil?
+
       if styles.cellXfs[style].alignment && styles.cellXfs[style].alignment.wrap_text
         first = true
         value.to_s.split(/\r?\n/, -1).each do |line|
@@ -181,31 +197,32 @@ module Axlsx
     # Utility method for setting inline style attributes
     def set_run_style(validator, attr, value)
       return unless INLINE_STYLES.include?(attr.to_sym)
+
       Axlsx.send(validator, value) unless validator.nil?
-      self.instance_variable_set :"@#{attr.to_s}", value
+      instance_variable_set :"@#{attr}", value
     end
 
     # Serializes the RichTextRun
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       valid = RichTextRun::INLINE_STYLES
-      data = Hash[Axlsx.instance_values_for(self).map{ |k, v| [k.to_sym, v] }]
-      data = data.select { |key, value| valid.include?(key) && !value.nil? }
+      data = Axlsx.instance_values_for(self).transform_keys(&:to_sym)
+      data = data.select { |key, value| !value.nil? && valid.include?(key) }
 
       str << '<r><rPr>'
-      data.keys.each do |key|
+      data.each do |key, val|
         case key
         when :font_name
-          str << ('<rFont val="' << font_name << '"/>')
+          str << '<rFont val="' << font_name << '"/>'
         when :color
-          str << data[key].to_xml_string
+          str << val.to_xml_string
         else
-          str << ('<' << key.to_s << ' val="' << xml_value(data[key]) << '"/>')
+          str << '<' << key.to_s << ' val="' << xml_value(val) << '"/>'
         end
       end
-      clean_value = Axlsx::trust_input ? @value.to_s : ::CGI.escapeHTML(Axlsx::sanitize(@value.to_s))
-      str << ('</rPr><t>' << clean_value << '</t></r>')
+      clean_value = Axlsx.trust_input ? @value.to_s : ::CGI.escapeHTML(Axlsx.sanitize(@value.to_s))
+      str << '</rPr><t>' << clean_value << '</t></r>'
     end
 
     private
@@ -223,8 +240,9 @@ module Axlsx
     # imagemagick and loading metrics for every character.
     def font_size
       return sz if sz
+
       font = styles.fonts[styles.cellXfs[style].fontId] || styles.fonts[0]
-      (font.b || (defined?(@b) && @b)) ? (font.sz * 1.5) : font.sz
+      font.b || (defined?(@b) && @b) ? (font.sz * 1.5) : font.sz
     end
 
     def style
@@ -237,7 +255,7 @@ module Axlsx
 
     # Converts the value to the correct XML representation (fixes issues with
     # Numbers)
-    def xml_value value
+    def xml_value(value)
       if value == true
         1
       elsif value == false

data/lib/axlsx/workbook/worksheet/row.rb

@@ -1,4 +1,5 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 module Axlsx
   # A Row is a single row in a worksheet.
   # @note The recommended way to manage rows and cells is to use Worksheet#add_row
@@ -6,13 +7,13 @@ module Axlsx
   class Row < SimpleTypedList
     include SerializedAttributes
     include Accessors
-    
+
     # No support is provided for the following attributes
     # spans
     # thickTop
     # thickBottom
 
-   # Creates a new row. New Cell objects are created based on the values, types and style options.
+    # Creates a new row. New Cell objects are created based on the values, types and style options.
     # A new cell is created for each item in the values array. style and types options are applied as follows:
     #   If the types option is defined and is a symbol it is applied to all the cells created.
     #   If the types option is an array, cell types are applied by index for each cell
@@ -24,11 +25,12 @@ module Axlsx
     # @option options [Array] values
     # @option options [Array, Symbol] types
     # @option options [Array, Integer] style
+    # @option options [Array, Boolean] escape_formulas
     # @option options [Float] height the row's height (in points)
     # @option options [Integer] offset - add empty columns before values
     # @see Row#array_to_cells
     # @see Cell
-    def initialize(worksheet, values=[], options={})
+    def initialize(worksheet, values = [], options = {})
       self.worksheet = worksheet
       super(Cell, nil, values.size + options[:offset].to_i)
       self.height = options.delete(:height)
@@ -64,7 +66,7 @@ module Axlsx
     # @see Row#s
     def s=(v)
       Axlsx.validate_unsigned_numeric(v)
-      @custom_format = true 
+      @custom_format = true
       @s = v
     end
 
@@ -73,7 +75,7 @@ module Axlsx
       Axlsx.validate_unsigned_numeric(v)
       @outline_level = v
     end
-    
+
     alias :outlineLevel= :outline_level=
 
     # The index of this row in the worksheet
@@ -86,12 +88,9 @@ module Axlsx
     # @param [Integer] r_index The row index, 0 based.
     # @param [String] str The string this rows xml will be appended to.
     # @return [String]
-    def to_xml_string(r_index, str = '')
-      serialized_tag('row', str, :r => r_index + 1) do
-        tmp = '' # time / memory tradeoff, lots of calls to rubyzip costs more
-                 # time..
-        each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, tmp) }
-        str << tmp
+    def to_xml_string(r_index, str = +'')
+      serialized_tag('row', str, r: Axlsx.row_ref(r_index)) do
+        each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, str) }
       end
     end
 
@@ -104,29 +103,38 @@ module Axlsx
       c
     end
 
-    # sets the color for every cell in this row
+    # Sets the color for every cell in this row.
     def color=(color)
-      each_with_index do | cell, index |
+      each_with_index do |cell, index|
         cell.color = color.is_a?(Array) ? color[index] : color
       end
     end
 
-    # sets the style for every cell in this row
+    # Sets the style for every cell in this row.
     def style=(style)
-      each_with_index do | cell, index |
+      each_with_index do |cell, index|
         cell.style = style.is_a?(Array) ? style[index] : style
       end
     end
 
+    # Sets escape_formulas for every cell in this row. This determines whether to treat
+    # values starting with an equals sign as formulas or as literal strings.
+    # @param [Array, Boolean] value The value to set.
+    def escape_formulas=(value)
+      each_with_index do |cell, index|
+        cell.escape_formulas = value.is_a?(Array) ? value[index] : value
+      end
+    end
+
     # @see height
     def height=(v)
       unless v.nil?
-        Axlsx::validate_unsigned_numeric(v)
+        Axlsx.validate_unsigned_numeric(v)
         @custom_height = true
         @ht = v
       end
     end
-    
+
     # return cells
     def cells
       self
@@ -135,7 +143,7 @@ module Axlsx
     private
 
     # assigns the owning worksheet for this row
-    def worksheet=(v) DataTypeValidator.validate :row_worksheet, Worksheet, v; @worksheet=v; end
+    def worksheet=(v) DataTypeValidator.validate :row_worksheet, Worksheet, v; @worksheet = v; end
 
     # Converts values, types, and style options into cells and associates them with this row.
     # A new cell is created for each item in the values array.
@@ -146,19 +154,19 @@ module Axlsx
     # @option options [Array] values
     # @option options [Array, Symbol] types
     # @option options [Array, Integer] style
-    def array_to_cells(values, options={})
+    # @option options [Array, Boolean] escape_formulas
+    def array_to_cells(values, options = {})
       DataTypeValidator.validate :array_to_cells, Array, values
       types, style, formula_values, escape_formulas, offset = options.delete(:types), options.delete(:style), options.delete(:formula_values), options.delete(:escape_formulas), options.delete(:offset)
       offset.to_i.times { |index| self[index] = Cell.new(self) } if offset
       values.each_with_index do |value, index|
         options[:style] = style.is_a?(Array) ? style[index] : style if style
         options[:type] = types.is_a?(Array) ? types[index] : types if types
-        options[:escape_formulas] = escape_formulas.is_a?(Array) ? escape_formulas[index] : escape_formulas if escape_formulas
+        options[:escape_formulas] = escape_formulas.is_a?(Array) ? escape_formulas[index] : escape_formulas unless escape_formulas.nil?
         options[:formula_value] = formula_values[index] if formula_values.is_a?(Array)
 
         self[index + offset.to_i] = Cell.new(self, value, options)
       end
     end
   end
-
 end

data/lib/axlsx/workbook/worksheet/row_breaks.rb

@@ -1,9 +1,9 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # A collection of break objects that define row breaks (page breaks) for printing and preview
 
   class RowBreaks < SimpleTypedList
-
     def initialize
       super Break
     end
@@ -13,19 +13,20 @@ module Axlsx
     # max and man values are fixed.
     # @see Break
     def add_break(options)
-      # force feed the excel default
-      self << Break.new(options.merge(:max => 16383, :man => true))
+      # force feed the Excel default
+      self << Break.new(options.merge(max: 16383, man: true))
       last
     end
- 
+
     # <rowBreaks count="3" manualBreakCount="3">
     # <brk id="1" max="16383" man="1"/>
     # <brk id="7" max="16383" man="1"/>
     # <brk id="13" max="16383" man="1"/>
     # </rowBreaks>
-    def to_xml_string(str='')
+    def to_xml_string(str = +'')
       return if empty?
-      str << ('<rowBreaks count="' << self.size.to_s << '" manualBreakCount="' << self.size.to_s << '">')
+
+      str << '<rowBreaks count="' << size.to_s << '" manualBreakCount="' << size.to_s << '">'
       each { |brk| brk.to_xml_string(str) }
       str << '</rowBreaks>'
     end