axlsx 1.2.0 → 2.0.0

data/lib/axlsx/package.rb

@@ -3,7 +3,7 @@ module Axlsx
   # Package is responsible for managing all the bits and peices that Open Office XML requires to make a valid
   # xlsx document including valdation and serialization.
   class Package
-
+    include Axlsx::OptionsParser
 
     # provides access to the app doc properties for this package
     # see App
@@ -17,15 +17,15 @@ 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
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
+      @core.created = options[:created_at]
+      parse_options options
       yield self if block_given?
     end
 
@@ -37,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
@@ -50,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.
@@ -100,6 +100,7 @@ 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?
+      Relationship.clear_cached_instances
       Zip::ZipOutputStream.open(output) do |zip|
         write_parts(zip)
       end
@@ -112,6 +113,7 @@ 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?
+      Relationship.clear_cached_instances
       zip = write_parts(Zip::ZipOutputStream.new("streamed", true))
       stream = zip.close_buffer
       stream.rewind
@@ -158,12 +160,12 @@ module Axlsx
       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
@@ -171,11 +173,27 @@ module Axlsx
       zip
     end
 
+    # Generate a ZipEntry 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::ZipEntry]
+    def zip_entry_for_part(part)
+      timestamp = Zip::DOSTime.at(@core.created.to_i)
+      Zip::ZipEntry.new("", part[:entry], "", "", 0, 0, Zip::ZipEntry::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
     def parts
-      @parts = [
+      parts = [
        {:entry => RELS_PN, :doc => relationships.to_xml_string, :schema => RELS_XSD},
        {:entry => "xl/#{STYLES_PN}", :doc => workbook.styles.to_xml_string, :schema => SML_XSD},
        {:entry => CORE_PN, :doc => @core.to_xml_string, :schema => CORE_XSD},
@@ -186,39 +204,45 @@ module Axlsx
       ]
 
       workbook.drawings.each do |drawing|
-        @parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships.to_xml_string, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{drawing.pn}", :doc => drawing.to_xml_string, :schema => DRAWING_XSD}
+        parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships.to_xml_string, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{drawing.pn}", :doc => drawing.to_xml_string, :schema => DRAWING_XSD}
       end
 
 
       workbook.tables.each do |table|
-        @parts << {:entry => "xl/#{table.pn}", :doc => table.to_xml_string, :schema => SML_XSD}
+        parts << {:entry => "xl/#{table.pn}", :doc => table.to_xml_string, :schema => SML_XSD}
+      end
+      workbook.pivot_tables.each do |pivot_table|
+        cache_definition = pivot_table.cache_definition
+        parts << {:entry => "xl/#{pivot_table.rels_pn}", :doc => pivot_table.relationships.to_xml_string, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{pivot_table.pn}", :doc => pivot_table.to_xml_string} #, :schema => SML_XSD}
+        parts << {:entry => "xl/#{cache_definition.pn}", :doc => cache_definition.to_xml_string} #, :schema => SML_XSD}
       end
 
       workbook.comments.each do|comment|
         if comment.size > 0
-          @parts << { :entry => "xl/#{comment.pn}", :doc => comment.to_xml_string, :schema => SML_XSD }
-          @parts << { :entry => "xl/#{comment.vml_drawing.pn}", :doc => comment.vml_drawing.to_xml_string, :schema => nil }
+          parts << { :entry => "xl/#{comment.pn}", :doc => comment.to_xml_string, :schema => SML_XSD }
+          parts << { :entry => "xl/#{comment.vml_drawing.pn}", :doc => comment.vml_drawing.to_xml_string, :schema => nil }
         end
       end
 
       workbook.charts.each do |chart|
-        @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
+        parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
       end
 
       workbook.images.each do |image|
-        @parts << {:entry => "xl/#{image.pn}", :path => image.image_src}
+        parts << {:entry => "xl/#{image.pn}", :path => image.image_src}
       end
 
       if use_shared_strings
-        @parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml_string, :schema => SML_XSD}
+        parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml_string, :schema => SML_XSD}
       end
 
       workbook.worksheets.each do |sheet|
-        @parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships.to_xml_string, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{sheet.pn}", :doc => sheet.to_xml_string, :schema => SML_XSD}
+        parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships.to_xml_string, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{sheet.pn}", :doc => sheet.to_xml_string, :schema => SML_XSD}
       end
-      @parts
+      parts
     end
 
     # Performs xsd validation for a signle document
@@ -242,7 +266,6 @@ module Axlsx
     # @private
     def content_types
       c_types = base_content_types
-
       workbook.drawings.each do |drawing|
         c_types << Axlsx::Override.new(:PartName => "/xl/#{drawing.pn}",
                                        :ContentType => DRAWING_CT)
@@ -258,6 +281,13 @@ module Axlsx
                                        :ContentType => TABLE_CT)
       end
 
