axlsx 1.2.0 → 2.0.0

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

@@ -0,0 +1,273 @@
+# encoding: UTF-8
+module Axlsx
+  # Table
+  # @note Worksheet#add_pivot_table is the recommended way to create tables for your worksheets.
+  # @see README for examples
+  class PivotTable
+
+    include Axlsx::OptionsParser
+
+    # Creates a new PivotTable object
+    # @param [String] ref The reference to where the pivot table lives like 'G4:L17'.
+    # @param [String] range The reference to the pivot table data like 'A1:D31'.
+    # @param [Worksheet] sheet The sheet containing the table data.
+    # @option options [Cell, String] name
+    # @option options [TableStyle] style
+    def initialize(ref, range, sheet, options={})
+      @ref = ref
+      self.range = range
+      @sheet = sheet
+      @sheet.workbook.pivot_tables << self
+      @name = "PivotTable#{index+1}"
+      @data_sheet = nil
+      @rows = []
+      @columns = []
+      @data = []
+      @pages = []
+      @subtotal = nil
+      parse_options options
+      yield self if block_given?
+    end
+
+    # The reference to the table data
+    # @return [String]
+    attr_reader :ref
+
+    # The name of the table.
+    # @return [String]
+    attr_reader :name
+
+    # The name of the sheet.
+    # @return [String]
+    attr_reader :sheet
+
+    # The sheet used as data source for the pivot table
+    # @return [Worksheet]
+    attr_writer :data_sheet
+
+    # @see #data_sheet
+    def data_sheet
+      @data_sheet || @sheet
+    end
+
+    # The range where the data for this pivot table lives.
+    # @return [String]
+    attr_reader :range
+
+    # (see #range)
+    def range=(v)
+      DataTypeValidator.validate "#{self.class}.range", [String], v
+      if v.is_a?(String)
+        @range = v
+      end
+    end
+
+    # The rows
+    # @return [Array]
+    attr_reader :rows
+
+
+    # (see #rows)
+    def rows=(v)
+      DataTypeValidator.validate "#{self.class}.rows", [Array], v
+      v.each do |ref|
+        DataTypeValidator.validate "#{self.class}.rows[]", [String], ref
+      end
+      @rows = v
+    end
+
+    # The columns
+    # @return [Array]
+    attr_reader :columns
+
+    # (see #columns)
+    def columns=(v)
+      DataTypeValidator.validate "#{self.class}.columns", [Array], v
+      v.each do |ref|
+        DataTypeValidator.validate "#{self.class}.columns[]", [String], ref
+      end
+      @columns = v
+    end
+
+    # The data
+    # @return [Array]
+    attr_reader :data
+
+    # (see #data)
+    def data=(v)
+      DataTypeValidator.validate "#{self.class}.data", [Array], v
+      @data = []
+      v.each do |data_field|
+        if data_field.is_a? String
+          data_field = {:ref => data_field}
+        end
+        data_field.values.each do |value|
+          DataTypeValidator.validate "#{self.class}.data[]", [String], value
+        end
+        @data << data_field
+      end
+      @data
+    end
+
+    # The pages
+    # @return [String]
+    attr_reader :pages
+
+    # (see #pages)
+    def pages=(v)
+      DataTypeValidator.validate "#{self.class}.pages", [Array], v
+      v.each do |ref|
+        DataTypeValidator.validate "#{self.class}.pages[]", [String], ref
+      end
+      @pages = v
+    end
+
+    # The index of this chart in the workbooks charts collection
+    # @return [Integer]
+    def index
+      @sheet.workbook.pivot_tables.index(self)
+    end
+
+    # The part name for this table
+    # @return [String]
+    def pn
+      "#{PIVOT_TABLE_PN % (index+1)}"
+    end
+
+    # The relationship part name of this pivot table
+    # @return [String]
+    def rels_pn
+      "#{PIVOT_TABLE_RELS_PN % (index+1)}"
+    end
+
+    # The cache_definition for this pivot table
+    # @return [PivotTableCacheDefinition]
+    def cache_definition
+      @cache_definition ||= PivotTableCacheDefinition.new(self)
+    end
+
+    # The relationships for this pivot table.
+    # @return [Relationships]
+    def relationships
+      r = Relationships.new
+      r << Relationship.new(cache_definition, PIVOT_TABLE_CACHE_DEFINITION_R, "../#{cache_definition.pn}")
+      r
+    end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<pivotTableDefinition xmlns="' << XML_NS << '" name="' << name << '" cacheId="' << cache_definition.cache_id.to_s << '"  dataOnRows="1" applyNumberFormats="0" applyBorderFormats="0" applyFontFormats="0" applyPatternFormats="0" applyAlignmentFormats="0" applyWidthHeightFormats="1" dataCaption="Data" showMultipleLabel="0" showMemberPropertyTips="0" useAutoFormatting="1" indent="0" compact="0" compactData="0" gridDropZones="1" multipleFieldFilters="0">'
+      str <<   '<location firstDataCol="1" firstDataRow="1" firstHeaderRow="1" ref="' << ref << '"/>'
+      str <<   '<pivotFields count="' << header_cells_count.to_s << '">'
+      header_cell_values.each do |cell_value|
+        str <<   pivot_field_for(cell_value)
+      end
+      str <<   '</pivotFields>'
+      if rows.empty?
+        str << '<rowFields count="1"><field x="-2"/></rowFields>'
+        str << '<rowItems count="2"><i><x/></i> <i i="1"><x v="1"/></i></rowItems>'
+      else
+        str << '<rowFields count="' << rows.size.to_s << '">'
+        rows.each do |row_value|
+          str << '<field x="' << header_index_of(row_value).to_s << '"/>'
+        end
+        str << '</rowFields>'
+        str << '<rowItems count="' << rows.size.to_s << '">'
+        rows.size.times do |i|
+          str << '<i/>'
+        end
+        str << '</rowItems>'
+      end
+      if columns.empty?
+        str << '<colItems count="1"><i/></colItems>'
+      else
+        str << '<colFields count="' << columns.size.to_s << '">'
+        columns.each do |column_value|
+          str << '<field x="' << header_index_of(column_value).to_s << '"/>'
+        end
+        str << '</colFields>'
+      end
+      unless pages.empty?
+        str << '<pageFields count="' << pages.size.to_s << '">'
+        pages.each do |page_value|
+          str << '<pageField fld="' << header_index_of(page_value).to_s << '"/>'
+        end
+        str << '</pageFields>'
+      end
+      unless data.empty?
+        str << "<dataFields count=\"#{data.size}\">"
+        data.each do |datum_value|
+          str << "<dataField name='#{@subtotal} of #{datum_value[:ref]}' fld='#{header_index_of(datum_value[:ref])}' baseField='0' baseItem='0'"
+          str << " subtotal='#{datum_value[:subtotal]}' " if datum_value[:subtotal]
+          str << "/>"
+        end
+        str << '</dataFields>'
+      end
+      str << '</pivotTableDefinition>'
+    end
+
+    # References for header cells
+    # @return [Array]
+    def header_cell_refs
+      Axlsx::range_to_a(header_range).first
+    end
+
+    # The header cells for the pivot table
+    # @return [Array]
+    def header_cells
+      data_sheet[header_range]
+    end
+
+    # The values in the header cells collection
+    # @return [Array]
+    def header_cell_values
+      header_cells.map(&:value)
+    end
+
+    # The number of cells in the header_cells collection
+    # @return [Integer]
+    def header_cells_count
+      header_cells.count
+    end
+
+    # The index of a given value in the header cells
+    # @return [Integer]
+    def header_index_of(value)
+      header_cell_values.index(value)
+    end
+
+    private
+
+    def pivot_field_for(cell_ref)
+      if rows.include? cell_ref
+        '<pivotField axis="axisRow" compact="0" outline="0" subtotalTop="0" showAll="0" includeNewItemsInFilter="1">' <<
+          '<items count="1"><item t="default"/></items>' <<
+        '</pivotField>'
+      elsif columns.include? cell_ref
+        '<pivotField axis="axisCol" compact="0" outline="0" subtotalTop="0" showAll="0" includeNewItemsInFilter="1">' <<
+          '<items count="1"><item t="default"/></items>' <<
+        '</pivotField>'
+      elsif pages.include? cell_ref
+        '<pivotField axis="axisCol" compact="0" outline="0" subtotalTop="0" showAll="0" includeNewItemsInFilter="1">' <<
+          '<items count="1"><item t="default"/></items>' <<
+        '</pivotField>'
+      elsif data_refs.include? cell_ref
+        '<pivotField dataField="1" compact="0" outline="0" subtotalTop="0" showAll="0" includeNewItemsInFilter="1">' <<
+        '</pivotField>'
+      else
+        '<pivotField compact="0" outline="0" subtotalTop="0" showAll="0" includeNewItemsInFilter="1">' <<
+        '</pivotField>'
+      end
+    end
+    def data_refs
+      data.map { |hash| hash[:ref] }
+    end
+    def header_range
+      range.gsub(/^(\w+?)(\d+)\:(\w+?)\d+$/, '\1\2:\3\2')
+    end
+
+  end
+end

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

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+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
+    # @param [String] pivot_table The pivot table this cache definition is in
+    def initialize(pivot_table)
+      @pivot_table = pivot_table
+    end
+
+    # # The reference to the pivot table data
+    # # @return [PivotTable]
+    attr_reader :pivot_table
+
+    # The index of this chart in the workbooks charts collection
+    # @return [Integer]
+    def index
+      pivot_table.sheet.workbook.pivot_tables.index(pivot_table)
+    end
+
+    # The part name for this table
+    # @return [String]
+    def pn
+      "#{PIVOT_TABLE_CACHE_DEFINITION_PN % (index+1)}"
+    end
+
+    # The identifier for this cache
+    # @return [Integer]
+    def cache_id
+      index + 1
+    end
+
+    # The relationship id for this pivot table cache definition.
+    # @see Relationship#Id
+    # @return [String]
+    def rId
+      pivot_table.relationships.for(self).Id
+    end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    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 << '">'
+      pivot_table.header_cells.each do |cell|
+        str <<   '<cacheField name="' << cell.value << '" numFmtId="0">'
+        str <<     '<sharedItems count="0">'
+        str <<     '</sharedItems>'
+        str <<   '</cacheField>'
+      end
+      str <<   '</cacheFields>'
+      str << '</pivotCacheDefinition>'
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+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
+
+    # The worksheet that owns this collection of pivot tables
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # 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}") }
+    end
+  end
+
+end

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

