axlsx 1.3.6 → 2.0.1

data/lib/axlsx/drawing/marker.rb

@@ -43,11 +43,14 @@ module Axlsx
     def rowOff=(v) Axlsx::validate_int v; @rowOff = v end
 
     # shortcut to set the column, row position for this marker
-    # @param col the column for the marker
-    # @param row the row of the marker
-    def coord(col, row)
-      self.col = col
-      self.row = row
+    # @param col the column for the marker, a Cell object or a string reference like "B7"
+    # or an Array.
+    # @param row the row of the marker. This is ignored if the col parameter is a Cell or
+    # String or Array.
+    def coord(col, row=0)
+      coordinates = parse_coord_args(col, row)
+      self.col = coordinates[0]
+      self.row = coordinates[1]
     end
 
     # Serializes the object
@@ -58,6 +61,23 @@ module Axlsx
         str << '<xdr:' << k.to_s << '>' << self.send(k).to_s << '</xdr:' << k.to_s << '>'
       end
     end
+    private
+
+    # handles multiple inputs for setting the position of a marker
+    # @see Chart#start_at
+    def parse_coord_args(x, y=0)
+      if x.is_a?(String)
+        x, y = *Axlsx::name_to_indices(x)
+      end
+      if x.is_a?(Cell)
+        x, y = *x.pos
+      end
+      if x.is_a?(Array)
+        x, y = *x
+      end
+      [x, y]
+    end
+
 
   end
 

data/lib/axlsx/drawing/one_cell_anchor.rb

@@ -48,6 +48,15 @@ module Axlsx
     # @return [Integer]
     attr_reader :height
 
+    # sets the starting position for the anchor.
+    # You can provide a String like "A1", an array like [0,0] or a cell object for the x parameter.
+    # We just 'figure it out' for you.
+    # @param [Array, String, Cell, Integer] x Accepts many inputs for defining the starting position of the cell.
+    # @param [Integer] y When x is an integer, this value is used for the row index at which the anchor starts.
+    def start_at(x, y=0)
+      from.coord x, y
+    end
+    #
     # @see height
     def height=(v) Axlsx::validate_unsigned_int(v); @height = v; end
 

data/lib/axlsx/drawing/pic.rb

@@ -37,7 +37,7 @@ module Axlsx
     attr_reader :descr
 
     # The path to the image you want to include
-    # Only local images are supported at this time and only jpg support
+    # Only local images are supported at this time.
     # @return [String]
     attr_reader :image_src
 
@@ -67,7 +67,7 @@ module Axlsx
 
     def image_src=(v)
       Axlsx::validate_string(v)
-      RestrictionValidator.validate 'Pic.image_src', ALLOWED_EXTENSIONS, File.extname(v).delete('.')
+      RestrictionValidator.validate 'Pic.image_src', ALLOWED_EXTENSIONS, File.extname(v.downcase).delete('.')
       raise ArgumentError, "File does not exist" unless File.exist?(v)
       @image_src = v
     end
@@ -89,7 +89,8 @@ module Axlsx
     # @return [String]
     def extname
       File.extname(image_src).delete('.') unless image_src.nil?
-    end 
+    end
+
     # The index of this image in the workbooks images collections
     # @return [Index]
     def index
@@ -102,15 +103,10 @@ module Axlsx
       "#{IMAGE_PN % [(index+1), extname]}"
     end
 
-    # The relational id withing the drawing's relationships
-    def id
-      @anchor.drawing.charts.size + @anchor.drawing.images.index(self) + 1
-    end
-
-    # Returns a relationship object for this object
-    # @return Axlsx::Relationship
+    # The relationship object for this pic.
+    # @return [Relationship]
     def relationship
-      Relationship.new(IMAGE_R, "../#{pn}")
+      Relationship.new(self, IMAGE_R, "../#{pn}")
     end
 
     # providing access to the anchor's width attribute
@@ -148,9 +144,8 @@ module Axlsx
     # @param [Integer] x The column
     # @param [Integer] y The row
     # @return [Marker]
-    def start_at(x, y)
-      @anchor.from.col = x
-      @anchor.from.row = y
+    def start_at(x, y=nil)
+      @anchor.start_at x, y
       @anchor.from
     end
 
@@ -158,10 +153,9 @@ module Axlsx
     # @param [Integer] x The column
     # @param [Integer] y The row
     # @return [Marker]
