axlsx 1.2.1 → 1.3.1

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

@@ -28,6 +28,7 @@ module Axlsx
       @sheet = sheet
       @style = nil
       @sheet.workbook.tables << self
+      @table_style_info = TableStyleInfo.new(options[:style_info]) if options[:style_info]
       @name = "Table#{index+1}"
       options.each do |o|
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
@@ -62,6 +63,12 @@ module Axlsx
         @name = v
       end
     end
+    
+    # TableStyleInfo for the table. 
+    # initialization can be fed via the :style_info option
+    def table_style_info
+      @table_style_info ||= TableStyleInfo.new
+    end
 
     # Serializes the object
     # @param [String] str
@@ -77,7 +84,7 @@ module Axlsx
       end
       str << '</tableColumns>'
       #TODO implement tableStyleInfo
-      str << '<tableStyleInfo showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0" name="TableStyleMedium9" />'
+      table_style_info.to_xml_string(str) # '<tableStyleInfo showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0" name="TableStyleMedium9" />'
       str << '</table>'
     end
 

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

@@ -0,0 +1,68 @@
+module Axlsx
+
+  # The table style info class manages style attributes for defined tables in
+  # a worksheet
+  class TableStyleInfo
+
+    # boolean attributes for this object
+    BOOLEAN_ATTRIBUTES = %w(show_first_column show_last_column show_row_stripes show_column_stripes)
+
+    # creates a new TableStyleInfo instance
+    # @param [Hash] options
+    # @option [Boolean] show_first_column indicates if the first column should
+    #                   be shown
+    # @option [Boolean] show_last_column indicates if the last column should
+    #                   be shown
+    # @option [Boolean] show_column_stripes indicates if column stripes should
+    #                   be shown
+    # @option [Boolean] show_row_stripes indicates if row stripes should be shown
+    # @option [String] name The name of the style to apply to your table. 
+    #                  Only predefined styles are currently supported.
+    #                  @see Annex G. (normative) Predefined SpreadsheetML Style Definitions in part 1 of the specification.
+    def initialize(options = {})
+      initialize_defaults
+      @name = 'TableStyleMedium9'
+      options.each do |k, v|
+        send("#{k}=", v) if respond_to? "#{k}="
+      end
+    end
+
+    # Dynamically create accessors for boolean attriubtes
+    BOOLEAN_ATTRIBUTES.each do |attr|
+      class_eval %{
+      # The #{attr} attribute reader
+      # @return [Boolean]
+      attr_reader :#{attr} 
+
+      # 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
+
+    # Initialize all the values to false as Excel requires them to
+    # explicitly be disabled or all will show.
+    def initialize_defaults
+      BOOLEAN_ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", 0)
+      end
+    end
+
+    # The name of the table style.
+    attr_accessor :name
+
+    # seralizes this object to an xml string
+    # @param [String] str the string to contact this objects serialization to.
+    def to_xml_string(str = '')
+      str << '<tableStyleInfo '
+      instance_values.each do |key, value|
+        str << Axlsx::camel(key, false) << "='#{value}' "
+      end
+      str << '/>'
+    end
+  end
+end

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

@@ -42,6 +42,12 @@ module Axlsx
     def name
       @name ||=  "Sheet" + (index+1).to_s
     end
+ 
+    # The sheet calculation properties
+    # @return [SheetCalcPr]
+    def sheet_calc_pr
+      @sheet_calc_pr ||= SheetCalcPr.new
+    end
 
     # The sheet protection object for this workbook
     # @return [SheetProtection]
@@ -491,15 +497,24 @@ module Axlsx
     # This intentionally does not use nokogiri for performance reasons
     # @return [String]
     def to_xml_string
+      auto_filter.apply if auto_filter.range
       str = '<?xml version="1.0" encoding="UTF-8"?>'
       str << worksheet_node
       serializable_parts.each do |item|
         item.to_xml_string(str) if item
       end
       str << '</worksheet>'
-      str.gsub(/[[:cntrl:]]/,'')
+      sanitize(str)
     end
 
+    # returns the provided string with all invalid control charaters
+    # removed.
+    # @param [String] str The sting to process
+    # @return [String]
+    def sanitize(str)
+      str.gsub(CONTROL_CHAR_REGEX, '')
+    end
+    
     # The worksheet relationships. This is managed automatically by the worksheet
     # @return [Relationships]
     def relationships
@@ -556,7 +571,7 @@ module Axlsx
 
 
     private
-
+   
     def validate_sheet_name(name)
       DataTypeValidator.validate "Worksheet.name", String, name
       raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % name) if name.size > 31
