axlsx 1.1.4 → 1.3.1

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

@@ -0,0 +1,57 @@
+module Axlsx
+
+  # A wraper class for comments that defines its on worksheet
+  # serailization
+  class WorksheetComments
+
+    # Creates a new WorksheetComments object
+    # param [Worksheet] worksheet The worksheet comments in thes object belong to
+    def initialize(worksheet)
+      raise ArugumentError, 'You must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+
+    attr_reader :worksheet
+
+    # The comments for this worksheet.
+    # @return [Comments]
+    def comments
+      @comments ||= Comments.new(worksheet)
+    end
+
+    # Adds a comment
+    # @param [Hash] options
+    # @see Comments#add_comment
+    def add_comment(options={})
+      comments.add_comment(options)
+    end 
+
+    # The relationships defined by this objects comments collection
+    # @return [Relationships]
+    def relationships
+      return [] unless has_comments?
+      comments.relationships
+    end
+
+
+    # Helper method to tell us if there are comments in the comments collection
+    # @return [Boolean]
+    def has_comments?
+      !comments.empty?
+    end
+
+    # The index in the worksheet's relationships for the VML drawing that will render the comments
+    # @return [Integer]
+    def index
+      worksheet.relationships.index { |r| r.Type == VML_DRAWING_R } + 1
+    end
+
+    # Seraalize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      return unless has_comments?
+      str << "<legacyDrawing r:id='rId#{index}' />"
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Axlsx
+  
+  # This is a utility class for serialing the drawing node in a
+  # worksheet. Drawing objects have their own serialization that exports
+  # a drawing document. This is only for the single node in the
+  # worksheet
+  class WorksheetDrawing
+
+    # Creates a new WorksheetDrawing
+    # @param [Worksheet] worksheet
+    def initialize(worksheet)
+      raise ArgumentError, 'you must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet      
+      @drawing = nil
+    end
+
+    attr_reader :worksheet
+
+    attr_reader :drawing
+    
+    # adds a chart to the drawing object
+    # @param [Class] chart_type The type of chart to add
+    # @param [Hash] options Options to pass on to the drawing and chart
+    # @see Worksheet#add_chart
+    def add_chart(chart_type, options)
+      @drawing ||= Drawing.new worksheet
+      drawing.add_chart(chart_type, options)
+    end
+    
+    # adds an image to the drawing object
+    # @param [Hash] options Options to pass on to the drawing and image 
+    # @see Worksheet#add_image
+    def add_image(options)
+      @drawing ||= Drawing.new worksheet
+      drawing.add_image(options)
+    end 
+  
+    # helper method to tell us if the drawing has something in it or not
+    # @return [Boolean] 
+    def has_drawing?
+      @drawing.is_a? Drawing
+    end
+
+    # The relationship required by this object
+    # @return [Relationship]
+    def relationship
+      return unless has_drawing?
+      Relationship.new(DRAWING_R, "../#{drawing.pn}") 
+    end
+
+    # returns the index of the worksheet releationship that defines this drawing.
+    # @return [Integer]
+    def index
+       worksheet.relationships.index{ |r| r.Type == DRAWING_R } +1 
+    end
+
+    # Serialize the drawing for the worksheet
+    # @param [String] str
+    def to_xml_string(str = '')
+      return unless has_drawing? 
+      str << "<drawing r:id='rId#{index}'/>"
+    end
+  end
+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

@@ -1,16 +1,10 @@
 # encoding: UTF-8
+require 'htmlentities'
 require 'axlsx/version.rb'
 
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
 require 'axlsx/util/validators.rb'
-require 'axlsx/util/storage.rb'
-
-#not even close to being ready but it does not break anything so it stays for now.
-# needs a full re-write to use agile-encryption properly
-require 'axlsx/util/cbf.rb'
-require 'axlsx/util/ms_off_crypto.rb'
-
 
 # to be included with parsable intitites.
 #require 'axlsx/util/parser.rb'
@@ -43,25 +37,44 @@ 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
-  def self.cell_range(items)
-    return "" unless items.first.is_a? Cell
-    ref = "'#{items.first.row.worksheet.name}'!" +
-      "#{items.first.r_abs}"
-    ref += ":#{items.last.r_abs}" if items.size > 1
-    ref
+  def self.cell_range(cells, absolute=true)
+    return "" unless cells.first.is_a? Cell
+    sort_cells(cells)
+    reference = "#{cells.first.reference(absolute)}:#{cells.last.reference(absolute)}"
+    absolute ? "'#{cells.first.row.worksheet.name}'!#{reference}" : reference
   end
 