-    def end_at(x, y)
+    def end_at(x, y=nil)
       use_two_cell_anchor unless @anchor.is_a?(TwoCellAnchor)
-      @anchor.to.col = x
-      @anchor.to.row = y
+      @anchor.end_at x, y
       @anchor.to
     end
 
@@ -177,7 +171,7 @@ module Axlsx
       picture_locking.to_xml_string(str)
       str << '</xdr:cNvPicPr></xdr:nvPicPr>'
       str << '<xdr:blipFill>'
-      str << '<a:blip xmlns:r ="' << XML_NS_R << '" r:embed="rId' << id.to_s <<  '"/>'
+      str << '<a:blip xmlns:r ="' << XML_NS_R << '" r:embed="' << relationship.Id <<  '"/>'
       str << '<a:stretch><a:fillRect/></a:stretch></xdr:blipFill><xdr:spPr>'
       str << '<a:xfrm><a:off x="0" y="0"/><a:ext cx="2336800" cy="2161540"/></a:xfrm>'
       str << '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr></xdr:pic>'
@@ -189,22 +183,22 @@ module Axlsx
     # Changes the anchor to a one cell anchor.
     def use_one_cell_anchor
       return if @anchor.is_a?(OneCellAnchor)
-      swap_anchor(OneCellAnchor.new(@anchor.drawing, :from => @anchor.from))
+      new_anchor = OneCellAnchor.new(@anchor.drawing, :start_at => [@anchor.from.col, @anchor.from.row])
+      swap_anchor(new_anchor)
     end
 
     #changes the anchor type to a two cell anchor
     def use_two_cell_anchor
       return if @anchor.is_a?(TwoCellAnchor)
-      swap_anchor(TwoCellAnchor.new(@anchor.drawing)).tap do |new_anchor|
-        new_anchor.from.col = @anchor.from.col
-        new_anchor.from.row = @anchor.from.row
-      end
+      new_anchor = TwoCellAnchor.new(@anchor.drawing, :start_at => [@anchor.from.col, @anchor.from.row])
+      swap_anchor(new_anchor)
     end
 
     # refactoring of swapping code, law of demeter be damned!
     def swap_anchor(new_anchor)
       new_anchor.drawing.anchors.delete(new_anchor)
       @anchor.drawing.anchors[@anchor.drawing.anchors.index(@anchor)] = new_anchor
+      new_anchor.instance_variable_set "@object", @anchor.object
       @anchor = new_anchor
     end
   end

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -5,6 +5,8 @@ module Axlsx
   # @see Worksheet#add_chart
   class TwoCellAnchor
 
+    include Axlsx::OptionsParser
+
     # A marker that defines the from cell anchor. The default from column and row are 0 and 0 respectively
     # @return [Marker]
     attr_reader :from
@@ -34,22 +36,23 @@ module Axlsx
       @drawing = drawing
       drawing.anchors << self
       @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
+      parse_options options
     end
 
     # sets the col, row attributes for the from marker.
     # @note The recommended way to set the start position for graphical
     # objects is directly thru the object. 
     # @see Chart#start_at
-    def start_at(x, y)
-      set_marker_coords(x, y, from)
+    def start_at(x, y=nil)
+      from.coord x, y
     end
 
     # sets the col, row attributes for the to marker
     # @note the recommended way to set the to position for graphical
     # objects is directly thru the object
     # @see Char#end_at
-    def end_at(x, y)
-      set_marker_coords(x, y, to) 
+    def end_at(x, y=nil)
+      to.coord x, y
     end
 
     # Creates a graphic frame and chart object associated with this anchor
@@ -85,28 +88,5 @@ module Axlsx
       str << '<xdr:clientData/>'
       str << '</xdr:twoCellAnchor>'
     end
-    private 
-
-    # parses coordinates and sets up a marker's row/col propery
-    def set_marker_coords(x, y, marker)
-      marker.col, marker.row = *parse_coord_args(x, y)
-    end
-
-    # handles multiple inputs for setting the position of a marker
-    # @see Chart#start_at
-    def parse_coord_args(x, y=0)
-      if x.is_a?(String)
-        x, y = *Axlsx::name_to_indices(x)
-      end
-      if x.is_a?(Cell)
-        x, y = *x.pos
-      end
-      if x.is_a?(Array)
-        x, y = *x
-      end
-      [x, y]
-    end
-
-
   end
 end

data/lib/axlsx/package.rb