@@ -6,22 +6,9 @@ module Axlsx
   # @see Worksheet#initialize
   class PrintOptions
 
-    # Whether grid lines should be printed.
-    # @return [Boolean]
-    attr_reader :grid_lines
-
-    # Whether row and column headings should be printed.
-    # @return [Boolean]
-    attr_reader :headings
-
-    # Whether the content should be centered horizontally on the page.
-    # @return [Boolean]
-    attr_reader :horizontal_centered
-
-    # Whether the content should be centered vertically on the page.
-    # @return [Boolean]
-    attr_reader :vertical_centered
-
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+    include Axlsx::Accessors
     # Creates a new PrintOptions object
     # @option options [Boolean] grid_lines Whether grid lines should be printed
     # @option options [Boolean] headings Whether row and column headings should be printed
@@ -32,31 +19,22 @@ module Axlsx
       set(options)
     end
 
+    serializable_attributes :grid_lines, :headings, :horizontal_centered, :vertical_centered
+    boolean_attr_accessor :grid_lines, :headings, :horizontal_centered, :vertical_centered
+
     # Set some or all options at once.
     # @param [Hash] options The options to set (possible keys are :grid_lines, :headings, :horizontal_centered, and :vertical_centered).
     def set(options)
-      options.each do |k, v|
-        send("#{k}=", v) if respond_to? "#{k}="
-      end
+      parse_options options
     end
 