@@ -569,7 +584,7 @@ module Axlsx
 
     def serializable_parts
       [sheet_pr, dimension, sheet_view, column_info,
-       sheet_data, @sheet_protection, protected_ranges,
+       sheet_data, sheet_calc_pr, @sheet_protection, protected_ranges,
        auto_filter, merged_cells, conditional_formattings,
        data_validations, hyperlinks, print_options, page_margins,
        page_setup, worksheet_drawing, worksheet_comments,

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

@@ -1,4 +1,5 @@
 module Axlsx
+
   #A collection of hyperlink objects for a worksheet
   class WorksheetHyperlinks < SimpleTypedList
 
@@ -18,6 +19,8 @@ module Axlsx
       @list.last
     end
 
+    # The relationships required by this collection's hyperlinks
+    # @return Array
     def relationships
       return [] if empty?
       map { |hyperlink| hyperlink.relationship }

data/lib/axlsx.rb

@@ -37,7 +37,12 @@ if !Object.respond_to?(:instance_values)
   end
 end
 
-# xlsx generation with charts, images, automated column width, customizable styles and full schema validation. Axlsx excels at helping you generate beautiful Office Open XML Spreadsheet documents without having to understand the entire ECMA specification. Check out the README for some examples of how easy it is. Best of all, you can validate your xlsx file before serialization so you know for sure that anything generated is going to load on your client's machine.
+# xlsx generation with charts, images, automated column width, customizable styles
+# and full schema validation. Axlsx excels at helping you generate beautiful
+# Office Open XML Spreadsheet documents without having to understand the entire
+# ECMA specification. Check out the README for some examples of how easy it is.
+# Best of all, you can validate your xlsx file before serialization so you know
+# for sure that anything generated is going to load on your client's machine.
 module Axlsx
 
   # determines the cell range for the items provided
@@ -65,6 +70,7 @@ module Axlsx
   # returns the x, y position of a cell
   def self.name_to_indices(name)
     raise ArgumentError, 'invalid cell name' unless name.size > 1
+    # capitalization?!?
     v = name[/[A-Z]+/].reverse.chars.reduce({:base=>1, :i=>0}) do  |val, c|
       val[:i] += ((c.bytes.first - 64) * val[:base]); val[:base] *= 26; val
     end
@@ -95,6 +101,7 @@ module Axlsx
   # @param [String] s The snake case string to camelize
   # @return [String]
   def self.camel(s="", all_caps = true)
+    s = s.to_s
     s = s.capitalize if all_caps
     s.gsub(/_(.)/){ $1.upcase }
   end

data/test/stylesheet/tc_styles.rb

@@ -105,6 +105,19 @@ class TestStyles < Test::Unit::TestCase
     assert(@styles.parse_alignment_options(:alignment => {}).is_a?(Axlsx::CellAlignment))
   end
 
+  def test_parse_font_using_defaults
+    original = @styles.fonts.first
+    @styles.add_style :b => 1, :sz => 99
+    created = @styles.fonts.last
+    original_attributes = original.instance_values
+    assert_equal(1, created.b)
+    assert_equal(99, created.sz)
+    copied = original_attributes.reject{ |key, value| %w(b sz).include? key }
+    copied.each do |key, value|
+      assert_equal(created.instance_values[key], value)
+    end
+  end
+
   def test_parse_font_options
     options = {
       :fg_color => "FF050505",

data/test/util/tc_validators.rb

@@ -158,4 +158,11 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 'frozen_split' }
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 0 }
   end