@@ -17,12 +17,14 @@ module Axlsx
     #
     # @param [Hash] options A hash that you can use to specify the author and workbook for this package.
     # @option options [String] :author The author of the document
+    # @option options [Time] :created_at Timestamp in the document properties (defaults to current time).
     # @option options [Boolean] :use_shared_strings This is passed to the workbook to specify that shared strings should be used when serializing the package.
     # @example Package.new :author => 'you!', :workbook => Workbook.new
     def initialize(options={})
       @workbook = nil
       @core, @app  =  Core.new, App.new
       @core.creator = options[:author] || @core.creator
+      @core.created = options[:created_at]
       parse_options options
       yield self if block_given?
     end
@@ -35,12 +37,6 @@ module Axlsx
     end
 
 
-    # Shortcut to specify that the workbook should use shared strings
-    # @see Workbook#use_shared_strings
-    def use_shared_strings=(v)
-      Axlsx::validate_boolean(v);
-      workbook.use_shared_strings = v
-    end
 
     # Shortcut to determine if the workbook is configured to use shared strings
     # @see Workbook#use_shared_strings
@@ -48,6 +44,12 @@ module Axlsx
       workbook.use_shared_strings
     end
 
+    # Shortcut to specify that the workbook should use shared strings
+    # @see Workbook#use_shared_strings
+    def use_shared_strings=(v)
+      Axlsx::validate_boolean(v);
+      workbook.use_shared_strings = v
+    end
     # The workbook this package will serialize or validate.
     # @return [Workbook] If no workbook instance has been assigned with this package a new Workbook instance is returned.
     # @raise ArgumentError if workbook parameter is not a Workbook instance.
@@ -68,7 +70,7 @@ module Axlsx
 
     #def self.parse(input, confirm_valid = false)
     #  p = Package.new
-    #  z = Zip::ZipFile.open(input)
+    #  z = Zip::File.open(input)
     #  p.workbook = Workbook.parse z.get_entry(WORKBOOK_PN)
     #  p
     #end
@@ -98,7 +100,8 @@ module Axlsx
     #   File.open('example_streamed.xlsx', 'w') { |f| f.write(s.read) }
     def serialize(output, confirm_valid=false)
       return false unless !confirm_valid || self.validate.empty?
-      Zip::ZipOutputStream.open(output) do |zip|
+      Relationship.clear_cached_instances
+      Zip::OutputStream.open(output) do |zip|
         write_parts(zip)
       end
       true
@@ -110,7 +113,8 @@ module Axlsx
     # @return [StringIO|Boolean] False if confirm_valid and validation errors exist. rewound string IO if not.
     def to_stream(confirm_valid=false)
       return false unless !confirm_valid || self.validate.empty?
-      zip = write_parts(Zip::ZipOutputStream.new("streamed", true))
+      Relationship.clear_cached_instances
+      zip = write_parts(Zip::OutputStream.new("streamed", true))
       stream = zip.close_buffer
       stream.rewind
       stream
@@ -150,18 +154,18 @@ module Axlsx
     private
 
     # Writes the package parts to a zip archive.
-    # @param [Zip::ZipOutputStream] zip
-    # @return [Zip::ZipOutputStream]
+    # @param [Zip::OutputStream] zip
+    # @return [Zip::OutputStream]
     def write_parts(zip)
       p = parts
       p.each do |part|
         unless part[:doc].nil?
-          zip.put_next_entry(part[:entry])
+          zip.put_next_entry(zip_entry_for_part(part))
           entry = ['1.9.2', '1.9.3'].include?(RUBY_VERSION) ? part[:doc].force_encoding('BINARY') : part[:doc]
           zip.puts(entry)
         end
         unless part[:path].nil?
-          zip.put_next_entry(part[:entry]);
+          zip.put_next_entry(zip_entry_for_part(part))
           # binread for 1.9.3
           zip.write IO.respond_to?(:binread) ? IO.binread(part[:path]) : IO.read(part[:path])
         end
@@ -169,6 +173,22 @@ module Axlsx
       zip
     end
 
