caxlsx 3.3.0 → 4.0.0

data/lib/axlsx/util/serialized_attributes.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Axlsx
   # This module allows us to define a list of symbols defining which
   # attributes will be serialized for a class.
   module SerializedAttributes
-
     # Extend with class methods
     def self.included(base)
       base.send :extend, ClassMethods
@@ -10,16 +11,25 @@ module Axlsx
 
     # class methods applied to all includers
     module ClassMethods
-
-      # This is the method to be used in inheriting classes to specify 
+      # This is the method to be used in inheriting classes to specify
       # which of the instance values are serializable
       def serializable_attributes(*symbols)
         @xml_attributes = symbols
+        @camel_xml_attributes = nil
+        @ivar_xml_attributes = nil
       end
 
       # a reader for those attributes
       attr_reader :xml_attributes
 
+      def camel_xml_attributes
+        @camel_xml_attributes ||= @xml_attributes.map { |attr| Axlsx.camel(attr, false) }
+      end
+
+      def ivar_xml_attributes
+        @ivar_xml_attributes ||= @xml_attributes.map { |attr| :"@#{attr}" }
+      end
+
       # This helper registers the attributes that will be formatted as elements.
       def serializable_element_attributes(*symbols)
         @xml_element_attributes = symbols
@@ -31,39 +41,52 @@ module Axlsx
 
     # creates a XML tag with serialized attributes
     # @see SerializedAttributes#serialized_attributes
-    def serialized_tag(tagname, str, additional_attributes = {}, &block)
-      str << "<#{tagname} "
+    def serialized_tag(tagname, str, additional_attributes = {})
+      str << '<' << tagname << ' '
       serialized_attributes(str, additional_attributes)
       if block_given?
         str << '>'
         yield
-        str << "</#{tagname}>"
+        str << '</' << tagname << '>'
       else
         str << '/>'
       end
     end
 
-    # serializes the instance values of the defining object based on the 
+    # serializes the instance values of the defining object based on the
     # list of serializable attributes.
     # @param [String] str The string instance to append this
     # serialization to.
     # @param [Hash] additional_attributes An option key value hash for
     # defining values that are not serializable attributes list.
-    def serialized_attributes(str = '', additional_attributes = {})
-      attributes = declared_attributes.merge! additional_attributes
-      attributes.each do |key, value|
-        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(Axlsx.booleanize(value), false)}\" "
+    # @param [Boolean] camelize_value Should the attribute values be camelized
+    def serialized_attributes(str = +'', additional_attributes = {}, camelize_value = true)
+      camel_xml_attributes = self.class.camel_xml_attributes
+      ivar_xml_attributes = self.class.ivar_xml_attributes
+
+      self.class.xml_attributes.each_with_index do |attr, index|
+        next if additional_attributes.key?(attr)
+        next unless instance_variable_defined?(ivar_xml_attributes[index])
+
+        value = instance_variable_get(ivar_xml_attributes[index])
+        next if value.nil?
+
+        value = Axlsx.booleanize(value)
+        value = Axlsx.camel(value, false) if camelize_value
+
+        str << camel_xml_attributes[index] << '="' << value.to_s << '" '
       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
-      Axlsx.instance_values_for(self).select do |key, value|
-        value != nil && self.class.xml_attributes.include?(key.to_sym)
+      additional_attributes.each do |attr, value|
+        next if value.nil?
+
+        value = Axlsx.booleanize(value)
+        value = Axlsx.camel(value, false) if camelize_value
+
+        str << Axlsx.camel(attr, false) << '="' << value.to_s << '" '
       end
+
+      str
     end
 
     # serialized instance values at text nodes on a camelized element of the
@@ -73,15 +96,16 @@ module Axlsx
     # @param [String] str The string instance to which serialized data is appended
     # @param [Array] additional_attributes An array of additional attribute names.
     # @return [String] The serialized output.
