axlsx 1.2.0 → 2.0.0

data/lib/axlsx/util/validators.rb

@@ -14,6 +14,24 @@ module Axlsx
     end
   end
 
+  # Validate that the value provided is between a specific range
+  # Note that no data conversions will be done for you!
+  # Comparisons will be made using < and > or <= and <= when the inclusive parameter is true
+  class RangeValidator
+    # @param [String] name The name of what is being validated
+    # @param [Any] min The minimum allowed value
+    # @param [Any] max The maximum allowed value
+    # @param [Any] value The value to be validated
+    # @param [Boolean] inclusive Flag indicating if the comparison should be inclusive.
+    def self.validate(name, min, max, value, inclusive = true)
+      passes = if inclusive
+                 min <= value && value <= max
+               else
+                 min < value && value < max
+               end
+      raise ArgumentError, (ERR_RANGE % [value.inspect, min.to_s, max.to_s, inclusive]) unless passes
+    end
+  end
   # Validates the value against the regular expression provided.
   class RegexValidator
     # @param [String] name The name of what is being validated. This is included in the output when the value is invalid
@@ -23,6 +41,7 @@ module Axlsx
       raise ArgumentError, (ERR_REGEX % [v.inspect, regex.to_s]) unless (v.respond_to?(:to_s) && v.to_s.match(regex))
     end
   end
+
   # Validate that the class of the value provided is either an instance or the class of the allowed types and that any specified additional validation returns true.
   class DataTypeValidator
     # Perform validation
@@ -32,17 +51,18 @@ module Axlsx
     # @raise [ArugumentError] Raised if the class of the value provided is not in the specified array of types or the block passed returns false
     # @return [Boolean] true if validation succeeds.
     # @see validate_boolean
-    def self.validate(name, types, v, other= lambda{|arg| true })
+    def self.validate(name, types, v, other=false)
       types = [types] unless types.is_a? Array
-      valid_type = false
+      if other.is_a?(Proc)
+         raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless other.call(v)
+      end
       if v.class == Class
-        types.each { |t| valid_type = true if v.ancestors.include?(t) }
+        types.each { |t| return if v.ancestors.include?(t) }
       else
-        types.each { |t| valid_type = true if v.is_a?(t) }
+        types.each { |t| return if v.is_a?(t) }
       end
-      raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless (other.call(v) && valid_type)
+      raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect])
     end
-    true
   end
 
 
@@ -73,7 +93,7 @@ module Axlsx
   # @raise [ArgumentError] raised if the value is not a Fixnun, Integer, Float value greater or equal to 0
   # @return [Boolean] true if the data is valid
   def self.validate_unsigned_numeric(v)
-    DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
+    DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg.to_i >= 0 })
   end
 
   # Requires that the value is a Fixnum or Integer
@@ -112,7 +132,7 @@ module Axlsx
   def self.validate_scale_10_400(v)
     DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg >= 10 && arg <= 400 }
   end
-  
+
   # Requires that the value is an integer ranging from 10 to 400 or 0.
   def self.validate_scale_0_10_400(v)
     DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
@@ -122,14 +142,22 @@ module Axlsx
   def self.validate_page_orientation(v)
     RestrictionValidator.validate "page_orientation", [:default, :landscape, :portrait], v
   end
+  # Requires that the value is one of :none, :single, :double, :singleAccounting, :doubleAccounting
+  def self.validate_cell_u(v)
+    RestrictionValidator.validate "cell run style u", [:none, :single, :double, :singleAccounting, :doubleAccounting], v
+  end
 
+  # validates cell style family which must be between 1 and 5 
+  def self.validate_family(v)
+    RestrictionValidator.validate "cell run style family", 1..5, v
+  end
   # Requires that the value is valid pattern type.
   # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
   # :darkUp, :darkGrid, :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, or :gray0625.
   # @param [Any] v The value validated
   def self.validate_pattern_type(v)
     RestrictionValidator.validate :pattern_type, [:none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown, :darkUp, :darkGrid,
-       :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625], v
+                                                  :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625], v
   end
 
   # Requires that the value is one of the ST_TimePeriod types
