axlsx 1.3.4 → 1.3.5

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_R, "../#{pivot_table.pn}") }
+    end
+  end
+
+end

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

@@ -147,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

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

@@ -0,0 +1,60 @@
+module Axlsx
+
+  #Sheet formatting properties
+  # <xsd:complexType name="CT_SheetFormatPr">
+  #   <xsd:attribute name="baseColWidth" type="xsd:unsignedInt" use="optional" default="8"/>
+  #   <xsd:attribute name="defaultColWidth" type="xsd:double" use="optional"/>
+  #   <xsd:attribute name="defaultRowHeight" type="xsd:double" use="required"/>
+  #   <xsd:attribute name="customHeight" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="zeroHeight" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="thickTop" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="thickBottom" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="outlineLevelRow" type="xsd:unsignedByte" use="optional" default="0"/>
+  #   <xsd:attribute name="outlineLevelCol" type="xsd:unsignedByte" use="optional" default="0"/>
+  #</xsd:complexType>
+
+  class SheetFormatPr
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+
+    # creates a new sheet_format_pr object
+    # @param [Hash] options initialization options
+    # @option [Integer] base_col_width Specifies the number of characters of the maximum digit width of the normal style's font. This value does not include margin padding or extra padding for gridlines. It is only the number of characters.
+    # @option [Float] default_col_width Default column width measured as the number of characters of the maximum digit width of the normal style's font.
+    # @option [Float] default_row_height Default row height measured in point size. Optimization so we don't have to write the height on all rows. This can be written out if most rows have custom height, to achieve the optimization.
+    # @option [Boolean] custom_height 'True' if defaultRowHeight value has been manually set, or is different from the default value.
+    # @option [Boolean] zero_height 'True' if rows are hidden by default. This setting is an optimization used when most rows of the sheet are hidden.
+    # @option [Boolean] think_top 'True' if rows have a thick top border by default.
+    # @option [Boolean] thick_bottom 'True' if rows have a thick bottom border by default.
+    # @option [Integer] outline_level_row Highest number of outline level for rows in this sheet. These values shall be in synch with the actual sheet outline levels.
+    # @option [Integer] outline_level_col Highest number of outline levels for columns in this sheet. These values shall be in synch with the actual sheet outline levels.
+    def initialize(options={})
+      set_defaults
+      parse_options options
+    end
+
+    serializable_attributes :base_col_width, :default_col_width, :default_row_height,
+      :custom_height, :zero_height, :thick_top, :thick_bottom,
+      :outline_level_row, :outline_level_col
+
+    float_attr_accessor :default_col_width, :default_row_height
+
+    boolean_attr_accessor :custom_height, :zero_height, :thick_top, :thick_bottom
+
+    unsigned_int_attr_accessor :base_col_width, :outline_level_row, :outline_level_col 
+
+    # serializes this object to an xml string
+    # @param [String] str The string this objects serialization will be appended to
+    # @return [String]
+    def to_xml_string(str='')
+      str << "<sheetFormatPr #{serialized_attributes}/>"
+    end
+
+    private
+    def set_defaults
+      @base_col_width = 8
+      @default_row_height = 18
+    end
+  end
+end

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

@@ -23,11 +23,11 @@ module Axlsx
     # @option options [Boolean] show_gridlines indicates if gridlines should be shown for this sheet.
     def initialize(wb, options={})
       self.workbook = wb
-      @workbook.worksheets << self
       @sheet_protection = nil
 
       initialize_page_options(options)
       parse_options options
+      @workbook.worksheets << self
     end
 
     # Initalizes page margin, setup and print options
@@ -69,6 +69,15 @@ module Axlsx
       @sheet_view
     end
 
+    # The sheet format pr for this worksheet
+    # @return [SheetFormatPr]
+    # @see [SheetFormatPr]
+    def sheet_format_pr
+      @sheet_format_pr ||= SheetFormatPr.new
+      yeild @sheet_format_pr if block_given?
+      @sheet_format_pr
+    end
+
     # The workbook that owns this worksheet
     # @return [Workbook]
     attr_reader :workbook
@@ -79,6 +88,12 @@ module Axlsx
       @tables ||=  Tables.new self
     end
 