-end
+
+  def test_range_validation
+     # exclusive
+     assert_raise(ArgumentError) { Axlsx::RangeValidator.validate('foo', 1, 10, 10, false) } 
+     # inclusive by default
+     assert_nothing_raised { Axlsx::RangeValidator.validate('foo', 1, 10, 10) }
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_auto_filter.rb

@@ -0,0 +1,38 @@
+require 'tc_helper.rb'
+
+class TestAutoFilter < Test::Unit::TestCase
+
+  def setup
+    ws = Axlsx::Package.new.workbook.add_worksheet
+    3.times { |index| ws.add_row [1*index,2*index,3*index] }
+    @auto_filter = ws.auto_filter
+    @auto_filter.range = 'A1:C3'
+    @auto_filter.add_column 0, :filters, :filter_items => [1]
+  end
+
+  def test_defined_name
+    assert_equal("'Sheet1'!$A$1:$C$3", @auto_filter.defined_name)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@auto_filter.to_xml_string)
+    assert(doc.xpath("autoFilter[@ref='#{@auto_filter.range}']"))
+  end
+
+  def test_columns
+    assert @auto_filter.columns.is_a?(Axlsx::SimpleTypedList)
+    assert_equal @auto_filter.columns.allowed_types, [Axlsx::FilterColumn]
+  end
+
+  def test_add_column
+    @auto_filter.add_column(0, :filters) do |column|
+      assert column.is_a? FilterColumn
+    end
+  end
+
+  def test_applya
+    assert_equal nil, @auto_filter.worksheet.rows.last.hidden
+    @auto_filter.apply
+    assert_equal true, @auto_filter.worksheet.rows.last.hidden
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filter_column.rb

@@ -0,0 +1,76 @@
+require 'tc_helper.rb'
+
+class TestFilterColumn < Test::Unit::TestCase
+
+  def setup
+    @filter_column = Axlsx::FilterColumn.new(0, :filters, :filter_items => [200])
+  end
+
+
+  def test_initialize_col_id
+    assert_raise ArgumentError do
+      Axlsx::FilterColumn.new(0, :bobs_house_of_filter)
+    end 
+    assert_raise ArgumentError do 
+      Axlsx::FilterColumn.new(:penut, :filters)
+    end 
+  end
+
+  def test_initailize_filter_type
+    assert @filter_column.filter.is_a?(Axlsx::Filters)
+    assert_equal 1, @filter_column.filter.filter_items.size
+  end
+
+  def test_initialize_filter_type_filters_with_options
+    assert_equal 200, @filter_column.filter.filter_items.first.val
+  end
+
+  def test_initialize_with_block
+    filter_column = Axlsx::FilterColumn.new(0, :filters) do |filters|
+      filters.filter_items = [700, 100, 5]
+    end
+    assert_equal 3, filter_column.filter.filter_items.size
+    assert_equal 700, filter_column.filter.filter_items.first.val
+    assert_equal 5, filter_column.filter.filter_items.last.val
+  end
+
+  def test_default_show_button
+    assert_equal true, @filter_column.show_button
+  end
+
+  def test_default_hidden_button
+    assert_equal false, @filter_column.hidden_button
+  end
+
+  def test_show_button
+    assert_raise ArgumentError do
+      @filter_column.show_button = :foo 
+    end
+    assert_nothing_raised { @filter_column.show_button = false }
+  end
+
+  def test_hidden_button
+    assert_raise ArgumentError do
+      @filter_column.hidden_button = :hoge
+    end 
+    assert_nothing_raised { @filter_column.hidden_button = true }
+  end
+
+  def test_col_id=
+    assert_raise ArgumentError do 
+    @filter_column.col_id = :bar
+    end 
+  assert_nothing_raised { @filter_column.col_id = 7 }
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filter_column.to_xml_string)
+    assert doc.xpath("//filterColumn[@colId=#{@filter_column.col_id}]")
+    assert doc.xpath("//filterColumn[@hiddenButton=#{@filter_column.hidden_button}]")
+    assert doc.xpath("//filterColumn[@showButton=#{@filter_column.show_button}]")
+
+
+
+    assert doc.xpath("//filterColumn/filters")
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filters.rb