+    # Generate a Entry for the given package part.
+    # The important part here is to explicitly set the timestamp for the zip entry: Serializing axlsx packages
+    # with identical contents should result in identical zip files – however, the timestamp of a zip entry
+    # defaults to the time of serialization and therefore the zip file contents would be different every time
+    # the package is serialized.
+    #
+    # Note: {Core#created} also defaults to the current time – so to generate identical axlsx packages you have
+    # to set this explicitly, too (eg. with `Package.new(created_at: Time.local(2013, 1, 1))`).
+    #
+    # @param part A hash describing a part of this pacakge (see {#parts})
+    # @return [Zip::Entry]
+    def zip_entry_for_part(part)
+      timestamp = Zip::DOSTime.at(@core.created.to_i)
+      Zip::Entry.new("", part[:entry], "", "", 0, 0, Zip::Entry::DEFLATED, 0, timestamp)
+    end
+
     # The parts of a package
     # @return [Array] An array of hashes that define the entry, document and schema for each part of the package.
     # @private
@@ -321,9 +341,9 @@ module Axlsx
     # @private
     def relationships
       rels = Axlsx::Relationships.new
-      rels << Relationship.new(WORKBOOK_R, WORKBOOK_PN)
-      rels << Relationship.new(CORE_R, CORE_PN)
-      rels << Relationship.new(APP_R, APP_PN)
+      rels << Relationship.new(self, WORKBOOK_R, WORKBOOK_PN)
+      rels << Relationship.new(self, CORE_R, CORE_PN)
+      rels << Relationship.new(self, APP_R, APP_PN)
       rels.lock
       rels
     end

data/lib/axlsx/rels/relationship.rb

@@ -3,7 +3,43 @@ module Axlsx
   # A relationship defines a reference between package parts.
   # @note Packages automatically manage relationships.
   class Relationship
+    
+    class << self
+      # Keeps track of all instances of this class.
+      # @return [Array]
+      def instances
+        @instances ||= []
+      end
+      
+      # Clear cached instances.
+      # 
+      # This should be called before serializing a package (see {Package#serialize} and
+      # {Package#to_stream}) to make sure that serialization is idempotent (i.e. 
+      # Relationship instances are generated with the same IDs everytime the package
+      # is serialized).
+      # 
+      # Also, calling this avoids memory leaks (cached instances lingering around 
+      # forever). 
+      def clear_cached_instances
+        @instances = []
+      end
+      
+      # Generate and return a unique id (eg. `rId123`) Used for setting {#Id}. 
+      #
+      # The generated id depends on the number of cached instances, so using
+      # {clear_cached_instances} will automatically reset the generated ids, too.
+      # @return [String]
+      def next_free_id
+        "rId#{@instances.size + 1}"
+      end
+    end
 
+    # The id of the relationship (eg. "rId123"). Most instances get their own unique id. 
+    # However, some instances need to share the same id – see {#should_use_same_id_as?}
+    # for details.
+    # @return [String]
+    attr_reader :Id
+    
     # The location of the relationship target
     # @return [String]
     attr_reader :Target
@@ -30,14 +66,26 @@ module Axlsx
     # Target mode must be :external for now.
     attr_reader :TargetMode
 
-    # creates a new relationship
+    # The source object the relations belongs to (e.g. a hyperlink, drawing, ...). Needed when
+    # looking up the relationship for a specific object (see {Relationships#for}).
+    attr_reader :source_obj
+    
+    # Initializes a new relationship. 
+    # @param [Object] source_obj see {#source_obj}
     # @param [String] type The type of the relationship
     # @param [String] target The target for the relationship
     # @option [Symbol] :target_mode only accepts :external.
-    def initialize(type, target, options={})
+    def initialize(source_obj, type, target, options={})
+      @source_obj = source_obj
       self.Target=target
       self.Type=type
-      self.TargetMode = options.delete(:target_mode) if options[:target_mode]
+      self.TargetMode = options[:target_mode] if options[:target_mode]
+      @Id = if (existing = self.class.instances.find{ |i| should_use_same_id_as?(i) })
+        existing.Id
+      else
+        self.class.next_free_id
+      end
+      self.class.instances << self
     end
 
     # @see Target
@@ -50,15 +98,32 @@ module Axlsx
 
     # serialize relationship
     # @param [String] str
-    # @param [Integer] rId the id for this relationship
     # @return [String]
-    def to_xml_string(rId, str = '')
-      h = self.instance_values
-      h[:Id] = 'rId' << rId.to_s
+    def to_xml_string(str = '')
+      h = self.instance_values.reject{|k, _| k == "source_obj"}
       str << '<Relationship '
       str << h.map { |key, value| '' << key.to_s << '="' << Axlsx::coder.encode(value.to_s) << '"'}.join(' ')
       str << '/>'
     end