+    # The pivot tables in this worksheet
+    # @return [Array] of Table
+    def pivot_tables
+      @pivot_tables ||=  PivotTables.new self
+    end
+
     # A typed collection of hyperlinks associated with this worksheet
     # @return [WorksheetHyperlinks]
     def hyperlinks
@@ -454,6 +469,12 @@ module Axlsx
       tables.last
     end
 
+    def add_pivot_table(ref, range, options={})
+      pivot_tables << PivotTable.new(ref, range, self, options)
+      yield pivot_tables.last if block_given?
+      pivot_tables.last
+    end
+
     # Shortcut to worsksheet_comments#add_comment
     def add_comment(options={})
       worksheet_comments.add_comment(options)
@@ -539,7 +560,8 @@ module Axlsx
       r + [tables.relationships,
            worksheet_comments.relationships,
            hyperlinks.relationships,
-           worksheet_drawing.relationship].flatten.compact || []
+           worksheet_drawing.relationship,
+           pivot_tables.relationships].flatten.compact || []
       r
     end
 
@@ -586,21 +608,48 @@ module Axlsx
       @styles ||= self.workbook.styles
     end
 
+    # shortcut level to specify the outline level for a series of rows
+    # Oulining is what lets you add collapse and expand to a data set.
+    # @param [Integer] start_index The zero based index of the first row of outlining.
+    # @param [Integer] end_index The zero based index of  the last row to be outlined
+    # @param [integer] level The level of outline to apply
+    # @param [Integer] collapsed The initial collapsed state of the outline group
+    def outline_level_rows(start_index, end_index, level = 1, collapsed = true)
+      outline rows, (start_index..end_index), level, collapsed
+    end
+
+    # shortcut level to specify the outline level for a series of columns
+    # Oulining is what lets you add collapse and expand to a data set.
+    # @param [Integer] start_index The zero based index of the first column of outlining.
+    # @param [Integer] end_index The zero based index of  the last column to be outlined
+    # @param [integer] level The level of outline to apply
+    # @param [Integer] collapsed The initial collapsed state of the outline group
+    def outline_level_columns(start_index, end_index, level = 1, collapsed = true)
+      outline column_info, (start_index..end_index), level, collapsed
+    end
 
     private
+    def outline(collection, range, level = 1, collapsed = true)
+       range.each do |index|
+        unless (item = collection[index]).nil?
+          item.outline_level = level
+          item.hidden = collapsed
+        end
+        sheet_view.show_outline_symbols = true
+      end
+    end
 
     def validate_sheet_name(name)
       DataTypeValidator.validate "Worksheet.name", String, name
       raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % name) if name.size > 31
-      raise ArgumentError, (ERR_SHEET_NAME_COLON_FORBIDDEN % name) if name.include? ':'
+      raise ArgumentError, (ERR_SHEET_NAME_CHARACTER_FORBIDDEN % name) if '[]*/\?:'.chars.any? { |char| name.include? char }
       name = Axlsx::coder.encode(name)
-      sheet_names = @workbook.worksheets.map { |s| s.name }
+      sheet_names = @workbook.worksheets.reject { |s| s == self }.map { |s| s.name }
       raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % name) if sheet_names.include?(name)
     end
 
-
     def serializable_parts