-    def serialized_element_attributes(str='', additional_attributes=[], &block)
+    def serialized_element_attributes(str = +'', additional_attributes = [])
       attrs = self.class.xml_element_attributes + additional_attributes
       values = Axlsx.instance_values_for(self)
       attrs.each do |attribute_name|
         value = values[attribute_name.to_s]
         next if value.nil?
+
         value = yield value if block_given?
         element_name = Axlsx.camel(attribute_name, false)
-        str << "<#{element_name}>#{value}</#{element_name}>"
+        str << '<' << element_name << '>' << value << '</' << element_name << '>'
       end
       str
     end

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,23 +1,42 @@
-# encoding: UTF-8
-module Axlsx
+# frozen_string_literal: true
 
+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
+  class SimpleTypedList < Array
+    DESTRUCTIVE = [
+      'replace', 'insert', 'collect!', 'map!', 'pop', 'delete_if',
+      'reverse!', 'shift', 'shuffle!', 'slice!', 'sort!', 'uniq!',
+      'unshift', 'zip', 'flatten!', 'fill', 'drop', 'drop_while',
+      'clear'
+    ].freeze
+
+    DESTRUCTIVE.each do |name|
+      undef_method name
+    end
+
+    # We often call index(element) on instances of SimpleTypedList. Thus, we do not want to inherit Array
+    # implementation of == / eql? which walks the elements calling == / eql?. Instead we want the fast
+    # and original versions from BasicObject.
+    alias :== :equal?
+    alias :eql? :equal?
+
     # 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
     # @raise [ArgumentError] if all members of type are not Class objects
-    def initialize type, serialize_as=nil, start_size = 0
+    def initialize(type, serialize_as = nil, start_size = 0)
+      super(start_size)
+
       if type.is_a? Array
         type.each { |item| raise ArgumentError, "All members of type must be Class objects" unless item.is_a? Class }
         @allowed_types = type
       else
         raise ArgumentError, "Type must be a Class object or array of Class objects" unless type.is_a? Class
+
         @allowed_types = [type]
       end
       @serialize_as = serialize_as unless serialize_as.nil?
-      @list = Array.new(start_size)
     end
 
     # The class constants of allowed types
@@ -38,15 +57,16 @@ module Axlsx
     # 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
+      return clone if size.zero?
+
+      row_count = size
+      max_column_count = 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]
+        max_column_count.times do |column_index|
+          datum = if self[row_index].cells.size >= max_column_count
+                    self[row_index].cells[column_index]
                   elsif block_given?
                     yield(column_index, row_index)
                   end
@@ -55,11 +75,11 @@ module Axlsx
       end
       result
     end
-    
+
     # Lock this list at the current size
     # @return [self]
     def lock
-      @locked_at = @list.size
+      @locked_at = size
       self
     end
 
@@ -69,23 +89,17 @@ module Axlsx
       @locked_at = nil
       self
     end
-    
-    def to_ary
-      @list
-    end
-
-    alias :to_a :to_ary
 
     # join operator
-    # @param [Array] v the array to join
+    # @param [Array] other the array to join
     # @raise [ArgumentError] if any of the values being joined are not
     # one of the allowed types
     # @return [SimpleTypedList]
-    def +(v)
-      v.each do |item| 
-        DataTypeValidator.validate :SimpleTypedList_plus, @allowed_types, item
-        @list << item 
+    def +(other)
+      other.each do |item|
+        self << item
       end
+      super
     end
 
     # Concat operator
@@ -94,12 +108,11 @@ module Axlsx
     # @return [Integer] returns the index of the item added.
     def <<(v)
       DataTypeValidator.validate :SimpleTypedList_push, @allowed_types, v
-      @list << v
-      @list.size - 1
-    end 
-    
+      super
+      size - 1
+    end
+
     alias :push :<<
-    
 
     # delete the item from the list
     # @param [Any] v The item to be deleted.
@@ -108,16 +121,17 @@ module Axlsx
     def delete(v)
       return unless include? v
       raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