@@ -203,14 +231,14 @@ module Axlsx
   # TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, DRAWING_CT, COMMENT_CT are allowed
   # @param [Any] v The value validated
   def self.validate_content_type(v)
-    RestrictionValidator.validate :content_type, [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, JPEG_CT, GIF_CT, PNG_CT, DRAWING_CT, COMMENT_CT, VML_DRAWING_CT], v
+    RestrictionValidator.validate :content_type, [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, JPEG_CT, GIF_CT, PNG_CT, DRAWING_CT, COMMENT_CT, VML_DRAWING_CT, PIVOT_TABLE_CT, PIVOT_TABLE_CACHE_DEFINITION_CT], v
   end
 
   # Requires that the value is a valid relationship_type
   # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R are allowed
   # @param [Any] v The value validated
   def self.validate_relationship_type(v)
-    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R, COMMENT_R, VML_DRAWING_R, COMMENT_R_NULL], v
+    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R, COMMENT_R, VML_DRAWING_R, COMMENT_R_NULL, PIVOT_TABLE_R, PIVOT_TABLE_CACHE_DEFINITION_R], v
   end
 
   # Requires that the value is a valid table element type
@@ -226,7 +254,7 @@ module Axlsx
   def self.validate_data_validation_error_style(v)
     RestrictionValidator.validate :validate_data_validation_error_style, [:information, :stop, :warning], v
   end
-  
+
   # Requires that the value is valid data validation operator.
   # valid operators must be one of lessThan, lessThanOrEqual, equal,
   # notEqual, greaterThanOrEqual, greaterThan, between, notBetween
@@ -234,32 +262,39 @@ module Axlsx
   def self.validate_data_validation_operator(v)
     RestrictionValidator.validate :data_validation_operator, [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween], v
   end
-  
+
   # Requires that the value is valid data validation type.
   # valid types must be one of custom, data, decimal, list, none, textLength, time, whole
   # @param [Any] v The value validated
   def self.validate_data_validation_type(v)
     RestrictionValidator.validate :data_validation_type, [:custom, :data, :decimal, :list, :none, :textLength, :time, :whole], v
   end
-  
+
   # Requires that the value is a valid sheet view type.
   # valid types must be one of normal, page_break_preview, page_layout
   # @param [Any] v The value validated
   def self.validate_sheet_view_type(v)
     RestrictionValidator.validate :sheet_view_type, [:normal, :page_break_preview, :page_layout], v
   end
-  
+
   # Requires that the value is a valid active pane type.
   # valid types must be one of bottom_left, bottom_right, top_left, top_right
   # @param [Any] v The value validated
   def self.validate_pane_type(v)
     RestrictionValidator.validate :active_pane_type, [:bottom_left, :bottom_right, :top_left, :top_right], v
   end
-  
+
   # Requires that the value is a valid split state type.
   # valid types must be one of frozen, frozen_split, split
   # @param [Any] v The value validated
   def self.validate_split_state_type(v)
     RestrictionValidator.validate :split_state_type, [:frozen, :frozen_split, :split], v
   end
+
+  # Requires that the value is a valid "display blanks as" type.
+  # valid types must be one of gap, span, zero
+  # @param [Any] v The value validated
+  def self.validate_display_blanks_as(v)
+    RestrictionValidator.validate :display_blanks_as, [:gap, :span, :zero], v
+  end
 end

data/lib/axlsx/version.rb

@@ -1,5 +1,5 @@
-# encoding: UTF-8
 module Axlsx
+
   # The current version
-  VERSION="1.2.0"
+  VERSION = "2.0.0"
 end

data/lib/axlsx/workbook/defined_name.rb

@@ -49,12 +49,15 @@ module Axlsx
   # @example
   #     For clarification: LOG10 is always a cell reference, LOG10() is always formula, LOGO1000 can be a defined name that overrides a cell reference.
   class DefinedName
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
     # creates a new DefinedName.
     # @param [String] formula - the formula the defined name references
     # @param [Hash] options - A hash of key/value pairs that will be mapped to this instances attributes.