-      [sheet_pr, dimension, sheet_view, column_info,
+      [sheet_pr, dimension, sheet_view, sheet_format_pr, column_info,
        sheet_data, sheet_calc_pr, @sheet_protection, protected_ranges,
        auto_filter, merged_cells, conditional_formattings,
        data_validations, hyperlinks, print_options, page_margins,

data/test/benchmark.rb

@@ -4,6 +4,7 @@ $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
 require 'csv'
 require 'benchmark'
+Axlsx::trust_input = true
 row = []
 input = (32..126).to_a.pack('U*').chars.to_a
 20.times { row << input.shuffle.join}

data/test/drawing/tc_chart.rb

@@ -37,6 +37,13 @@ class TestChart < Test::Unit::TestCase
     assert_nothing_raised { @chart.style = 2 }
     assert_equal(@chart.style, 2)
   end
+  
+  def test_vary_colors
+    assert_equal(true, @chart.vary_colors)
+    assert_raise(ArgumentError) { @chart.vary_colors = 7 }
+    assert_nothing_raised { @chart.vary_colors = false }
+    assert_equal(false, @chart.vary_colors)
+  end
 
   def test_start_at
     @chart.start_at 15, 25

data/test/drawing/tc_graphic_frame.rb

@@ -22,4 +22,9 @@ class TestGraphicFrame < Test::Unit::TestCase
     assert_equal(chart.graphic_frame.rId, "rId2")
   end
 
+  def test_rId_with_image_and_chart
+    image = @ws.add_image :image_src => (File.dirname(__FILE__) + "/../../examples/image1.jpeg"), :start_at => [0,25], :width => 200, :height => 200
+    assert_equal(2, image.id)
+    assert_equal(1, @chart.index+1)
+  end
 end

data/test/profile.rb

@@ -8,6 +8,7 @@
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
 require 'perftools'
+Axlsx.trust_input = true
 row = []
 # Taking worst case scenario of all string data
 input = (32..126).to_a.pack('U*').chars.to_a

data/test/tc_axlsx.rb

@@ -18,6 +18,15 @@ class TestAxlsx < Test::Unit::TestCase
     assert_equal(Axlsx.cell_range([]), "")
   end
 
+  def test_do_not_trust_input_by_default
+    assert_equal false, Axlsx.trust_input
+  end
+
+
+  def test_trust_input_can_be_set_to_true
+    Axlsx.trust_input = true
+    assert_equal true, Axlsx.trust_input
+  end
   def test_cell_range_relative
     p = Axlsx::Package.new
     ws = p.workbook.add_worksheet
@@ -54,4 +63,10 @@ class TestAxlsx < Test::Unit::TestCase
     # todo
   end
 
+  def test_range_to_a
+    assert_equal([['A1', 'B1', 'C1']],                         Axlsx::range_to_a('A1:C1'))
+    assert_equal([['A1', 'B1', 'C1'], ['A2', 'B2', 'C2']],     Axlsx::range_to_a('A1:C2'))
+    assert_equal([['Z5', 'AA5', 'AB5'], ['Z6', 'AA6', 'AB6']], Axlsx::range_to_a('Z5:AB6'))
+  end
+
 end

data/test/tc_package.rb

@@ -7,6 +7,8 @@ class TestPackage < Test::Unit::TestCase
     ws = @package.workbook.add_worksheet
     ws.add_row ['Can', 'we', 'build it?']
     ws.add_row ['Yes!', 'We', 'can!']
+    ws.outline_level_rows 0, 1
+    ws.outline_level_columns 0, 1
     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')
@@ -38,15 +40,15 @@ class TestPackage < Test::Unit::TestCase
     ws.add_chart(Axlsx::Line3DChart, :title => "axis labels") do |chart|
       chart.valAxis.title = 'bob'
       chart.d_lbls.show_val = true
-    end 
-    
+    end
+
     ws.add_chart(Axlsx::Bar3DChart, :title => 'bar chart') do |chart|
       chart.add_series :data => [1,4,5], :labels => %w(A B C)
       chart.d_lbls.show_percent = true
     end
 
     ws.add_chart(Axlsx::ScatterChart, :title => 'scat man') do |chart|
-      chart.add_series :xData => [1,2,3,4], :yData => [4,3,2,1] 
+      chart.add_series :xData => [1,2,3,4], :yData => [4,3,2,1]
       chart.d_lbls.show_val = true
     end
 
@@ -61,7 +63,7 @@ class TestPackage < Test::Unit::TestCase
     ws.add_image :image_src => File.expand_path('../../examples/image1.gif', __FILE__) do |image|
       image.start_at 0, 20
       image.width=360
-      image.height=333 
+      image.height=333
     end
     ws.add_image :image_src => File.expand_path('../../examples/image1.png', __FILE__) do |image|
       image.start_at 9, 20
@@ -69,6 +71,9 @@ class TestPackage < Test::Unit::TestCase
       image.height = 167
     end
     ws.add_table 'A1:C1'
+
+    ws.add_pivot_table 'G5:G6', 'A1:B3'
+
   end
 
   def test_use_autowidth
@@ -135,10 +140,13 @@ class TestPackage < Test::Unit::TestCase
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/comments\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/pivotTable\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/_rels\/pivotTable\d\.xml.rels/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotCache\/pivotCacheDefinition\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
 
 
     #no mystery parts
-    assert_equal(p.size, 21)
+    assert_equal(24, p.size)
 
   end
 

data/test/workbook/worksheet/tc_cell.rb

@@ -89,6 +89,7 @@ class TestCell < Test::Unit::TestCase
     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)
+    assert_equal(:iso_8601, @c.send(:cell_type_from_value, '2008-08-30T01:45:36.123+09:00'))
   end
 
   def test_cast_value
@@ -105,6 +106,8 @@ class TestCell < Test::Unit::TestCase
     @c.type = :boolean
     assert_equal(@c.send(:cast_value, true), 1)
     assert_equal(@c.send(:cast_value, false), 0)
+    @c.type = :iso_8601
+    assert_equal("2012-10-10T12:24", @c.send(:cast_value, "2012-10-10T12:24"))
   end
 
   def test_color
@@ -299,8 +302,9 @@ class TestCell < Test::Unit::TestCase
   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)"]
