axlsx 1.2.0 → 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]
@@ -70,7 +76,13 @@ module Axlsx
     def tables
       @tables ||=  Tables.new self
     end
-    
+
+    # A typed collection of hyperlinks associated with this worksheet
+    # @return [WorksheetHyperlinks]
+    def hyperlinks
+      @hyperlinks ||= WorksheetHyperlinks.new self
+    end
+
     # The a shortcut to the worksheet_comments list of comments
     # @return [Array|SimpleTypedList]
     def comments
@@ -391,6 +403,14 @@ module Axlsx
       data_validations << dv
     end
 
+    # Adds a new hyperlink to the worksheet
+    # @param [Hash] options for the hyperlink
+    # @see WorksheetHyperlink for a list of options
+    # @return [WorksheetHyperlink]
+    def add_hyperlink(options={})
+      hyperlinks.add(options)
+    end
+
     # Adds a chart to this worksheets drawing. This is the recommended way to create charts for your worksheet. This method wraps the complexity of dealing with ooxml drawing, anchors, markers graphic frames chart objects and all the other dirty details.
     # @param [Class] chart_type
     # @option options [Array] start_at
@@ -477,25 +497,43 @@ 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
       r = Relationships.new
-      r + [tables.relationships, 
-           worksheet_comments.relationships, 
+      r + [tables.relationships,
+           worksheet_comments.relationships,
+           hyperlinks.relationships,
            worksheet_drawing.relationship].flatten.compact || []
       r
     end
 
+    # identifies the index of an object withing the collections used in generating relationships for the worksheet
+    # @param [Any] object the object to search for
+    # @return [Integer] The index of the object
+    def relationships_index_of(object)
+      objects = [tables.to_a, worksheet_comments.comments.to_a, hyperlinks.to_a, worksheet_drawing.drawing].flatten.compact || []
+      objects.index(object)
+    end
+
     # Returns the cell or cells defined using excel style A1:B3 references.
     # @param [String|Integer] cell_def the string defining the cell or range of cells, or the rownumber
     # @return [Cell, Array]
@@ -533,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
@@ -546,9 +584,9 @@ 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, print_options, page_margins,
+       data_validations, hyperlinks, print_options, page_margins,
        page_setup, worksheet_drawing, worksheet_comments,
        tables]
     end

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