-    # 
+    #
     # @option [String] name - Specifies the name that appears in the user interface for the defined name.
-    #                         This attribute is required. 
+    #                         This attribute is required.
     #                         The following built-in names are defined in this SpreadsheetML specification:
     #                         Print
     #                           _xlnm.Print_Area: this defined name specifies the workbook's print area.
@@ -96,77 +99,29 @@ module Axlsx
     #                                        version of the workbook that is published to or rendered on a Web or application server.
     def initialize(formula, options={})
       @formula = formula
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
+      parse_options options
     end
+
     attr_reader :local_sheet_id
 
     # The local sheet index (0-based)
-    # @param [Integer] value the unsinged integer index of the sheet this defined_name applies to.
+    # @param [Integer] value the unsigned integer index of the sheet this defined_name applies to.
     def local_sheet_id=(value)
       Axlsx::validate_unsigned_int(value)
       @local_sheet_id = value
     end
 
-    # string attributes that will be added when this class is evaluated
-    STRING_ATTRIBUTES = [:short_cut_key, :status_bar, :help, :description, :custom_menu, :comment]
-
-    # boolean attributes that will be added when this class is evaluated
-    BOOLEAN_ATTRIBUTES = [:workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden] 
-
-    # Dynamically create string attribute accessors
-    STRING_ATTRIBUTES.each do |attr|
-      class_eval %{
-        # The #{attr} attribute reader
-        # @return [String]
-        attr_reader :#{attr}
-
-        # The #{attr} writer
-        # @param [String] value The value to assign to #{attr}
-        # @return [String]
-        def #{attr}=(value)
-          Axlsx::validate_string(value)
-          @#{attr}= value
-        end
-      }
-    end
-
-    # Dynamically create boolean attribute accessors
-    BOOLEAN_ATTRIBUTES.each do |attr|
-      class_eval %{
-      # The #{attr} attribute reader
-      # @return [Boolean]
-      attr_reader :#{attr}
+    string_attr_accessor :short_cut_key, :status_bar, :help, :description, :custom_menu, :comment, :name, :formula
 
-      # The #{attr} writer
-      # @param [Boolean] value The value to assign to #{attr}
-      # @return [Boolean]
-      def #{attr}=(value)
-        Axlsx::validate_boolean(value)
-        @#{attr} = value
-      end
-      }
-    end
-   
-    attr_reader :name
-    # The name of this defined name. Please refer to the class documentation for more information
-    def name=(value)
-      Axlsx::RestrictionValidator.validate 'DefinedName.name', %w(_xlnm.Print_Area _xlnm.Print_Titles _xlnm.Criteria _xlnm._FilterDatabase _xlnm.Extract _xlnm.Consolidate_Area _xlnm.Database _xlnm.Sheet_Title), value
-      @name = value
-    end
+    boolean_attr_accessor :workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden
 
-    # The formula this defined name references
-    attr_reader :formula
+    serializable_attributes :short_cut_key, :status_bar, :help, :description, :custom_menu, :comment,
+      :workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden, :name, :local_sheet_id
 
     def to_xml_string(str='')
       raise ArgumentError, 'you must specify the name for this defined name. Please read the documentation for Axlsx::DefinedName for more details' unless name 
-      str << '<definedName'
-      instance_values.each do |name, value| 
-        unless name == 'formula'
-          str << ' ' << Axlsx::camel(name, false) << "='#{value}'"
-        end
-      end
+      str << '<definedName '
+      serialized_attributes str
       str << '>' << @formula
       str << '</definedName>'
     end

data/lib/axlsx/workbook/shared_strings_table.rb

@@ -26,10 +26,16 @@ module Axlsx
     # @see Cell#sharable
     attr_reader :unique_cells
 
+    # The xml:space attribute
+    # @see Workbook#xml_space
+    attr_reader :xml_space
+
     # Creates a new Shared Strings Table agains an array of cells
     # @param [Array] cells This is an array of all of the cells in the workbook