+    @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)", "2013-01-13T13:31:25.123"]
     @ws.rows.last.cells[5].u = true
+    
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@ws.to_xml_string)
     errors = []

data/test/workbook/worksheet/tc_pivot_table.rb

@@ -0,0 +1,102 @@
+require 'tc_helper.rb'
+
+class TestPivotTable < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+
+    @ws << ["Year","Month","Region", "Type", "Sales"]
+    @ws << [2012,  "Nov",  "East",   "Soda", "12345"]
+  end
+
+  def test_initialization
+    assert(@ws.workbook.pivot_tables.empty?)
+    assert(@ws.pivot_tables.empty?)
+  end
+
+  def test_add_pivot_table
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal('G5:G6', pivot_table.ref, 'ref assigned from first parameter')
+    assert_equal('A1:D5', pivot_table.range, 'range assigned from second parameter')
+    assert_equal('PivotTable1', pivot_table.name, 'name automatically generated')
+    assert(pivot_table.is_a?(Axlsx::PivotTable), "must create a pivot table")
+    assert_equal(@ws.workbook.pivot_tables.last, pivot_table, "must be added to workbook pivot tables collection")
+    assert_equal(@ws.pivot_tables.last, pivot_table, "must be added to worksheet pivot tables collection")
+  end
+
+  def test_add_pivot_table_with_config
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5') do |pt|
+      pt.rows = ['Year', 'Month']
+      pt.columns = ['Type']
+      pt.data = ['Sales']
+      pt.pages = ['Region']
+    end
+    assert_equal(['Year', 'Month'], pivot_table.rows)
+    assert_equal(['Type'], pivot_table.columns)
+    assert_equal(['Sales'], pivot_table.data)
+    assert_equal(['Region'], pivot_table.pages)
+  end
+
+  def test_header_indices
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5')
+    assert_equal(0,   pivot_table.header_index_of('Year'   ))
+    assert_equal(1,   pivot_table.header_index_of('Month'  ))
+    assert_equal(2,   pivot_table.header_index_of('Region' ))
+    assert_equal(3,   pivot_table.header_index_of('Type'   ))
+    assert_equal(4,   pivot_table.header_index_of('Sales'  ))
+    assert_equal(nil, pivot_table.header_index_of('Missing'))
+    assert_equal(%w(A1 B1 C1 D1 E1), pivot_table.header_cell_refs)
+  end
+
+  def test_pn
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.pivot_tables.first.pn, "pivotTables/pivotTable1.xml")
+  end
+
+  def test_rId
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.pivot_tables.first.rId, "rId1")
+  end
+
+  def test_index
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.pivot_tables.first.index, @ws.workbook.pivot_tables.index(@ws.pivot_tables.first))
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?)
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.relationships.size, 1, "adding a pivot table adds a relationship")
+    @ws.add_pivot_table('G10:G11', 'A1:D5')
+    assert_equal(@ws.relationships.size, 2, "adding a pivot table adds a relationship")
+  end
+
+  def test_to_xml_string
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(pivot_table.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+  def test_to_xml_string_with_configuration
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.rows = ['Year', 'Month']
+      pt.columns = ['Type']
+      pt.data = ['Sales']
+      pt.pages = ['Region']
+    end
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(pivot_table.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+end