@@ -0,0 +1,50 @@
+require 'tc_helper.rb'
+
+class TestFilters < Test::Unit::TestCase
+  def setup
+    @filters = Axlsx::Filters.new(:filter_items => [1, 'a'], 
+                                  :date_group_items =>[ { :date_time_grouping => :year, :year => 2011, :month => 11, :day => 11, :hour => 0, :minute => 0, :second => 0 } ] , 
+                                  :blank => true)
+  end
+
+  def test_blank
+    assert_equal true, @filters.blank
+    assert_raise(ArgumentError) { @filters.blank = :only_if_you_want_it }
+    @filters.blank = true
+    assert_equal true, @filters.blank
+  end
+
+  def test_calendar_type
+    assert_raise(ArgumentError) { @filters.calendar_type = 'monkey calendar' }
+    @filters.calendar_type = 'japan'
+    assert_equal('japan', @filters.calendar_type)
+  end
+
+  def test_filters_items
+    assert @filters.filter_items.is_a?(Array)
+    assert_equal 2, @filters.filter_items.size
+  end
+
+  def test_date_group_items
+    assert @filters.date_group_items.is_a?(Array)
+    assert_equal 1, @filters.date_group_items.size
+  end
+ 
+  def test_apply_is_false_for_matching_values
+    keeper = Object.new
+    def keeper.value; 'a'; end 
+    assert_equal false, @filters.apply(keeper)
+  end
+
+  def test_apply_is_true_for_non_matching_values
+    hidden = Object.new 
+    def hidden.value; 'b'; end
+    assert_equal true, @filters.apply(hidden)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filters.to_xml_string)
+    assert_equal(1, doc.xpath('//filters[@blank="true"]').size)
+  end
+end
+

data/test/workbook/worksheet/tc_cell.rb

@@ -60,7 +60,7 @@ class TestCell < Test::Unit::TestCase
     assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
     assert_nothing_raised("type can be changed") { @c.type = :string }
     assert_equal(@c.value, "1.0", "changing type casts the value")
-
+    assert_equal(:float, @row.add_cell(1.0/10**7).type, 'properly identify exponential floats as float type')
     assert_equal(@row.add_cell(Time.now).type, :time, 'time should be time')
     assert_equal(@row.add_cell(Date.today).type, :date, 'date should be date')
     assert_equal(@row.add_cell(true).type, :boolean, 'boolean should be boolean')
@@ -88,6 +88,7 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.send(:cell_type_from_value, -1), :integer)
     assert_equal(@c.send(:cell_type_from_value, true), :boolean)
     assert_equal(@c.send(:cell_type_from_value, false), :boolean)
+    assert_equal(@c.send(:cell_type_from_value, 1.0/10**6), :float)
   end
 
   def test_cast_value
@@ -274,6 +275,11 @@ class TestCell < Test::Unit::TestCase
     assert_equal(sz, @c.row.worksheet.workbook.styles.fonts.first.sz)
   end
 
+  def test_font_size_with_bolding
+    @c.style = @c.row.worksheet.workbook.styles.add_style :b => true
+    assert_equal(@c.row.worksheet.workbook.styles.fonts.first.sz * 1.5, @c.send(:font_size))
+  end
+
   def test_font_size_with_custom_sz
     @c.style = @c.row.worksheet.workbook.styles.add_style :sz => 52
     sz = @c.send(:font_size)

data/test/workbook/worksheet/tc_page_set_up_pr.rb