+  # sorts the array of cells provided to start from the minimum x,y to
+  # the maximum x.y#
+  # @param [Array] cells
+  # @return [Array]
+  def self.sort_cells(cells)
+    cells.sort { |x, y| [x.index, x.row.index] <=> [y.index, y.row.index] }
+  end
+
+  #global reference html entity encoding
+  # @return [HtmlEntities]
+  def self.coder
+    @@coder ||= ::HTMLEntities.new
+  end
+  
+  # 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
-
     [v[:i]-1, ((name[/[1-9][0-9]*/]).to_i)-1]
-
   end
 
   # converts the column index into alphabetical values.
@@ -84,4 +97,13 @@ module Axlsx
     Axlsx::col_ref(c_index).to_s << (r_index+1).to_s
   end
 
+  # performs the increadible feat of changing snake_case to CamelCase
+  # @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
+
 end

data/test/content_type/tc_content_type.rb

@@ -9,12 +9,7 @@ class TestContentType < Test::Unit::TestCase
 
   def test_valid_document
     schema = Nokogiri::XML::Schema(File.open(Axlsx::CONTENT_TYPES_XSD))
-    errors = []
-    schema.validate(@doc).each do |error|
-      puts error.message
-      errors << error
-    end
-    assert_equal(errors.size, 0, "[Content Types].xml Invalid" + errors.map{ |e| e.message }.to_s)
+    assert(schema.validate(@doc).map{ |e| puts e.message; e.message }.empty?)
   end
 
   def test_pre_built_types

data/test/doc_props/tc_app.rb

@@ -1,9 +1,39 @@
 require 'tc_helper.rb'
 
 class TestApp < Test::Unit::TestCase
+  def setup
+    options = {
+      :'Template' => 'Foo.xlt',
+      :'Manager' => 'Penny',
+      :'Company' => "Bob's Repair",
+      :'Pages' => 1,
+      :'Words' => 2,
+      :'Characters' => 7,
+      :'PresentationFormat' => 'any',
+      :'Lines' => 1,
+      :'Paragraphs' => 1,
+      :'Slides' => 4,
+      :'Notes' => 1,
+      :'TotalTime' => 2,
+      :'HidddenSlides' => 3,
+      :'MMClips' => 10,
+      :'ScaleCrop' => true,
+      :'LinksUpToDate' => true,
+      :'CharactersWithSpaces' => 9,
+      :'SharedDoc' => false,
+      :'HyperlinkBase' => 'foo',
+      :'HyperlInksChanged' => false, 
+      :'Application' => 'axlsx',
+      :'AppVersion' => '1.1.5',
+      :'DocSecurity' => 0
+      }
+
+    @app = Axlsx::App.new options
+
+  end
   def test_valid_document
     schema = Nokogiri::XML::Schema(File.open(Axlsx::APP_XSD))