-
+    
+    # Whether this relationship should use the same id as `other`.
+    #
+    # Instances designating the same relationship need to use the same id. We can not simply
+    # compare the {#Target} attribute, though: `foo/bar.xml`, `../foo/bar.xml`, 
+    # `../../foo/bar.xml` etc. are all different but probably mean the same file (this 
+    # is especially an issue for relationships in the context of pivot tables). So lets
+    # just ignore this attribute for now (except when {#TargetMode} is set to `:External` –
+    # then {#Target} will be an absolute URL and thus can safely be compared).
+    #
+    # @todo Implement comparison of {#Target} based on normalized path names.
+    # @param other [Relationship]
+    def should_use_same_id_as?(other)
+      result = self.source_obj == other.source_obj && self.Type == other.Type && self.TargetMode == other.TargetMode
+      if self.TargetMode == :External
+        result &&= self.Target == other.Target
+      end
+      result
+    end
+    
   end
 end

data/lib/axlsx/rels/relationships.rb

@@ -11,10 +11,17 @@ require 'axlsx/rels/relationship.rb'
       super Relationship
     end
     
+    # The relationship instance for the given source object, or nil if none exists.
+    # @see Relationship#source_obj
+    # @return [Relationship]
+    def for(source_obj)
+      @list.find{ |rel| rel.source_obj == source_obj }
+    end
+    
     def to_xml_string(str = '')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
       str << '<Relationships xmlns="' << RELS_R << '">'
-      each_with_index { |rel, index| rel.to_xml_string(index+1, str) }
+      each{ |rel| rel.to_xml_string(str) }
       str << '</Relationships>'
     end
 

data/lib/axlsx/stylesheet/color.rb

@@ -51,7 +51,7 @@ module Axlsx
     # @see color
     def rgb=(v)
       Axlsx::validate_string(v)
-      v.upcase!
+      v = v.upcase
       v = v * 3 if v.size == 2
       v = v.rjust(8, 'FF')
       raise ArgumentError, "Invalid color rgb value: #{v}." unless v.match(/[0-9A-F]{8}/)

data/lib/axlsx/stylesheet/num_fmt.rb

@@ -10,7 +10,7 @@ module Axlsx
     # Creates a new NumFmt object
     # @param [Hash] options Options for the number format object
     # @option [Integer] numFmtId The predefined format id or new format id for this format
-    # @option [String] fomratCode The format code for this number format
+    # @option [String] formatCode The format code for this number format
     def initialize(options={})
       @numFmtId = 0
       @formatCode = ""
@@ -23,7 +23,7 @@ module Axlsx
     # @see http://support.microsoft.com/kb/264372
     attr_reader :formatCode
 
-    # @return [Integer] An unsinged integer referencing a standard or custom number format.
+    # @return [Integer] An unsigned integer referencing a standard or custom number format.
     # @note
     #  These are the known formats I can dig up. The constant NUM_FMT_PERCENT is 9, and uses the default % formatting. Axlsx also defines a few formats for date and time that are commonly used in asia as NUM_FMT_YYYYMMDD and NUM_FRM_YYYYMMDDHHMMSS.
     #   1 0

data/lib/axlsx/stylesheet/styles.rb

@@ -183,7 +183,7 @@ module Axlsx
     #                                 :border=>Axlsx::STYLE_THIN_BORDER)
     #
     #   # build your rows
-    #   ws.add_row ["Genreated At:", Time.now], :styles=>[nil, date_time]
+    #   ws.add_row ["Generated At:", Time.now], :styles=>[nil, date_time]
     #   ws.add_row ["Previous Year Quarterly Profits (JPY)"], :style=>title
     #   ws.add_row ["Quarter", "Profit", "% of Total"], :style=>title
     #   ws.add_row ["Q1", 4000, 40], :style=>[title, currency, percent]
@@ -296,9 +296,11 @@ module Axlsx
     def parse_fill_options(options={})
       return unless options[:bg_color]
       color = Color.new(:rgb=>options[:bg_color])
-      pattern = PatternFill.new(:patternType =>:solid, :fgColor=>color)
+      dxf = options[:type] == :dxf
+      color_key = dxf ? :bgColor : :fgColor
+      pattern = PatternFill.new(:patternType =>:solid, color_key=>color)
       fill = Fill.new(pattern)