+      workbook.pivot_tables.each do |pivot_table|
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{pivot_table.pn}",
+                                       :ContentType => PIVOT_TABLE_CT)
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{pivot_table.cache_definition.pn}",
+                                       :ContentType => PIVOT_TABLE_CACHE_DEFINITION_CT)
+      end
+
       workbook.comments.each do |comment|
         if comment.size > 0
         c_types << Axlsx::Override.new(:PartName => "/xl/#{comment.pn}",
@@ -311,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
@@ -12,6 +48,7 @@ module Axlsx
     # @note Supported types are defined as constants in Axlsx:
     # @see XML_NS_R
     # @see TABLE_R
+    # @see PIVOT_TABLE_R
     # @see WORKBOOK_R
     # @see WORKSHEET_R
     # @see APP_R
@@ -29,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
@@ -49,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 << '="' << value.to_s << '"'}.join(' ')
+      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/border.rb

@@ -3,21 +3,12 @@ module Axlsx
   # This class details a border used in Office Open XML spreadsheet styles.
   class Border
 
-    # @return [Boolean] The diagonal up property for the border that indicates if the border should include a diagonal line from the bottom left to the top right of the cell.
-    attr_reader :diagonalUp
-
-    # @return [Boolean] The diagonal down property for the border that indicates if the border should include a diagonal line from the top left to the top right of the cell.
-    attr_reader :diagonalDown
-
-    # @return [Boolean] The outline property for the border indicating that top, left, right and bottom borders should only be applied to the outside border of a range of cells.
-    attr_reader :outline
-
-    # @return [SimpleTypedList] A list of BorderPr objects for this border.
-    attr_reader :prs
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
 
     # Creates a new Border object
-    # @option options [Boolean] diagonalUp
-    # @option options [Boolean] diagonalDown
+    # @option options [Boolean] diagonal_up
+    # @option options [Boolean] diagonal_down
     # @option options [Boolean] outline
     # @example - Making a border
     #   p = Axlsx::Package.new
@@ -30,15 +21,33 @@ module Axlsx
     # @see Style#add_style
     def initialize(options={})
       @prs = SimpleTypedList.new BorderPr
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
+      parse_options options
     end
 
+    serializable_attributes :diagonal_up, :diagonal_down, :outline
+
+    # @return [Boolean] The diagonal up property for the border that indicates if the border should include a diagonal line from the bottom left to the top right of the cell.
+    attr_reader :diagonal_up
+    alias :diagonalUp :diagonal_up
+
+    # @return [Boolean] The diagonal down property for the border that indicates if the border should include a diagonal line from the top left to the top right of the cell.
+    attr_reader :diagonal_down
+    alias :diagonalDown :diagonal_down
+
+    # @return [Boolean] The outline property for the border indicating that top, left, right and bottom borders should only be applied to the outside border of a range of cells.
+    attr_reader :outline
+
+    # @return [SimpleTypedList] A list of BorderPr objects for this border.
+    attr_reader :prs
+
     # @see diagonalUp
-    def diagonalUp=(v) Axlsx::validate_boolean v; @diagonalUp = v end
+    def diagonal_up=(v) Axlsx::validate_boolean v; @diagonal_up = v end
+    alias :diagonalUp= :diagonal_up=
+
     # @see diagonalDown
-    def diagonalDown=(v) Axlsx::validate_boolean v; @diagonalDown = v end
+    def diagonal_down=(v) Axlsx::validate_boolean v; @diagonal_down = v end
+    alias :diagonalDown= :diagonal_down=
+
     # @see outline
     def outline=(v) Axlsx::validate_boolean v; @outline = v end
 