-    def initialize(cells)
+    # @param [Symbol] xml_space The xml:space behavior for the shared string table.
+    def initialize(cells, xml_space=:preserve)
       @index = 0
+      @xml_space = xml_space
       @unique_cells = {}
       @shared_xml_string = ""
       shareable_cells = cells.flatten.select{ |cell| cell.plain_string? }
@@ -40,8 +46,11 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string
-      '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '" count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '">' << @shared_xml_string << '</sst>'
+    def to_xml_string(str='')
+      str << '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '"'
+      str << ' count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '"'
+      str << ' xml:space="' << xml_space.to_s << '">' << @shared_xml_string << '</sst>'
+      str = Axlsx::sanitize(str)
     end
 
     private
@@ -58,7 +67,7 @@ module Axlsx
           cell.send :ssti=, index
         else
           cell.send :ssti=, @index
-          @shared_xml_string << '<si>' << cell.run_xml_string << '</si>'
+          @shared_xml_string << '<si>' << CellSerializer.run_xml_string(cell) << '</si>'
           @unique_cells[cell_hash] = @index
           @index += 1
         end

data/lib/axlsx/workbook/workbook.rb

@@ -1,14 +1,19 @@
 # -*- coding: utf-8 -*-
 module Axlsx
-require 'axlsx/workbook/worksheet/auto_filter.rb'
+require 'axlsx/workbook/worksheet/sheet_calc_pr.rb'
+require 'axlsx/workbook/worksheet/auto_filter/auto_filter.rb'
 require 'axlsx/workbook/worksheet/date_time_converter.rb'
 require 'axlsx/workbook/worksheet/protected_range.rb'
 require 'axlsx/workbook/worksheet/protected_ranges.rb'
+require 'axlsx/workbook/worksheet/cell_serializer.rb'
 require 'axlsx/workbook/worksheet/cell.rb'
 require 'axlsx/workbook/worksheet/page_margins.rb'
+require 'axlsx/workbook/worksheet/page_set_up_pr.rb'
 require 'axlsx/workbook/worksheet/page_setup.rb'
+require 'axlsx/workbook/worksheet/header_footer.rb'
 require 'axlsx/workbook/worksheet/print_options.rb'
 require 'axlsx/workbook/worksheet/cfvo.rb'
+require 'axlsx/workbook/worksheet/cfvos.rb'
 require 'axlsx/workbook/worksheet/color_scale.rb'
 require 'axlsx/workbook/worksheet/data_bar.rb'
 require 'axlsx/workbook/worksheet/icon_set.rb'
@@ -27,15 +32,28 @@ require 'axlsx/workbook/worksheet/dimension.rb'
 require 'axlsx/workbook/worksheet/sheet_data.rb'
 require 'axlsx/workbook/worksheet/worksheet_drawing.rb'
 require 'axlsx/workbook/worksheet/worksheet_comments.rb'
+require 'axlsx/workbook/worksheet/worksheet_hyperlink'
+require 'axlsx/workbook/worksheet/worksheet_hyperlinks'
+require 'axlsx/workbook/worksheet/break'
+require 'axlsx/workbook/worksheet/row_breaks'
+require 'axlsx/workbook/worksheet/col_breaks'
+
+
+
 require 'axlsx/workbook/worksheet/worksheet.rb'
 require 'axlsx/workbook/shared_strings_table.rb'
 require 'axlsx/workbook/defined_name.rb'
 require 'axlsx/workbook/defined_names.rb'
+require 'axlsx/workbook/worksheet/table_style_info.rb'
 require 'axlsx/workbook/worksheet/table.rb'
 require 'axlsx/workbook/worksheet/tables.rb'
+require 'axlsx/workbook/worksheet/pivot_table_cache_definition.rb'
+require 'axlsx/workbook/worksheet/pivot_table.rb'
+require 'axlsx/workbook/worksheet/pivot_tables.rb'
 require 'axlsx/workbook/worksheet/data_validation.rb'
 require 'axlsx/workbook/worksheet/data_validations.rb'
 require 'axlsx/workbook/worksheet/sheet_view.rb'