-    doc = Nokogiri::XML(Axlsx::App.new.to_xml_string)
+    doc = Nokogiri::XML(@app.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|
       errors << error

data/test/doc_props/tc_core.rb

@@ -4,6 +4,8 @@ class TestCore < Test::Unit::TestCase
 
   def setup
     @core = Axlsx::Core.new
+    # could still see some false positives if the second changes between the next two calls
+    @time = Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
     @doc = Nokogiri::XML(@core.to_xml_string)
   end
 
@@ -18,7 +20,7 @@ class TestCore < Test::Unit::TestCase
   end
 
   def test_populates_created
-    assert_equal(@doc.xpath('//dcterms:created').text, Time.now.strftime('%Y-%m-%dT%H:%M:%S'), "dcterms:created incorrect")
+    assert_equal(@doc.xpath('//dcterms:created').text, @time, "dcterms:created incorrect")
   end
 
   def test_populates_default_name

data/test/drawing/tc_axis.rb

@@ -2,8 +2,10 @@ require 'tc_helper.rb'
 
 class TestAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::Axis.new 12345, 54321
+    
+    @axis = Axlsx::Axis.new 12345, 54321, :gridlines => false, :title => 'Foo'
   end
+
   def teardown
   end
 
@@ -13,7 +15,30 @@ class TestAxis < Test::Unit::TestCase
     assert_equal(@axis.tickLblPos, :nextTo, "tick label position default incorrect")
     assert_equal(@axis.crosses, :autoZero, "tick label position default incorrect")
     assert(@axis.scaling.is_a?(Axlsx::Scaling) && @axis.scaling.orientation == :minMax, "scaling default incorrect")
-    assert_raise(ArgumentError) { Axlsx::Axis.new -1234, 'abcd' }
+    assert_raise(ArgumentError) { Axlsx::Axis.new( -1234, 'abcd') }
+    assert_equal('Foo', @axis.title.text)
+  end
+
+  def test_color
+    @axis.color = "00FF00"
+    str  = '<?xml version="1.0" encoding="UTF-8"?>'
+    str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '">'
+    doc = Nokogiri::XML(@axis.to_xml_string(str)) 
+    assert(doc.xpath("//a:srgbClr[@val='00FF00']"))
+  end
+
+  def test_cell_based_axis_title
+    p = Axlsx::Package.new
+    p.workbook.add_worksheet(:name=>'foosheet') do |sheet|
+      sheet.add_row ['battle victories']
+      sheet.add_row ['bird', 1, 2, 1]
+      sheet.add_row ['cat', 7, 9, 10]
+      sheet.add_chart(Axlsx::Line3DChart) do |chart|
+        chart.add_series :data => sheet['B2:D2'], :labels => sheet['B1']
+        chart.valAxis.title = sheet['A1']
+        assert_equal('battle victories', chart.valAxis.title.text)  
+      end
+    end
   end
 
   def test_axis_position
@@ -48,5 +73,15 @@ class TestAxis < Test::Unit::TestCase
     assert_raise(ArgumentError, "requires valid gridlines") { @axis.gridlines = 'alice' }
     assert_nothing_raised("accepts valid crosses") { @axis.gridlines = false }
   end
-
+  
+  def test_to_xml_string
+    str  = '<?xml version="1.0" encoding="UTF-8"?>'
+    str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '">'
+    doc = Nokogiri::XML(@axis.to_xml_string(str)) 
+    assert(doc.xpath('//a:noFill'))
+    assert(doc.xpath("//c:crosses[@val='#{@axis.crosses.to_s}']"))
+    assert(doc.xpath("//c:crossAx[@val='#{@axis.crossAx.to_s}']"))
+    assert(doc.xpath("//a:bodyPr[@rot='#{@axis.label_rotation.to_s}']"))
+    assert(doc.xpath("//a:t[text()='Foo']"))
+  end
 end

data/test/drawing/tc_bar_3D_chart.rb

@@ -15,15 +15,15 @@ class TestBar3DChart < Test::Unit::TestCase
   def test_initialization
     assert_equal(@chart.grouping, :clustered, "grouping defualt incorrect")
     assert_equal(@chart.series_type, Axlsx::BarSeries, "series type incorrect")
-    assert_equal(@chart.barDir, :bar, " bar direction incorrect")
-    assert(@chart.catAxis.is_a?(Axlsx::CatAxis), "category axis not created")
-    assert(@chart.valAxis.is_a?(Axlsx::ValAxis), "value access not created")
+    assert_equal(@chart.bar_dir, :bar, " bar direction incorrect")
+    assert(@chart.cat_axis.is_a?(Axlsx::CatAxis), "category axis not created")
+    assert(@chart.val_axis.is_a?(Axlsx::ValAxis), "value access not created")
   end
 
   def test_bar_direction
-    assert_raise(ArgumentError, "require valid bar direction") { @chart.barDir = :left }
-    assert_nothing_raised("allow valid bar direction") { @chart.barDir = :col }
-    assert(@chart.barDir == :col)
+    assert_raise(ArgumentError, "require valid bar direction") { @chart.bar_dir = :left }
+    assert_nothing_raised("allow valid bar direction") { @chart.bar_dir = :col }
+    assert(@chart.bar_dir == :col)
   end
 
  def test_grouping
@@ -34,15 +34,15 @@ class TestBar3DChart < Test::Unit::TestCase
 
 
  def test_gapWidth
-   assert_raise(ArgumentError, "require valid gap width") { @chart.gapWidth = 200 }
-   assert_nothing_raised("allow valid gapWidth") { @chart.gapWidth = "200%" }
-   assert(@chart.gapWidth == "200%")
+   assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 200 }
+   assert_nothing_raised("allow valid gapWidth") { @chart.gap_width = "200%" }
+   assert(@chart.gap_width == "200%")
  end
 
  def test_gapDepth
-   assert_raise(ArgumentError, "require valid gapDepth") { @chart.gapDepth = 200 }
-   assert_nothing_raised("allow valid gapDepth") { @chart.gapDepth = "200%" }
-   assert(@chart.gapDepth == "200%")
+   assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = 200 }
+   assert_nothing_raised("allow valid gap_depth") { @chart.gap_depth = "200%" }
+   assert(@chart.gap_depth == "200%")
  end
 
   def test_shape

data/test/drawing/tc_bar_series.rb

