axlsx 1.1.1 → 1.1.2

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

@@ -0,0 +1,95 @@
+module Axlsx
+  # Conditional Format Rule data bar object
+  # Describes a data bar conditional formatting rule.
+
+  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
+  # @see Worksheet#add_conditional_formatting
+  # @see ConditionalFormattingRule#initialize
+  class DataBar
+    CHILD_ELEMENTS = [:value_objects]
+
+    # minLength attribute
+    # The minimum length of the data bar, as a percentage of the cell width.
+    # The default value is 10
+    # @return [Integer]
+    attr_reader :minLength
+
+    # maxLength attribute
+    # The maximum length of the data bar, as a percentage of the cell width.
+    # The default value is 90
+    # @return [Integer]
+    attr_reader :maxLength
+
+    # maxLength attribute
+    # Indicates whether to show the values of the cells on which this data bar is applied.
+    # The default value is true
+    # @return [Boolean]
+    attr_reader :showValue
+
+    # A simple typed list of cfvos
+    # @return [SimpleTypedList]
+    # @see Cfvo
+    attr_reader :value_objects
+
+    # color
+    # the color object used in the data bar formatting
+    # @return [Color]
+    def color
+      @color ||= Color.new :rgb => "FF0000FF"
+    end
+
+    # Creates a new data bar conditional formatting object
+    # @option options [Integer] minLength
+    # @option options [Integer] maxLength
+    # @option options [Boolean] showValue
+    # @option options [String] color - the rbg value used to color the bars
+    def initialize(options = {})
+      @minLength = 10
+      @maxLength = 90
+      @showValue = true
+      initialize_value_objects
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+
+    # @see minLength
+    def minLength=(v); Axlsx.validate_unsigned_int(v); @minLength = v end
+    # @see maxLength
+    def maxLength=(v); Axlsx.validate_unsigned_int(v); @maxLength = v end
+
+    # @see showValue
+    def showValue=(v); Axlsx.validate_boolean(v); @showValue = v end
+
+    # Sets the color for the data bars.
+    # @param [Color|String] The color object, or rgb string value to apply
+    def color=(v)
+      @color = v if v.is_a? Color
+      self.color.rgb = v if v.is_a? String
+      @color
+    end
+
+    # Serialize this object to an xml string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str="")
+      str << '<dataBar '
+      str << instance_values.map { |key, value| '' << key << '="' << value.to_s << '"' unless CHILD_ELEMENTS.include?(key.to_sym) }.join(' ')
+      str << '>'
+      @value_objects.each { |cfvo| cfvo.to_xml_string(str) }
+      self.color.to_xml_string(str)
+      str << '</dataBar>'
+    end
+
+    private
+
+    # Initalize the simple typed list of value objects
+    # I am keeping this private for now as I am not sure what impact changes to the required two cfvo objects will do.
+    def initialize_value_objects
+      @value_objects = SimpleTypedList.new Cfvo
+      @value_objects.concat [Cfvo.new(:type => :min, :val => 0), Cfvo.new(:type => :max, :val => 0)]
+      @value_objects.lock
+    end
+  end
+end

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

@@ -132,6 +132,8 @@ module Axlsx
         cell_type = types.is_a?(Array)? types[index] : types
         options[:type] = cell_type if cell_type
         Cell.new(self, value, options)
+        options.delete(:style)
+        options.delete(:type)
       end
     end
   end

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

@@ -101,6 +101,7 @@ module Axlsx
       @drawing = @page_margins = @auto_filter = nil
       @merged_cells = []
       @auto_fit_data = []
+      @conditional_formattings = []
 
       @selected = false
       @show_gridlines = true
@@ -123,6 +124,22 @@ module Axlsx
       rows.flatten
     end
 