-    # @see grid_lines
-    def grid_lines=(v); Axlsx::validate_boolean(v); @grid_lines = v; end
-    # @see headings
-    def headings=(v); Axlsx::validate_boolean(v); @headings = v; end
-    # @see horizontal_centered
-    def horizontal_centered=(v); Axlsx::validate_boolean(v); @horizontal_centered = v; end
-    # @see vertical_centered
-    def vertical_centered=(v); Axlsx::validate_boolean(v); @vertical_centered = v; end
-
     # Serializes the page options element.
     # @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 = '')
       str << '<printOptions '
-      # 
-      str << instance_values.select{ |k,v| v == true }.map{ |k,v| k.gsub(/_(.)/){ $1.upcase } << %{="#{v}"} }.join(' ')
+      serialized_attributes str
       str << '/>'
     end
   end

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

@@ -4,6 +4,18 @@ module Axlsx
   # @see Worksheet#protect_range
   class ProtectedRange
 
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+   # 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={})
+      parse_options options
+      yield self if block_given?
+    end
+
+    serializable_attributes :sqref, :name
     # The reference for the protected range
     # @return [String]
     attr_reader :sqref
@@ -12,16 +24,6 @@ module Axlsx
     # @return [String]
     attr_reader :name
 
-    # 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={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-    
     # @see sqref
     def sqref=(v)
       Axlsx.validate_string(v)