-      @list.delete v
+
+      super
     end
 
     # delete the item from the list at the index position provided
     # @raise [ArgumentError] if the index is protected by locking
     # @return [Any] The item deleted
     def delete_at(index)
-      @list[index]
       raise ArgumentError, "Item is protected and cannot be deleted" if protected? index
-      @list.delete_at index
+
+      super
     end
 
     # positional assignment. Adds the item at the index specified
@@ -125,11 +139,12 @@ module Axlsx
     # @param [Any] v
     # @raise [ArgumentError] if the index is protected by locking
     # @raise [ArgumentError] if the item is not one of the allowed types
+    # @return [Any] The item added
     def []=(index, v)
       DataTypeValidator.validate :SimpleTypedList_insert, @allowed_types, v
       raise ArgumentError, "Item is protected and cannot be changed" if protected? index
-      @list[index] = v
-      v
+
+      super
     end
 
     # inserts an item at the index specfied
@@ -137,43 +152,29 @@ module Axlsx
     # @param [Any] v
     # @raise [ArgumentError] if the index is protected by locking
     # @raise [ArgumentError] if the index is not one of the allowed types
+    # @return [Any] The item inserted
     def insert(index, v)
       DataTypeValidator.validate :SimpleTypedList_insert, @allowed_types, v
       raise ArgumentError, "Item is protected and cannot be changed" if protected? index
-      @list.insert(index, v)
+
+      super
       v
     end
 
     # determines if the index is protected
     # @param [Integer] index
-    def protected? index
+    def protected?(index)
       return false unless locked_at.is_a? Integer
+
       index < locked_at
     end
 
-    DESTRUCTIVE = ['replace', 'insert', 'collect!', 'map!', 'pop', 'delete_if',
-                   'reverse!', 'shift', 'shuffle!', 'slice!', 'sort!', 'uniq!',
-                   'unshift', 'zip', 'flatten!', 'fill', 'drop', 'drop_while',
-                   'delete_if', 'clear']
-    DELEGATES = Array.instance_methods - self.instance_methods - DESTRUCTIVE
-
-    DELEGATES.each do |method|
-      class_eval %{
-        def #{method}(*args, &block)
-          @list.send(:#{method}, *args, &block)
-        end
-      }
-    end
-                   
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       classname = @allowed_types[0].name.split('::').last
-      el_name = serialize_as.to_s || (classname[0,1].downcase + classname[1..-1])
-      str << ('<' << el_name << ' count="' << size.to_s << '">')
+      el_name = serialize_as.to_s || (classname[0, 1].downcase + classname[1..])
+      str << '<' << el_name << ' count="' << size.to_s << '">'
       each { |item| item.to_xml_string(str) }
-      str << ('</' << el_name << '>')
+      str << '</' << el_name << '>'
     end
-
   end
-
-
 end

data/lib/axlsx/util/storage.rb

@@ -1,61 +1,60 @@
-# encoding: UTF-8
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # The Storage class represents a storage object or stream in a compound file.
   class Storage
-
     # Packing for the Storage when pushing an array of items into a byte stream
     # Name, name length, type, color, left sibling, right sibling, child, classid, state, created, modified, sector, size
-    PACKING = "s32 s1 c2 l3 x16 x4 q2 l q".freeze
+    PACKING = "s32 s1 c2 l3 x16 x4 q2 l q"
 
     # storage types
     TYPES = {
-      :root=>5,
-      :stream=>2,
-      :storage=>1
+      root: 5,
+      stream: 2,
+      storage: 1
     }.freeze
 
     # Creates a byte string for this storage
-    # @return [String] 
+    # @return [String]
     def to_s
-     data = [@name.concat(Array.new(32-@name.size, 0)), 
-             @name_size, 
-             @type, 
-             @color, 
-             @left, 
-             @right, 
-             @child, 
-             @created,
-             @modified, 
-             @sector, 
-             @size].flatten
+      data = [@name.concat(Array.new(32 - @name.size, 0)),
+              @name_size,
+              @type,
+              @color,
+              @left,
+              @right,
+              @child,
+              @created,
+              @modified,
+              @sector,
+              @size].flatten
       data.pack(PACKING)
     end
 
     # storage colors
     COLORS = {
-      :red=>0, 
-      :black=>1
-    }
+      red: 0,
+      black: 1
+    }.freeze
 
     # The color of this node in the directory tree. Defaults to black if not specified
     # @return [Integer] color
     attr_reader :color