+require 'axlsx/workbook/worksheet/sheet_format_pr.rb'
 require 'axlsx/workbook/worksheet/pane.rb'
 require 'axlsx/workbook/worksheet/selection.rb'
   # The Workbook class is an xlsx workbook that manages worksheets, charts, drawings and styles.
@@ -114,10 +132,17 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # @return [SimpleTypedList]
     attr_reader :tables
 
+    # A colllection of pivot tables associated with this workbook
+    # @note The recommended way to manage drawings is Worksheet#add_table
+    # @see Worksheet#add_table
+    # @see Table
+    # @return [SimpleTypedList]
+    attr_reader :pivot_tables
+
 
     # A collection of defined names for this workbook
     # @note The recommended way to manage defined names is Workbook#add_defined_name
-    # @see DefinedName 
+    # @see DefinedName
     # @return [DefinedNames]
     def defined_names
       @defined_names ||= DefinedNames.new
@@ -147,6 +172,14 @@ require 'axlsx/workbook/worksheet/selection.rb'
     @@date1904 = false
 
 
+    # A quick helper to retrive a worksheet by name
+    # @param [String] name The name of the sheet you are looking for
+    # @return [Worksheet] The sheet found, or nil
+    def sheet_by_name(name)
+      index = @worksheets.index { |sheet| sheet.name == name }
+      @worksheets[index] if index
+    end
+
     # lets come back to this later when we are ready for parsing.
     #def self.parse entry
     #  io = entry.get_input_stream
@@ -167,6 +200,7 @@ require 'axlsx/workbook/worksheet/selection.rb'
       @images = SimpleTypedList.new Pic
       # Are these even used????? Check package serialization parts
       @tables = SimpleTypedList.new Table
+      @pivot_tables = SimpleTypedList.new PivotTable
       @comments = SimpleTypedList.new Comments
 
 
@@ -201,6 +235,23 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # see @use_autowidth
     def use_autowidth=(v=true) Axlsx::validate_boolean v; @use_autowidth = v; end
 
+    # inserts a worksheet into this workbook at the position specified.
+    # It the index specified is out of range, the worksheet will be added to the end of the
+    # worksheets collection
+    # @return [Worksheet]
+    # @param index The zero based position to insert the newly created worksheet
+    # @param [Hash] options Options to pass into the worksheed during initialization.
+    # @option options [String] name The name of the worksheet
+    # @option options [Hash] page_margins The page margins for the worksheet
+    def insert_worksheet(index=0, options={})
+      worksheet = Worksheet.new(self, options)
+      @worksheets.delete_at(@worksheets.size - 1)
+      @worksheets.insert(index, worksheet)
+      yield worksheet if block_given?
+      worksheet
+    end
+
+    #
     # Adds a worksheet to this workbook
     # @return [Worksheet]
     # @option options [String] name The name of the worksheet.
@@ -225,11 +276,14 @@ require 'axlsx/workbook/worksheet/selection.rb'
     def relationships
       r = Relationships.new
       @worksheets.each do |sheet|
-        r << Relationship.new(WORKSHEET_R, WORKSHEET_PN % (r.size+1))
+        r << Relationship.new(sheet, WORKSHEET_R, WORKSHEET_PN % (r.size+1))
+      end
+      pivot_tables.each_with_index do |pivot_table, index|
+        r << Relationship.new(pivot_table.cache_definition, PIVOT_TABLE_CACHE_DEFINITION_R, PIVOT_TABLE_CACHE_DEFINITION_PN % (index+1))
       end
-      r << Relationship.new(STYLES_R,  STYLES_PN)
+      r << Relationship.new(self, STYLES_R,  STYLES_PN)
       if use_shared_strings
-          r << Relationship.new(SHARED_STRINGS_R,  SHARED_STRINGS_PN)
+          r << Relationship.new(self, SHARED_STRINGS_R,  SHARED_STRINGS_PN)
       end
       r
     end