@@ -47,9 +56,9 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<border '
-      h = self.instance_values.select{ |k,v| [:diagonalUp, :diagonalDown, :outline].include? k }
-      str << h.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      serialized_attributes str
       str << '>'
+      # enforces order
       [:start, :end, :left, :right, :top, :bottom, :diagonal, :vertical, :horizontal].each do |k|
         @prs.select { |pr| pr.name == k }.each do |part|
           part.to_xml_string(str)

data/lib/axlsx/stylesheet/border_pr.rb

@@ -2,7 +2,7 @@
 module Axlsx
   # A border part.
   class BorderPr
-
+    include Axlsx::OptionsParser
     # @return [Color] The color of this border part.
     attr_reader :color
 
@@ -45,9 +45,10 @@ module Axlsx
     # @option options [Symbol] style
     # @see Axlsx::Border
     def initialize(options={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
+      parse_options(options)
+      #options.each do |o|
+      #  self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      #end
     end
 
     # @see name

data/lib/axlsx/stylesheet/cell_alignment.rb

@@ -1,9 +1,33 @@
 # encoding: UTF-8
 module Axlsx
+  
+ 
   # CellAlignment stores information about the cell alignment of a style Xf Object.
   # @note Using Styles#add_style is the recommended way to manage cell alignment.
   # @see Styles#add_style
   class CellAlignment
+    
+
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    
+    serializable_attributes :horizontal, :vertical, :text_rotation, :wrap_text, :indent, :relative_indent, :justify_last_line, :shrink_to_fit, :reading_order
+    # Create a new cell_alignment object
+    # @option options [Symbol] horizontal
+    # @option options [Symbol] vertical
+    # @option options [Integer] text_rotation
+    # @option options [Boolean] wrap_text
+    # @option options [Integer] indent
+    # @option options [Integer] relative_indent
+    # @option options [Boolean] justify_last_line
+    # @option options [Boolean] shrink_to_fit
+    # @option options [Integer] reading_order
+    def initialize(options={})
+      parse_options options
+    end
+
+
+
     # The horizontal alignment of the cell.
     # @note
     #  The horizontal cell alignement style must be one of
@@ -31,11 +55,13 @@ module Axlsx
 
     # The textRotation of the cell.
     # @return [Integer]
-    attr_reader :textRotation
+    attr_reader :text_rotation
+    alias :textRotation :text_rotation
 
     # Indicate if the text of the cell should wrap
     # @return [Boolean]
-    attr_reader :wrapText
+    attr_reader :wrap_text
+    alias :wrapText :wrap_text
 
     # The amount of indent
     # @return [Integer]
@@ -43,64 +69,64 @@ module Axlsx
 
     # The amount of relativeIndent
     # @return [Integer]
-    attr_reader :relativeIndent
+    attr_reader :relative_indent
+    alias :relativeIndent :relative_indent
 
     # Indicate if the last line should be justified.
     # @return [Boolean]
-    attr_reader :justifyLastLine
+    attr_reader :justify_last_line
+    alias :justifyLastLine :justify_last_line
 
     # Indicate if the text should be shrunk to the fit in the cell.
     # @return [Boolean]
-    attr_reader :shrinkToFit
+    attr_reader :shrink_to_fit
+    alias :shrinkToFit :shrink_to_fit
 
     # The reading order of the text
     # 0 Context Dependent
     # 1 Left-to-Right
     # 2 Right-to-Left
     # @return [Integer]
-    attr_reader :readingOrder
-
-    # Create a new cell_alignment object
-    # @option options [Symbol] horizontal
-    # @option options [Symbol] vertical
-    # @option options [Integer] textRotation
-    # @option options [Boolean] wrapText
-    # @option options [Integer] indent
-    # @option options [Integer] relativeIndent
-    # @option options [Boolean] justifyLastLine
-    # @option options [Boolean] shrinkToFit
-    # @option options [Integer] readingOrder
-    def initialize(options={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
+    attr_reader :reading_order
+    alias :readingOrder :reading_order
 
     # @see horizontal
     def horizontal=(v) Axlsx::validate_horizontal_alignment v; @horizontal = v end
     # @see vertical
     def vertical=(v) Axlsx::validate_vertical_alignment v; @vertical = v end
     # @see textRotation
-    def textRotation=(v) Axlsx::validate_unsigned_int v; @textRotation = v end
+    def text_rotation=(v) Axlsx::validate_unsigned_int v; @text_rotation = v end
+    alias :textRotation= :text_rotation=
+
     # @see wrapText
-    def wrapText=(v) Axlsx::validate_boolean v; @wrapText = v end
+    def wrap_text=(v) Axlsx::validate_boolean v; @wrap_text = v end
+    alias :wrapText= :wrap_text=
+
     # @see indent
     def indent=(v) Axlsx::validate_unsigned_int v; @indent = v end
+
     # @see relativeIndent
-    def relativeIndent=(v) Axlsx::validate_int v; @relativeIndent = v end
+    def relative_indent=(v) Axlsx::validate_int v; @relative_indent = v end
+    alias :relativeIndent= :relative_indent=
+
     # @see justifyLastLine
-    def justifyLastLine=(v) Axlsx::validate_boolean v; @justifyLastLine = v end
+    def justify_last_line=(v) Axlsx::validate_boolean v; @justify_last_line = v end
+    alias :justifyLastLine= :justify_last_line=
+
     # @see shrinkToFit
-    def shrinkToFit=(v) Axlsx::validate_boolean v; @shrinkToFit = v end
+    def shrink_to_fit=(v) Axlsx::validate_boolean v; @shrink_to_fit = v end
+    alias :shrinkToFit= :shrink_to_fit=
+
     # @see readingOrder
-    def readingOrder=(v) Axlsx::validate_unsigned_int v; @readingOrder = v end
+    def reading_order=(v) Axlsx::validate_unsigned_int v; @reading_order = v end
+    alias :readingOrder= :reading_order=
 
     # Serializes the object
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
       str << '<alignment '
-      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      serialized_attributes str
       str << '/>'
     end
 

data/lib/axlsx/stylesheet/cell_protection.rb

@@ -5,6 +5,11 @@ module Axlsx
   # @see Styles#add_style
   class CellProtection
 
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    serializable_attributes :hidden, :locked
+
     # specifies locking for cells that have the style containing this protection
     # @return [Boolean]
     attr_reader :hidden
@@ -17,9 +22,7 @@ module Axlsx
     # @option options [Boolean] hidden value for hidden protection
     # @option options [Boolean] locked value for locked protection
     def initialize(options={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
+      parse_options options
     end
 
     # @see hidden
@@ -32,7 +35,7 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<protection '
-      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      serialized_attributes str
       str << '/>'
     end
 

data/lib/axlsx/stylesheet/cell_style.rb

@@ -4,6 +4,23 @@ module Axlsx
   # @note Using Styles#add_style is the recommended way to manage cell styling.
   # @see Styles#add_style
   class CellStyle
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    # Creats a new CellStyle object
+    # @option options [String] name
+    # @option options [Integer] xfId
+    # @option options [Integer] buildinId
+    # @option options [Integer] iLevel
+    # @option options [Boolean] hidden
+    # @option options [Boolean] customBuiltIn
+    def initialize(options={})
+      parse_options options
+    end
+
+    serializable_attributes :name, :xfId, :buildinId, :iLevel, :hidden, :customBuilin
+
     # The name of this cell style
     # @return [String]
     attr_reader :name
@@ -30,19 +47,7 @@ module Axlsx
     # @return [Boolean]
     attr_reader :customBuiltin
 
-    # Creats a new CellStyle object
-    # @option options [String] name
-    # @option options [Integer] xfId
-    # @option options [Integer] buildinId
-    # @option options [Integer] iLevel
-    # @option options [Boolean] hidden
-    # @option options [Boolean] customBuiltIn
-    def initialize(options={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? o[0]
-      end
-    end
-    # @see name
+     # @see name
     def name=(v)  Axlsx::validate_string v; @name = v end
     # @see xfId
     def xfId=(v) Axlsx::validate_unsigned_int v; @xfId = v end
@@ -60,7 +65,7 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<cellStyle '
-      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      serialized_attributes str
       str << '/>'
     end