-      options[:type] == :dxf ? fill : fills << fill
+      dxf ? fill : fills << fill
     end
 
     # parses Style#add_style options for borders.

data/lib/axlsx/util/serialized_attributes.rb

@@ -40,18 +40,21 @@ module Axlsx
     # @param [Hash] additional_attributes An option key value hash for
     # defining values that are not serializable attributes list.
     def serialized_attributes(str = '', additional_attributes = {})
-      key_value_pairs = instance_values
-      key_value_pairs.each do |key, value|
-        key_value_pairs.delete(key) if value == nil
-        key_value_pairs.delete(key) unless self.class.xml_attributes.include?(key.to_sym)
-      end
-      key_value_pairs.merge! additional_attributes
-      key_value_pairs.each do |key, value|
-        str << "#{Axlsx.camel(key, false)}=\"#{value}\" "
+      attributes = declared_attributes.merge! additional_attributes
+      attributes.each do |key, value|
+        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(value, false)}\" "
       end
       str
     end
 
+    # A hash of instance variables that have been declared with
+    # seraialized_attributes and are not nil.
+    # This requires ruby 1.9.3 or higher
+    def declared_attributes
+      instance_values.select do |key, value|
+        value != nil && self.class.xml_attributes.include?(key.to_sym)
+      end
+    end
 
     # serialized instance values at text nodes on a camelized element of the
     # attribute name. You may pass in a block for evaluation against non nil

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,21 +1,9 @@
 # encoding: UTF-8
 module Axlsx
+
   # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.
   # @private
   class SimpleTypedList
-    # The class constants of allowed types
-    # @return [Array]
-    attr_reader :allowed_types
-
-    # The index below which items cannot be removed
-    # @return [Integer]
-    attr_reader :locked_at
-
-    # The tag name to use when serializing this object
-    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
-    # @return [String]
-    attr_reader :serialize_as
-
     # Creats a new typed list
     # @param [Array, Class] type An array of Class objects or a single Class object
     # @param [String] serialize_as The tag name to use in serialization
@@ -33,6 +21,39 @@ module Axlsx
       @serialize_as = serialize_as
     end
 
+    # The class constants of allowed types
+    # @return [Array]
+    attr_reader :allowed_types
+
+    # The index below which items cannot be removed
+    # @return [Integer]
+    attr_reader :locked_at
+
+    # The tag name to use when serializing this object
+    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
+    # @return [String]
+    attr_reader :serialize_as
+
+    # Transposes the list (without blowing up like ruby does)
+    # any non populated cell in the matrix will be a nil value
+    def transpose
+      return @list.clone if @list.size == 0
+      row_count = @list.size
+      max_column_count = @list.map{|row| row.cells.size}.max
+      result = Array.new(max_column_count) { Array.new(row_count) }
+      # yes, I know it is silly, but that warning is really annoying
+      row_count.times do |row_index|
+         max_column_count.times do |column_index|
+          datum = if @list[row_index].cells.size >= max_column_count
+                    @list[row_index].cells[column_index]
+                  elsif block_given?
+                    yield(column_index, row_index)
+                  end
+          result[column_index][row_index] = datum
+        end
+      end
+      result
+    end
     # Lock this list at the current size
     # @return [self]
     def lock

data/lib/axlsx/util/validators.rb

@@ -290,4 +290,11 @@ module Axlsx
   def self.validate_split_state_type(v)
     RestrictionValidator.validate :split_state_type, [:frozen, :frozen_split, :split], v
   end
+
+  # Requires that the value is a valid "display blanks as" type.
+  # valid types must be one of gap, span, zero
+  # @param [Any] v The value validated
+  def self.validate_display_blanks_as(v)
+    RestrictionValidator.validate :display_blanks_as, [:gap, :span, :zero], v
+  end
 end

data/lib/axlsx/version.rb

@@ -1,5 +1,5 @@
 module Axlsx
 
   # The current version
-  VERSION = "1.3.6"
+  VERSION = "2.0.1"
 end

data/lib/axlsx/workbook/defined_name.rb

@@ -105,7 +105,7 @@ module Axlsx
     attr_reader :local_sheet_id
 
     # The local sheet index (0-based)
-    # @param [Integer] value the unsinged integer index of the sheet this defined_name applies to.
+    # @param [Integer] value the unsigned integer index of the sheet this defined_name applies to.
     def local_sheet_id=(value)
       Axlsx::validate_unsigned_int(value)
       @local_sheet_id = value