@@ -0,0 +1,15 @@
+require 'tc_helper.rb'
+
+class TestPageSetUpPr < Test::Unit::TestCase
+ def setup
+   @page_setup_pr = Axlsx::PageSetUpPr.new(:fit_to_page => true, :auto_page_breaks => true)
+ end
+
+ def test_fit_to_page
+   assert_equal true, @page_setup_pr.fit_to_page
+ end
+
+ def test_auto_page_breaks
+   assert_equal true, @page_setup_pr.auto_page_breaks
+ end
+end

data/test/workbook/worksheet/tc_page_setup.rb

@@ -44,6 +44,11 @@ class TestPageSetup < Test::Unit::TestCase
     assert_equal(50, @ps.scale)
   end
 
+  def test_paper_size
+    assert_raise(ArgumentError) { @ps.paper_size = 119 }
+    assert_nothing_raised {  @ps.paper_size = 10 }
+  end
+
   def test_set_some_values
     @ps.set(:fit_to_width => 2, :orientation => :portrait)
     assert_equal(2, @ps.fit_to_width)
@@ -58,7 +63,7 @@ class TestPageSetup < Test::Unit::TestCase
     assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
     assert(@ps.fit_to_page? == false)
   end
-
+  
   def test_with_height_fit_to_page?
     assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
     @ps.set(:fit_to_height => 1)

data/test/workbook/worksheet/tc_sheet_calc_pr.rb

@@ -0,0 +1,18 @@
+require 'tc_helper'
+
+class TestSheetCalcPr < Test::Unit::TestCase
+
+  def setup
+    @sheet_calc_pr = Axlsx::SheetCalcPr.new(:full_calc_on_load => false)
+  end
+
+  def test_full_calc_on_load
+    assert_equal false, @sheet_calc_pr.full_calc_on_load
+    assert Axlsx::SheetCalcPr.new.full_calc_on_load
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@sheet_calc_pr.to_xml_string)
+    assert_equal 1, doc.xpath('//sheetCalcPr[@fullCalcOnLoad="false"]').size
+  end
+end

data/test/workbook/worksheet/tc_sheet_pr.rb

@@ -0,0 +1,27 @@
+require 'tc_helper.rb'
+
+
+class TestSheetPr < Test::Unit::TestCase
+
+  def setup
+    worksheet = Axlsx::Package.new.workbook.add_worksheet
+    @options = { 
+      :sync_horizontal => false,
+      :sync_vertical => false,
+      :transtion_evaluation => true,
+      :transition_entry => true,
+      :published => false,
+      :filter_mode => true,
+      :enable_format_conditions_calculation => false,
+      :code_name => '007',
+      :sync_ref => 'foo'
+    }
+    @sheet_pr = Axlsx::SheetPr.new(worksheet, @options)
+  end
+
+  def test_initialization
+    @options.each do |key, value|
+      assert_equal value, @sheet_pr.send(key)
+    end
+  end
+end

data/test/workbook/worksheet/{table/tc_table.rb → tc_table.rb}

@@ -15,6 +15,12 @@ class TestTable < Test::Unit::TestCase
 
   end
 
+  def test_table_style_info
+    table = @ws.add_table('A1:D5', :name => 'foo', :style_info => { :show_row_stripes => true, :name => "TableStyleMedium25" })
+    assert_equal('TableStyleMedium25', table.table_style_info.name)
+    assert_equal(true, table.table_style_info.show_row_stripes)
+  end
+
   def test_add_table
     name = "test"
     table = @ws.add_table("A1:D5", :name => name)
@@ -22,7 +28,6 @@ class TestTable < Test::Unit::TestCase
     assert_equal(@ws.workbook.tables.last, table, "must be added to workbook table collection")
     assert_equal(@ws.tables.last, table, "must be added to worksheet table collection")
     assert_equal(table.name, name, "options for name are applied")
-
   end
 
   def test_pn

data/test/workbook/worksheet/tc_table_style_info.rb