-    
+
     # Sets the color for this storage
     # @param [Integer] v Must be one of the COLORS constant hash values
     def color=(v)
-      RestrictionValidator.validate :storage_color, COLORS.values, v      
+      RestrictionValidator.validate :storage_color, COLORS.values, v
       @color = v
     end
 
     # The size of the name for this node.
-    # interesting to see that office actually uses 'R' for the root directory and lists the size as 2 bytes - thus is it *NOT* null 
+    # interesting to see that office actually uses 'R' for the root directory and lists the size as 2 bytes - thus is it *NOT* null
     # terminated. I am making this r/w so that I can override the size
     # @return [Integer] color
     attr_reader :name_size
 
-    # the name of the stream    
+    # the name of the stream
     attr_reader :name
 
     # sets the name of the stream.
@@ -64,7 +63,6 @@ module Axlsx
     def name=(v)
       @name = v.bytes.to_a << 0
       @name_size = @name.size * 2
-      @name
     end
 
     # The size of the stream
@@ -77,7 +75,7 @@ module Axlsx
     # @param [String] v The data for this storages stream
     # @return [Array]
     def data=(v)
-      Axlsx::validate_string(v)
+      Axlsx.validate_string(v)
       self.type = TYPES[:stream] unless @type
       @size = v.size
       @data = v.bytes.to_a
@@ -87,16 +85,16 @@ module Axlsx
     # @return [Integer] sector
     attr_accessor :sector
 
-    # The 0 based index in the directoies chain for this the left sibling of this storage. 
-    
+    # The 0 based index in the directoies chain for this the left sibling of this storage.
+
     # @return [Integer] left
-    attr_accessor :left 
+    attr_accessor :left
 
-    # The 0 based index in the directoies chain for this the right sibling of this storage. 
+    # The 0 based index in the directoies chain for this the right sibling of this storage.
     # @return [Integer] right
-    attr_accessor :right 
+    attr_accessor :right
 
-    # The 0 based index in the directoies chain for the child of this storage. 
+    # The 0 based index in the directoies chain for the child of this storage.
     # @return [Integer] child
     attr_accessor :child
 
@@ -113,14 +111,14 @@ module Axlsx
     # @return [Integer] type
     attr_reader :type
 
-    # Sets the type for this storage. 
-    # @param [Integer] v the type to specify must be one of the TYPES constant hash values. 
+    # Sets the type for this storage.
+    # @param [Integer] v the type to specify must be one of the TYPES constant hash values.
     def type=(v)
-      RestrictionValidator.validate :storage_type, TYPES.values, v      
+      RestrictionValidator.validate :storage_type, TYPES.values, v
       @type = v
     end
 
-    # Creates a new storage object. 
+    # Creates a new storage object.
     # @param [String] name the name of the storage
     # @option options [Integer] color (black)
     # @option options [Integer] type (storage)
@@ -131,16 +129,15 @@ module Axlsx
     # @option options [Integer] created (0)
     # @option options [Integer] modified (0)
     # @option options [Integer] sector (0)
-    def initialize(name, options= {})
+    def initialize(name, options = {})
       @left = @right = @child = -1
       @sector = @size = @created = @modified = 0
       options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+        send("#{o[0]}=", o[1]) if respond_to? "#{o[0]}="
       end
       @color ||= COLORS[:black]
       @type ||= (data.nil? ? TYPES[:storage] : TYPES[:stream])
       self.name = name
     end
- 
   end
 end