@@ -33,14 +35,15 @@ module Axlsx
       Axlsx.validate_string(v)
       @name = v
     end
-   
+
     # serializes the proteted range
     # @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="")
-      attrs = self.instance_values.reject{ |key, value| value == nil }
-      str << '<protectedRange ' << attrs.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ') << '/>'
+      str << '<protectedRange '
+      serialized_attributes str
+      str << '/>'
     end 
   end
 end

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

@@ -5,59 +5,14 @@ module Axlsx
   # @see Worksheet#add_row
   class Row
 
+    include SerializedAttributes
+    include Accessors
     # No support is provided for the following attributes
     # spans
     # thickTop
     # thickBottom
 
-
-    # A list of serilizable attributes.
-    # @note height(ht) and customHeight are manages separately for now. Have a look at Row#height
-    SERIALIZABLE_ATTRIBUTES = [:hidden, :outlineLevel, :collapsed, :s, :customFormat, :ph]
-    
-    # The worksheet this row belongs to
-    # @return [Worksheet]
-    attr_reader :worksheet
-
-    # The cells this row holds
-    # @return [SimpleTypedList]
-    attr_reader :cells
-
-    # Row height measured in point size. There is no margin padding on row height.
-    # @return [Float]
-    attr_reader :height
-
-    # Flag indicating if the outlining of row.
-    # @return [Boolean]
-    attr_reader :collapsed
-
-    # Flag indicating if the the row is hidden.
-    # @return [Boolean]
-    attr_reader :hidden
-
-    # Outlining level of the row, when outlining is on
-    # @return [Integer]
-    attr_reader :outlineLevel
-
-    # The style applied ot the row. This affects the entire row.
-    # @return [Integer]
-    attr_reader :s
-
-    # indicates that a style has been applied directly to the row via Row#s
-    # @return [Boolean]
-    attr_reader :customFormat
-
-    # indicates if the row should show phonetic
-    # @return [Boolean]
-    attr_reader :ph
-
-    # NOTE removing this from the api as it is actually incorrect. 
-    # having a method to style a row's cells is fine, but it is not an attribute on the row. 
-    # The proper attribute is ':s'
-    # attr_reader style
-    #
-    
-    # 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
@@ -73,7 +28,7 @@ module Axlsx
     # @see Row#array_to_cells
     # @see Cell
     def initialize(worksheet, values=[], options={})
-      @height = nil
+      @ht = nil
       self.worksheet = worksheet
       @cells = SimpleTypedList.new Cell
       @worksheet.rows << self
@@ -81,29 +36,48 @@ module Axlsx
       array_to_cells(values, options)
     end
 