@@ -0,0 +1,53 @@
+require 'tc_helper.rb'
+
+class TestTableStyleInfo < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+    40.times do 
+      @ws.add_row %w(aa bb cc dd ee ff gg hh ii jj kk)
+    end
+    @table = @ws.add_table(Axlsx::cell_range([@ws.rows.first.cells.first,@ws.rows.last.cells.last], false), :name => 'foo')
+    @options =  { :show_first_column => 1,
+                :show_last_column => 1,
+                :show_row_stripes => 1,
+                :show_column_stripes => 1,
+                :name => "TableStyleDark4" }
+
+
+  end
+
+  def test_initialize
+    table_style = Axlsx::TableStyleInfo.new @options
+    @options.each do |key, value|
+      assert_equal(value, table_style.send(key.to_sym))
+    end
+  end
+
+  def test_boolean_properties
+    table_style = Axlsx::TableStyleInfo.new
+    @options.keys.each do |key|
+     assert_nothing_raised { table_style.send("#{key.to_sym}=", true) }
+     assert_raises(ArgumentError) { table_style.send(key.to_sym, 'foo') }
+    end
+  end
+  def doc
+    @doc ||= Nokogiri::XML(Axlsx::TableStyleInfo.new(@options).to_xml_string)
+  end
+
+  def test_to_xml_string_first_column
+    assert(doc.xpath('//tableStyleInfo[@showLastColumn=1]'))
+  end
+
+  def test_to_xml_string_row_stripes
+    assert(doc.xpath('//tableStyleInfo[@showRowStripes=1]'))
+  end
+
+  def test_to_xml_string_column_stripes
+    assert(doc.xpath('//tableStyleInfo[@showColumnStripes=1]'))
+  end
+
+  def test_to_xml_string_name
+    assert(doc.xpath("//tableStyleInfo[@name=#{@options[:name]}]"))
+  end
+end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -246,7 +246,7 @@ class TestWorksheet < Test::Unit::TestCase
 
   def test_to_xml_string_auto_filter
     @ws.add_row [1, "two"]
-    @ws.auto_filter = "A1:B1"
+    @ws.auto_filter.range = "A1:B1"
     doc = Nokogiri::XML(@ws.to_xml_string)
     assert_equal(doc.xpath('//xmlns:worksheet/xmlns:autoFilter[@ref="A1:B1"]').size, 1)
   end
@@ -324,13 +324,20 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(0, @ws.rows.last.cells.last.value.index("\v"))
     assert_equal(nil,@ws.to_xml_string.index("\v"))
   end
+
+  def test_to_xml_string_with_newlines
+    cell_with_newline = "foo\n\r\nbar"
+    @ws.add_row [cell_with_newline]
+    assert_equal("foo\n\r\nbar", @ws.rows.last.cells.last.value)
+    assert_not_nil(@ws.to_xml_string.index("foo\n\r\nbar"))
+  end
   # Make sure the XML for all optional elements (like pageMargins, autoFilter, ...)
   # is generated in correct order.
   def test_valid_with_optional_elements
     @ws.page_margins.set :left => 9
     @ws.page_setup.set :fit_to_width => 1
     @ws.print_options.set :headings => true
-    @ws.auto_filter = "A1:C3"
+    @ws.auto_filter.range = "A1:C3"
     @ws.merge_cells "A4:A5"
     @ws.add_chart Axlsx::Pie3DChart
     @ws.add_table "E1:F3"
@@ -417,7 +424,14 @@ class TestWorksheet < Test::Unit::TestCase
   def test_auto_filter
     assert(@ws.auto_filter.range.nil?)
     assert_raise(ArgumentError) { @ws.auto_filter = 123 }
-    @ws.auto_filter = "A1:D9"
+    @ws.auto_filter.range = "A1:D9"
     assert_equal(@ws.auto_filter.range, "A1:D9")
   end
+
+  def test_sheet_pr_for_auto_filter
+    @ws.auto_filter.range = 'A1:D9'
+    @ws.auto_filter.add_column 0, :filters, :filter_items => [1]
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert(doc.xpath('//sheetPr[@filterMode="true"]')) 
+  end
 end