@@ -5,7 +5,7 @@ class TestBarSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    @chart = @ws.drawing.add_chart Axlsx::Bar3DChart, :title => "fishery"
+    @chart = @ws.add_chart Axlsx::Bar3DChart, :title => "fishery"
     @series = @chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :colors => ['FF0000', '00FF00', '0000FF'], :shape => :cone
   end
 
@@ -33,6 +33,5 @@ class TestBarSeries < Test::Unit::TestCase
       assert_equal(doc.xpath("//c:dPt/c:idx[@val='#{index}']").size,1)
       assert_equal(doc.xpath("//c:dPt/c:spPr/a:solidFill/a:srgbClr[@val='#{@series.colors[index]}']").size,1)
     end
-    assert_equal(doc.xpath("//c:shape[@val='#{@series.shape.to_s}']").size, 1)
   end
 end

data/test/drawing/tc_cat_axis.rb

@@ -10,7 +10,7 @@ class TestCatAxis < Test::Unit::TestCase
   def test_initialization
     assert_equal(@axis.auto, 1, "axis auto default incorrect")
     assert_equal(@axis.lblAlgn, :ctr, "label align default incorrect")
-    assert_equal(@axis.lblOffset, "100%", "label offset default incorrect")
+    assert_equal(@axis.lblOffset, "100", "label offset default incorrect")
   end
 
   def test_auto
@@ -24,8 +24,8 @@ class TestCatAxis < Test::Unit::TestCase
   end
 
   def test_lblOffset
-    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 100 }
-    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20%" }
+    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 'foo' }
+    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20" }
   end
 
 end

data/test/drawing/tc_chart.rb

@@ -22,11 +22,16 @@ class TestChart < Test::Unit::TestCase
     @chart.title.text = 'wowzer'
     assert_equal(@chart.title.text, "wowzer", "the title text via a string")
     assert_equal(@chart.title.cell, nil, "the title cell is nil as we set the title with text.")
-    @chart.title.cell = @row.cells.first
+    @chart.title = @row.cells.first
     assert_equal(@chart.title.text, "one", "the title text was set via cell reference")
     assert_equal(@chart.title.cell, @row.cells.first)
   end
 
+  def test_to_from_marker_access
+    assert(@chart.to.is_a?(Axlsx::Marker))
+    assert(@chart.from.is_a?(Axlsx::Marker))
+  end
+
   def test_style
     assert_raise(ArgumentError) { @chart.style = 49 }
     assert_nothing_raised { @chart.style = 2 }
@@ -34,16 +39,29 @@ class TestChart < Test::Unit::TestCase
   end
 
   def test_start_at
-    @chart.start_at 15,25
+    @chart.start_at 15, 25
     assert_equal(@chart.graphic_frame.anchor.from.col, 15)
     assert_equal(@chart.graphic_frame.anchor.from.row, 25)
-
+    @chart.start_at @row.cells.first
+    assert_equal(@chart.graphic_frame.anchor.from.col, 0)
+    assert_equal(@chart.graphic_frame.anchor.from.row, 0)
+    @chart.start_at [5,6]
+    assert_equal(@chart.graphic_frame.anchor.from.col, 5)
+    assert_equal(@chart.graphic_frame.anchor.from.row, 6)
+    
   end
 
   def test_end_at
     @chart.end_at 25, 90
     assert_equal(@chart.graphic_frame.anchor.to.col, 25)
     assert_equal(@chart.graphic_frame.anchor.to.row, 90)
+    @chart.end_at @row.cells.last
+    assert_equal(@chart.graphic_frame.anchor.to.col, 2)
+    assert_equal(@chart.graphic_frame.anchor.to.row, 0)
+    @chart.end_at [10,11]
+    assert_equal(@chart.graphic_frame.anchor.to.col, 10)
+    assert_equal(@chart.graphic_frame.anchor.to.row, 11)
+  
   end
 
   def test_add_series
@@ -55,15 +73,17 @@ class TestChart < Test::Unit::TestCase
   def test_pn
     assert_equal(@chart.pn, "charts/chart1.xml")
   end
-
+  
+  def test_d_lbls
+    assert_equal(nil, @chart.instance_values[:d_lbls])
+    @chart.d_lbls.d_lbl_pos = :t
+    assert(@chart.d_lbls.is_a?(Axlsx::DLbls), 'DLbls instantiated on access')
+  end
+  
   def test_to_xml_string
     schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
     doc = Nokogiri::XML(@chart.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
+    errors = schema.validate(doc).map { |error| puts error.message; error }
     assert(errors.empty?, "error free validation")
   end