-    # @see Row#collapsed
-    def collapsed=(v)
-      Axlsx.validate_boolean(v)
-      @collapsed = v
-    end
+    # A list of serializable attributes.
+    serializable_attributes :hidden, :outline_level, :collapsed, :custom_format, :s, :ph, :custom_height, :ht
+
+    # Boolean row attribute accessors
+    boolean_attr_accessor :hidden, :collapsed, :custom_format, :ph, :custom_height
 
-    # @see Row#hidden
-    def hidden=(v)
-      Axlsx.validate_boolean(v)
-      @hidden = v
+    # The worksheet this row belongs to
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # The cells this row holds
+    # @return [SimpleTypedList]
+    attr_reader :cells
+
+    # Row height measured in point size. There is no margin padding on row height.
+    # @return [Float]
+    def height
+      @ht
     end
-   
-    # @see Row#ph
-    def ph=(v) Axlsx.validate_boolean(v); @ph = v end
+
+    # Outlining level of the row, when outlining is on
+    # @return [Integer]
+    attr_reader :outline_level
+    alias :outlineLevel :outline_level
+
+    # The style applied ot the row. This affects the entire row.
+    # @return [Integer]
+    attr_reader :s
 
     # @see Row#s
-    def s=(v) Axlsx.validate_unsigned_numeric(v); @s = v; @customFormat = true end
+    def s=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @custom_format = true 
+      @s = v
+    end
 
     # @see Row#outline
-    def outlineLevel=(v)
+    def outline_level=(v)
       Axlsx.validate_unsigned_numeric(v)
-      @outlineLevel = v
+      @outline_level = v
     end
+    alias :outlineLevel= :outline_level=
 
     # The index of this row in the worksheet
     # @return [Integer]
@@ -116,21 +90,14 @@ module Axlsx
     # @param [String] str The string this rows xml will be appended to.
     # @return [String]
     def to_xml_string(r_index, str = '')
-      str << '<row r="' << (r_index + 1 ).to_s << '" '
-      instance_values.select { |key, value| SERIALIZABLE_ATTRIBUTES.include? key.to_sym }.each do |key, value|
-        str << key << '="' << value.to_s << '" '
-      end
-      if custom_height?
-        str << 'customHeight="1" ht="' << height.to_s << '">'
-      else
-        str << '>'
-      end
+      str << '<row '
+      serialized_attributes(str, { :r => r_index + 1 })
+      str << '>'
       @cells.each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, str) }
       str << '</row>'
-      str
     end
 
-    # Adds a singel sell to the row based on the data provided and updates the worksheet's autofit data.
+    # Adds a single sell to the row based on the data provided and updates the worksheet's autofit data.
     # @return [Cell]
     def add_cell(value="", options={})
       c = Cell.new(self, value, options)
@@ -154,13 +121,13 @@ module Axlsx
     end
 
     # @see height
-    def height=(v); Axlsx::validate_unsigned_numeric(v) unless v.nil?; @height = v end
-
-    # true if the row height has been manually set
-    # @return [Boolean]
-    # @see #height
-    def custom_height?
-      @height != nil
+    def height=(v)
+      Axlsx::validate_unsigned_numeric(v)
+      unless v.nil?
+        @ht = v
+        @custom_height = true
+      end
+      @ht
     end
 
     private
@@ -180,15 +147,24 @@ module Axlsx
     def array_to_cells(values, options={})
       values = values
       DataTypeValidator.validate 'Row.array_to_cells', Array, values
-      types, style = options.delete(:types), options.delete(:style)
+      types, style, formula_values = options.delete(:types), options.delete(:style), options.delete(:formula_values)
       values.each_with_index do |value, index|
+
+        #WTF IS THIS PAP?
         cell_style = style.is_a?(Array) ? style[index] : style
         options[:style] = cell_style if cell_style
+
         cell_type = types.is_a?(Array)? types[index] : types
         options[:type] = cell_type if cell_type
+
+        formula_value = formula_values[index] if formula_values.is_a?(Array)
+        options[:formula_value] = formula_value if formula_value
+
         Cell.new(self, value, options)
+
         options.delete(:style)
         options.delete(:type)
+        options.delete(:formula_value)
       end
     end
   end