@@ -237,7 +291,25 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # generates a shared string object against all cells in all worksheets.
     # @return [SharedStringTable]
     def shared_strings
-      SharedStringsTable.new(worksheets.collect { |ws| ws.cells })
+      SharedStringsTable.new(worksheets.collect { |ws| ws.cells }, xml_space)
+    end
+
+    # The xml:space attribute for the worksheet.
+    # This determines how whitespace is handled withing the document.
+    # The most relevant part being whitespace in the cell text.
+    # allowed values are :preserve and :default. Axlsx uses :preserve unless
+    # you explicily set this to :default.
+    # @return Symbol
+    def xml_space
+      @xml_space ||= :preserve
+    end
+
+    # Sets the xml:space attribute for the worksheet
+    # @see Worksheet#xml_space
+    # @param [Symbol] space must be one of :preserve or :default
+    def xml_space=(space)
+      Axlsx::RestrictionValidator.validate(:xml_space, [:preserve, :default], space)
+      @xml_space = space;
     end
 
     # returns a range of cells in a worksheet
@@ -268,6 +340,13 @@ require 'axlsx/workbook/worksheet/selection.rb'
       end
       str << '</sheets>'
       defined_names.to_xml_string(str)
+      unless pivot_tables.empty?
+        str << '<pivotCaches>'
+        pivot_tables.each do |pivot_table|
+          str << '<pivotCache cacheId="' << pivot_table.cache_definition.cache_id.to_s << '" r:id="' << pivot_table.cache_definition.rId << '"/>'
+        end
+        str << '</pivotCaches>'
+      end
       str << '</workbook>'
     end
 

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

@@ -0,0 +1,77 @@
+
+require 'axlsx/workbook/worksheet/auto_filter/filter_column.rb'
+require 'axlsx/workbook/worksheet/auto_filter/filters.rb'
+
+module Axlsx
+
+  #This class represents an auto filter range in a worksheet
+  class AutoFilter
+
+    # creates a new Autofilter object
+    # @param [Worksheet] worksheet
+    def initialize(worksheet)
+      raise ArgumentError, 'you must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+
+    attr_reader :worksheet
+
+    # The range the autofilter should be applied to.
+    # This should be a string like 'A1:B8'
+    # @return [String]
+    attr_accessor :range
+
+    # the formula for the defined name required for this auto filter
+    # This prepends the worksheet name to the absolute cell reference
+    # e.g. A1:B2 -> 'Sheet1'!$A$1:$B$2
+    # @return [String]
+    def defined_name
+      return unless range
+      Axlsx.cell_range(range.split(':').collect { |name| worksheet.name_to_cell(name)})
+    end
+
+    # A collection of filterColumns for this auto_filter
+    # @return [SimpleTypedList]
+    def columns
+      @columns ||= SimpleTypedList.new FilterColumn
+    end
+
+    # Adds a filter column. This is the recommended way to create and manage filter columns for your autofilter.
+    # In addition to the require id and type parameters, options will be passed to the filter column during instantiation.
+    # @param [String] col_id Zero-based index indicating the AutoFilter column to which this filter information applies.
+    # @param [Symbol] filter_type A symbol representing one of the supported filter types.
+    # @param [Hash] options a hash of options to pass into the generated filter
+    # @return [FilterColumn]
+    def add_column(col_id, filter_type, options = {})
+      columns << FilterColumn.new(col_id, filter_type, options)
+      columns.last
+    end
+
+    # actually performs the filtering of rows who's cells do not 
+    # match the filter.  
+    def apply
+      first_cell, last_cell = range.split(':')
+      start_point = Axlsx::name_to_indices(first_cell)
+      end_point = Axlsx::name_to_indices(last_cell)
+      # The +1 is so we skip the header row with the filter drop downs
+      rows = worksheet.rows[(start_point.last+1)..end_point.last] || []
+
+      column_offset = start_point.first
+      columns.each do |column|
+        rows.each do |row|
+          next if row.hidden
+          column.apply(row, column_offset)
+        end
+      end
+    end
+    # serialize the object
+    # @return [String]
+    def to_xml_string(str='')
+      return unless range
+      str << "<autoFilter ref='#{range}'>"
+      columns.each { |filter_column| filter_column.to_xml_string(str) }
+      str << "</autoFilter>"
+    end
+
+  end
+end