@@ -0,0 +1,101 @@
+module Axlsx
+
+  # A worksheet hyperlink object. Note that this is not the same as a drawing hyperlink object.
+  class WorksheetHyperlink
+
+    # Creates a new hyperlink object.
+    # @note the preferred way to add hyperlinks to your worksheet is the Worksheet#add_hyperlink method
+    # @param [Worksheet] worksheet the Worksheet that owns this hyperlink
+    # @param [Hash] options options to use when creating this hyperlink
+    # @option [String] display Display string, if different from string in string table. This is a property on the hyperlink object, but does not need to appear in the spreadsheet application UI.
+    # @option [String] location Location within target. If target is a workbook (or this workbook) this shall refer to a sheet and cell or a defined name. Can also be an HTML anchor if target is HTML file.
+    # @option [String] tooltip The tip to display when the user positions the mouse cursor over this hyperlink
+    # @option [Symbol] target This is :external by default. If you set it to anything else, the location is interpreted to be the current workbook.
+    # @option [String|Cell] ref The location of this hyperlink in the worksheet
+    def initialize(worksheet, options={})
+      DataTypeValidator.validate "Hyperlink.worksheet", [Worksheet], worksheet
+      @worksheet = worksheet
+      @target = :external
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+
+    # String attributes for this object
+    STRING_ATTRIBUTES = %w(display location tooltip)
+
+    #Cell location of hyperlink on worksheet.
+    # @return [String]
+    attr_reader :ref
+
+    # Sets the target for this hyperlink. Anything other than :external instructs the library to treat the location as an in-workbook reference.
+    # @param [Symbol] target
+    def target=(target)
+      @target = target
+    end
+
+    # Sets the cell location of this hyperlink in the worksheet
+    # @param [String|Cell] cell_reference The string reference or cell that defines where this hyperlink shows in the worksheet.
+    def ref=(cell_reference)
+      cell_reference = cell_reference.r if cell_reference.is_a?(Cell)
+
+      Axlsx::validate_string cell_reference
+      @ref = cell_reference
+    end
+
+    # 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
+
+    # The relationship required by this hyperlink when the taget is :external
+    # @return [Relationship]
+    def relationship
+      return unless @target == :external
+      Relationship.new HYPERLINK_R, location, :target_mode => :External
+    end
+
+    # The id of the relationship for this object
+    # @return [String]
+    def id
+      return unless @target == :external
+      "rId#{(@worksheet.relationships_index_of(self)+1)}"
+    end
+
+    # Seralize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str='')
+      str << '<hyperlink '
+      serialization_values.map { |key, value| str << key.to_s << '="' << value.to_s << '" ' }
+      str << '/>'
+    end
+
+    # The values to be used in serialization based on the target.
+    # location should only be specified for non-external targets.
+    # r:id should only be specified for external targets.
+    # @return [Hash]
+    def serialization_values
+      h = instance_values.reject { |key, value| !%w(display ref tooltip).include?(key) }
+      if @target == :external
+        h['r:id'] = id
+      else
+        h['location'] = location
+      end
+      h
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Axlsx
+
+  #A collection of hyperlink objects for a worksheet
+  class WorksheetHyperlinks < SimpleTypedList
+
+    # Creates a new Hyperlinks collection
+    # @param [Worksheet] worksheet the worksheet that owns these hyperlinks
+    def initialize(worksheet)
+      DataTypeValidator.validate "Hyperlinks.worksheet", [Worksheet], worksheet
+      @worksheet = worksheet
+      super WorksheetHyperlink
+    end
+
+    # Creates and adds a new hyperlink based on the options provided
+    # @see WorksheetHyperlink#initialize
+    # @return [WorksheetHyperlink]
+    def add(options)
+      @list << WorksheetHyperlink.new(@worksheet, options)
+      @list.last
+    end
+
+    # The relationships required by this collection's hyperlinks
+    # @return Array
+    def relationships
+      return [] if empty?
+      map { |hyperlink| hyperlink.relationship }
+    end
+
+    # seralize the collection of hyperlinks
+    # @return [String]
+    def to_xml_string(str='')
+      return if empty?
+      str << '<hyperlinks>'
+      @list.each { |hyperlink| hyperlink.to_xml_string(str) }
+      str << '</hyperlinks>'
+    end
+  end
+end

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/tc_package.rb

@@ -7,6 +7,7 @@ class TestPackage < Test::Unit::TestCase
     ws = @package.workbook.add_worksheet
     ws.add_row ['Can', 'we', 'build it?']
     ws.add_row ['Yes!', 'We', 'can!']
+    ws.add_hyperlink :ref => ws.rows.first.cells.last, :location => 'https://github.com/randym'
     ws.workbook.add_defined_name("#{ws.name}!A1:C2", :name => '_xlnm.Print_Titles', :hidden => true)
     ws.protect_range('A1:C1')
     ws.protect_range(ws.rows.last.cells)

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
@@ -268,6 +269,27 @@ class TestCell < Test::Unit::TestCase
 
   end
 
+  def test_font_size_with_custom_style_and_no_sz
+    @c.style = @c.row.worksheet.workbook.styles.add_style :bg_color => 'FF00FF'
+    sz = @c.send(:font_size)
+    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)
+    assert_equal(sz, 52)
+  end
+
+  def test_cell_with_sz
+    @c.sz = 25
+    assert_equal(25, @c.send(:font_size))
+  end
   def test_to_xml
     # TODO This could use some much more stringent testing related to the xml content generated!
     @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)"]

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)