+    # Add conditional formatting to this worksheet.
+    #
+    # @param [String] cells The range to apply the formatting to
+    # @param [Array|Hash] rules An array of hashes (or just one) to create Conditional formatting rules from.
+    # @example This would format column A whenever it is FALSE.
+    #        # for a longer example, see examples/example_conditional_formatting.rb (link below)
+    #        worksheet.add_conditional_formatting( "A1:A1048576", { :type => :cellIs, :operator => :equal, :formula => "FALSE", :dxfId => 1, :priority => 1 }
+    #
+    # @see ConditionalFormattingRule#initialize
+    # @see file:examples/example_conditional_formatting.rb
+    def add_conditional_formatting(cells, rules)
+      cf = ConditionalFormatting.new( :sqref => cells )
+      cf.add_rules rules
+      @conditional_formattings << cf
+    end
+
     # Creates merge information for this worksheet.
     # Cells can be merged by calling the merge_cells method on a worksheet.
     # @example This would merge the three cells C1..E1    #
@@ -411,6 +428,9 @@ module Axlsx
       unless @tables.empty?
         str.concat "<tableParts count='%s'>%s</tableParts>" % [@tables.size, @tables.reduce('') { |memo, obj| memo += "<tablePart r:id='%s'/>" % obj.rId }]
       end
+      @conditional_formattings.each do |cf|
+        str.concat cf.to_xml_string
+      end
       str + '</worksheet>'
     end
 
@@ -476,10 +496,12 @@ module Axlsx
     end
 
 
-    # If you *REALLY* want to know what this does, check the spec for how column width is specified.
+    # This is still not perfect...
+    #  - scaling is not linear as font sizes increst
+    #  - different fonts have different mdw and char widths
     def calculate_width(text, sz)