data/lib/axlsx/workbook/worksheet/auto_filter/filter_column.rb

@@ -0,0 +1,94 @@
+module Axlsx
+  # The filterColumn collection identifies a particular column in the AutoFilter
+  # range and specifies filter information that has been applied to this column.
+  # If a column in the AutoFilter range has no criteria specified,
+  # then there is no corresponding filterColumn collection expressed for that column.
+  class FilterColumn
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    # Creates a new FilterColumn object
+    # @note This class yeilds its filter object as that is where the vast majority of processing will be done
+    # @param [Integer|Cell] col_id The zero based index for the column to which this filter will be applied
+    # @param [Symbol] filter_type The symbolized class name of the filter to apply to this column.
+    # @param [Hash] options options for this object and the filter
+    # @option [Boolean] hidden_button @see hidden_button
+    # @option [Boolean] show_button @see show_button
+    def initialize(col_id, filter_type, options = {})
+      RestrictionValidator.validate 'FilterColumn.filter', FILTERS, filter_type
+      #Axlsx::validate_unsigned_int(col_id)
+      self.col_id = col_id
+      parse_options options
+      @filter = Axlsx.const_get(Axlsx.camel(filter_type)).new(options)
+      yield @filter if block_given?
+    end
+
+    serializable_attributes :col_id, :hidden_button, :show_button
+
+    # Allowed filters
+    FILTERS =  [:filters] #, :top10, :custom_filters, :dynamic_filters, :color_filters, :icon_filters]
+
+    # Zero-based index indicating the AutoFilter column to which this filter information applies.
+    # @return [Integer]
+    attr_reader :col_id
+
+    # The actual filter being dealt with here
+    # This could be any one of the allowed filter types
+    attr_reader :filter
+
+    # Flag indicating whether the filter button is visible.
+    # When the cell containing the filter button is merged with another cell,
+    # the filter button can be hidden, and not drawn.
+    # @return [Boolean]
+    def show_button
+      @show_button ||= true
+    end
+
+    # Flag indicating whether the AutoFilter button for this column is hidden.
+    # @return [Boolean]
+    def hidden_button
+      @hidden_button ||= false
+    end
+
+    # Sets the col_id attribute for this filter column.
+    # @param [Integer | Cell] column_index The zero based index of the column to which this filter applies. 
+    #                         When you specify a cell, the column index will be read off the cell
+    # @return [Integer]
+    def col_id=(column_index)
+      column_index = column_index.col if column_index.is_a?(Cell)
+      Axlsx.validate_unsigned_int column_index
+      @col_id = column_index
+    end
+
+    # Apply the filters for this column
+    # @param [Array] row A row from a worksheet that needs to be
+    # filtered.
+    def apply(row, offset)
+      row.hidden = @filter.apply(row.cells[offset+col_id.to_i])
+    end
+    # @param [Boolean] hidden Flag indicating whether the AutoFilter button for this column is hidden.
+    # @return [Boolean]
+    def hidden_button=(hidden)
+      Axlsx.validate_boolean hidden
+      @hidden_button = hidden
+    end
+
+    # Flag indicating whether the AutoFilter button is show. This is
+    # undocumented in the spec, but exists in the schema file as an
+    # optional attribute.
+    # @param [Boolean] show Show or hide the button
+    # @return [Boolean]
+    def show_button=(show)
+      Axlsx.validate_boolean show
+      @show_botton = show
+    end
+
+    # Serialize the object to xml
+    def to_xml_string(str='')
+      str << "<filterColumn #{serialized_attributes}>"
+      @filter.to_xml_string(str)
+      str << "</filterColumn>"
+    end
+  end
+end