-      mdw = 1.78 #magic numbers ftw! This is the widest width of 0..9 in the "standard" font (arial@10px)
-      font_scale = sz/10.0
+      mdw = 1.78 #This is the widest width of 0..9 in arial@10px)
+      font_scale = (sz/10.0).to_f
       ((text.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
     end
   end

data/test/drawing/tc_axis.rb

@@ -21,6 +21,14 @@ class TestAxis < Test::Unit::TestCase
     assert_nothing_raised("accepts valid axis position") { @axis.axPos = :r }
   end
 
+  def test_label_rotation
+    assert_raise(ArgumentError, "requires valid angle") { @axis.label_rotation = :nowhere }
+    assert_raise(ArgumentError, "requires valid angle") { @axis.label_rotation = 91 }
+    assert_raise(ArgumentError, "requires valid angle") { @axis.label_rotation = -91 }
+    assert_nothing_raised("accepts valid angle") { @axis.label_rotation = 45 }
+    assert_equal(@axis.label_rotation, 45 * 60000)
+  end
+
   def test_tick_label_position
     assert_raise(ArgumentError, "requires valid tick label position") { @axis.tickLblPos = :nowhere }
     assert_nothing_raised("accepts valid tick label position") { @axis.tickLblPos = :high }

data/test/stylesheet/tc_dxf.rb

@@ -0,0 +1,81 @@
+require 'tc_helper.rb'
+
+class TestDxf < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Dxf.new
+    @styles = Axlsx::Styles.new    
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.alignment, nil)
+    assert_equal(@item.protection, nil)
+    assert_equal(@item.numFmt, nil)
+    assert_equal(@item.font, nil)
+    assert_equal(@item.fill, nil)
+    assert_equal(@item.border, nil)
+  end
+
+  def test_alignment
+    assert_raise(ArgumentError) { @item.alignment = -1.1 }
+    assert_nothing_raised { @item.alignment = Axlsx::CellAlignment.new }
+    assert(@item.alignment.is_a?(Axlsx::CellAlignment))
+  end
+
+  def test_protection
+    assert_raise(ArgumentError) { @item.protection = -1.1 }
+    assert_nothing_raised { @item.protection = Axlsx::CellProtection.new }
+    assert(@item.protection.is_a?(Axlsx::CellProtection))
+  end
+
+  def test_numFmt
+    assert_raise(ArgumentError) { @item.numFmt = 1 }
+    assert_nothing_raised { @item.numFmt = Axlsx::NumFmt.new }
+    assert @item.numFmt.is_a? Axlsx::NumFmt
+  end
+
+  def test_fill
+    assert_raise(ArgumentError) { @item.fill =  1 }
+    assert_nothing_raised { @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000"))) }
+    assert @item.fill.is_a? Axlsx::Fill
+  end
+
+  def test_font
+    assert_raise(ArgumentError) { @item.font = 1 }
+    assert_nothing_raised { @item.font = Axlsx::Font.new }
+    assert @item.font.is_a? Axlsx::Font 
+  end
+
+  def test_border
+    assert_raise(ArgumentError) { @item.border = 1 }
+    assert_nothing_raised { @item.border = Axlsx::Border.new }
+    assert @item.border.is_a? Axlsx::Border
+  end
+
+  def test_to_xml
+    @item.border = Axlsx::Border.new
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//border").size)
+    assert_equal(0, doc.xpath(".//dxf//font").size)    
+  end
+
+  def test_many_options_xml
+    @item.border = Axlsx::Border.new
+    @item.alignment = Axlsx::CellAlignment.new
+    @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000")))
+    @item.font = Axlsx::Font.new
+    @item.protection = Axlsx::CellProtection.new
+    @item.numFmt = Axlsx::NumFmt.new
+    
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//fill//patternFill[@patternType='solid']//fgColor[@rgb='FF000000']").size)
+    assert_equal(1, doc.xpath(".//dxf//font").size)
+    assert_equal(1, doc.xpath(".//dxf//protection").size)
+    assert_equal(1, doc.xpath(".//dxf//numFmt[@numFmtId='0'][@formatCode='']").size)
+    assert_equal(1, doc.xpath(".//dxf//alignment").size)
+    assert_equal(1, doc.xpath(".//dxf//border").size)    
+  end
+end

data/test/stylesheet/tc_styles.rb

@@ -41,6 +41,111 @@ class TestStyles < Test::Unit::TestCase
     assert_equal options[:border][:color], "FF000000", 'color is stil in option'
   end
 
+  def test_parse_num_fmt
+    f_code = {:format_code => "YYYY/MM"}
+    num_fmt = {:num_fmt => 5}
+    both = { :format_code => "#000", :num_fmt => 0 }
+    assert_equal(@styles.parse_num_fmt_options, nil, 'noop if neither :format_code or :num_fmt exist')
+    max = @styles.numFmts.map{ |nf| nf.numFmtId }.max
+    @styles.parse_num_fmt_options(f_code)
+    assert_equal(@styles.numFmts.last.numFmtId, max + 1, "new numfmts gets next available id")
+    assert(@styles.parse_num_fmt_options(num_fmt).is_a?(Integer), "Should return the provided num_fmt if not dxf")
+    assert(@styles.parse_num_fmt_options(num_fmt.merge({:type => :dxf})).is_a?(Axlsx::NumFmt), "Makes a new NumFmt if dxf")
+  end
+
+  def test_parse_border_options_hash_required_keys
+    assert_raise(ArgumentError, "Require color key") { @styles.parse_border_options(:border => { :style => :thin }) }
+    assert_raise(ArgumentError, "Require style key") { @styles.parse_border_options(:border => { :color => "FF0d0d0d" }) }
+    assert_nothing_raised { @styles.parse_border_options(:border => { :style => :thin, :color => "FF000000"} ) }
+  end
+
+  def test_parse_border_basic_options
+    b_opts = {:border => { :diagonalUp => 1, :edges => [:left, :right], :color => "FFDADADA", :style => :thick } }
+    b = @styles.parse_border_options b_opts
+    assert(b.is_a? Integer)
+    assert_equal(@styles.parse_border_options(b_opts.merge({:type => :dxf})).class,Axlsx::Border)
+    assert(@styles.borders.last.diagonalUp == 1, "border options are passed in to the initializer")
+  end
+
+  def test_parse_border_options_edges
+    b_opts = {:border => { :diagonalUp => 1, :edges => [:left, :right], :color => "FFDADADA", :style => :thick } }
+    @styles.parse_border_options b_opts
+    b = @styles.borders.last
+    left = b.prs.select { |bpr| bpr.name == :left }[0]
+    right = b.prs.select { |bpr| bpr.name == :right }[0]
+    top = b.prs.select { |bpr| bpr.name == :top }[0]
+    bottom = b.prs.select { |bpr| bpr.name == :bottom }[0]
+    assert_equal(top, nil, "unspecified top edge should not be created")
+    assert_equal(bottom, nil, "unspecified bottom edge should not be created")
+    assert(left.is_a?(Axlsx::BorderPr), "specified left edge is set")
+    assert(right.is_a?(Axlsx::BorderPr), "specified right edge is set")
+    assert_equal(left.style,right.style, "edge parts have the same style")
+    assert_equal(left.style, :thick, "the style is THICK")
+    assert_equal(right.color.rgb,left.color.rgb, "edge parts are colors are the same")
+    assert_equal(right.color.rgb,"FFDADADA", "edge color rgb is correct")
+  end
+
+  def test_parse_border_options_noop
+    assert_equal(@styles.parse_border_options({}), nil, "noop if the border key is not in options")
+  end
+
+  def test_parse_border_options_integer_xf
+    assert_equal(@styles.parse_border_options(:border => 1), 1)
+    assert_raise(ArgumentError, "unknown border index") {@styles.parse_border_options(:border => 100) }
+  end
+
+  def test_parse_border_options_integer_dxf
+    b_opts = { :border => { :edges => [:left, :right], :color => "FFFFFFFF", :style=> :thick } }
+    b = @styles.parse_border_options(b_opts)
+    b2 = @styles.parse_border_options(:border => b, :type => :dxf)
+    assert(b2.is_a?(Axlsx::Border), "Cloned existing border object")
+  end
+
+  def test_parse_alignment_options
+    assert_equal(@styles.parse_alignment_options {}, nil, "noop if :alignment is not set")
+    assert(@styles.parse_alignment_options(:alignment => {}).is_a?(Axlsx::CellAlignment))
+  end
+
+  def test_parse_font_options
+    options = {
+      :fg_color => "FF050505",
+      :sz => 20,
+      :b => 1,
+      :i => 1,
+      :u => 1,
+      :strike => 1,
+      :outline => 1,
+      :shadow => 1,
+      :charset => 9,
+      :family => 1,
+      :font_name => "woot font"
+    }
+    assert_equal(@styles.parse_font_options {}, nil, "noop if no font keys are set")
+    assert_equal(@styles.parse_font_options(:b=>1).class, Fixnum, "return index of font if not :dxf type")
+    assert_equal(@styles.parse_font_options(:b=>1, :type => :dxf).class, Axlsx::Font, "return font object if :dxf type")
+
+    f = @styles.parse_font_options(options.merge(:type => :dxf))
+    color = options.delete(:fg_color)
+    options[:name] = options.delete(:font_name)
+    options.each do |key, value|
+      assert_equal(f.send(key), value, "assert that #{key} was parsed")
+    end
+    assert_equal(f.color.rgb, color)
+  end
+
+  def test_parse_fill_options
+    assert_equal(@styles.parse_fill_options {}, nil, "noop if no fill keys are set")
+    assert_equal(@styles.parse_fill_options(:bg_color => "DE").class, Fixnum, "return index of fill if not :dxf type")
+    assert_equal(@styles.parse_fill_options(:bg_color => "DE", :type => :dxf).class, Axlsx::Fill, "return fill object if :dxf type")
+    f = @styles.parse_fill_options(:bg_color => "DE", :type => :dxf)
+    assert(f.fill_type.fgColor.rgb == "FFDEDEDE")
+  end
+
+  def test_parse_protection_options
+    assert_equal(@styles.parse_protection_options {}, nil, "noop if no protection keys are set")
+    assert_equal(@styles.parse_protection_options(:hidden => 1).class, Axlsx::CellProtection, "creates a new cell protection object")
+  end
+
   def test_add_style
     fill_count = @styles.fills.size
     font_count = @styles.fonts.size
@@ -68,10 +173,51 @@ class TestStyles < Test::Unit::TestCase
     assert_raise(ArgumentError, "should reject invalid borderId") { @styles.add_style :border => 2 }
 
 
-    assert_equal(xf.applyProtection, 1, "protection applied")
+    assert_equal(xf.applyProtection, true, "protection applied")
     assert_equal(xf.applyBorder, true, "border applied")
-    assert_equal(xf.applyNumberFormat, true, "number format applied")
+    assert_equal(xf.applyNumberFormat,true, "number format applied")
     assert_equal(xf.applyAlignment, true, "alignment applied")
   end
 
+  def test_basic_add_style_dxf
+    border_count = @styles.borders.size
+    s = @styles.add_style :border => {:style => :thin, :color => "FFFF0000"}, :type => :dxf
+    assert_equal(@styles.borders.size, border_count, "styles borders not affected")
+    assert_equal(@styles.dxfs.last.border.prs.last.color.rgb, "FFFF0000")
+    assert_raise(ArgumentError) { @styles.add_style :border => {:color => "FFFF0000"}, :type => :dxf }
+    assert_equal @styles.borders.last.prs.size, 4
+  end
+
+  def test_add_style_dxf
+    fill_count = @styles.fills.size
+    font_count = @styles.fonts.size
+    dxf_count = @styles.dxfs.size
+
+    style = @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
+    assert_equal(@styles.dxfs.size, dxf_count+1)
+    assert_equal(0, style, "returns the zero-based dxfId")
+
+    dxf = @styles.dxfs.last
+    assert_equal(@styles.dxfs.last.fill.fill_type.fgColor.rgb, "FF000000", "fill created with color")
+
+    assert_equal(font_count, (@styles.fonts.size), "font not created under styles")
+    assert_equal(fill_count, (@styles.fills.size), "fill not created under styles")
+
+    assert(dxf.border.is_a?(Axlsx::Border), "border is set")
+    assert_equal(nil, dxf.numFmt, "number format is not set")
+
+    assert(dxf.alignment.is_a?(Axlsx::CellAlignment), "alignment was created")
+    assert_equal(dxf.alignment.horizontal, :left, "horizontal alignment applied")
+    assert_equal(dxf.protection.hidden, true, "hidden protection set")
+    assert_equal(dxf.protection.locked, true, "cell locking set")
+    assert_raise(ArgumentError, "should reject invalid borderId") { @styles.add_style :border => 3 }
+  end
+
+  def test_multiple_dxf
+    # add a second style
+    style = @styles.add_style :bg_color=>"00000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
+    assert_equal(0, style, "returns the first dxfId")
+    style = @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
+    assert_equal(1, style, "returns the second dxfId")
+  end
 end

data/test/workbook/worksheet/tc_cfvo.rb

@@ -0,0 +1,31 @@
+require 'tc_helper.rb'
+
+class TestCfvo < Test::Unit::TestCase
+  def setup
+    @cfvo = Axlsx::Cfvo.new(:val => "0", :type => :min)
+  end
+
+  def test_val
+    assert_nothing_raised { @cfvo.val = "abc" }
+    assert_equal(@cfvo.val, "abc")
+  end
+
+  def test_type
+    assert_raise(ArgumentError) { @cfvo.type = :invalid_type }
+    assert_nothing_raised { @cfvo.type = :max }
+    assert_equal(@cfvo.type, :max)
+  end
+
+  def test_gte
+    assert_raise(ArgumentError) { @cfvo.gte = :bob }
+    assert_equal(@cfvo.gte, true)
+    assert_nothing_raised { @cfvo.gte = false }
+    assert_equal(@cfvo.gte, false)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML.parse(@cfvo.to_xml_string)
+    assert doc.xpath(".//cfvo[@type='min'][@val=0][@gte=true]")
+  end
+
+end