caxlsx 3.1.1 → 3.2.0

data/lib/axlsx/util/mime_type_utils.rb

@@ -1,11 +1,11 @@
-module Axlsx
-  # This module defines some utils related with mime type detection
-  module MimeTypeUtils
-    # Detect a file mime type
-    # @param [String] v File path
-    # @return [String] File mime type
-    def self.get_mime_type(v)
-      Marcel::MimeType.for(Pathname.new(v))
-    end
-  end
-end
+module Axlsx
+  # This module defines some utils related with mime type detection
+  module MimeTypeUtils
+    # Detect a file mime type
+    # @param [String] v File path
+    # @return [String] File mime type
+    def self.get_mime_type(v)
+      Marcel::MimeType.for(Pathname.new(v))
+    end
+  end
+end

data/lib/axlsx/util/options_parser.rb

@@ -1,16 +1,16 @@
-module Axlsx
-  # This module defines a single method for parsing options in class
-  # initializers.
-  module OptionsParser
-
-    # Parses an options hash by calling any defined method by the same
-    # name of the key postfixed with an '='
-    # @param [Hash] options Options to parse.
-    def parse_options(options={})
-      options.each do |key, value|
-        key = :"#{key}="
-        self.send(key, value) if !value.nil? && self.respond_to?(key)
-      end
-    end
-  end
-end
+module Axlsx
+  # This module defines a single method for parsing options in class
+  # initializers.
+  module OptionsParser
+
+    # Parses an options hash by calling any defined method by the same
+    # name of the key postfixed with an '='
+    # @param [Hash] options Options to parse.
+    def parse_options(options={})
+      options.each do |key, value|
+        key = :"#{key}="
+        self.send(key, value) if !value.nil? && self.respond_to?(key)
+      end
+    end
+  end
+end

data/lib/axlsx/util/serialized_attributes.rb

@@ -1,89 +1,89 @@
-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
-    end
-
-    # class methods applied to all includers
-    module ClassMethods
-
-      # 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
-      end
-
-      # a reader for those attributes
-      attr_reader :xml_attributes
-
-      # This helper registers the attributes that will be formatted as elements.
-      def serializable_element_attributes(*symbols)
-        @xml_element_attributes = symbols
-      end
-
-      # attr reader for element attributes
-      attr_reader :xml_element_attributes
-    end
-
-    # creates a XML tag with serialized attributes
-    # @see SerializedAttributes#serialized_attributes
-    def serialized_tag(tagname, str, additional_attributes = {}, &block)
-      str << "<#{tagname} "
-      serialized_attributes(str, additional_attributes)
-      if block_given?
-        str << '>'
-        yield
-        str << "</#{tagname}>"
-      else
-        str << '/>'
-      end
-    end
-
-    # 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)}\" "
-      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
-    # values. We use an array for element attributes becuase misordering will
-    # break the xml and 1.8.7 does not support ordered hashes.
-    # @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)
-      attrs = self.class.xml_element_attributes + additional_attributes
-      values = instance_values
-      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}>"
-      end
-      str
-    end
-  end
-end
+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
+    end
+
+    # class methods applied to all includers
+    module ClassMethods
+
+      # 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
+      end
+
+      # a reader for those attributes
+      attr_reader :xml_attributes
+
+      # This helper registers the attributes that will be formatted as elements.
+      def serializable_element_attributes(*symbols)
+        @xml_element_attributes = symbols
+      end
+
+      # attr reader for element attributes
+      attr_reader :xml_element_attributes
+    end
+
+    # creates a XML tag with serialized attributes
+    # @see SerializedAttributes#serialized_attributes
+    def serialized_tag(tagname, str, additional_attributes = {}, &block)
+      str << "<#{tagname} "
+      serialized_attributes(str, additional_attributes)
+      if block_given?
+        str << '>'
+        yield
+        str << "</#{tagname}>"
+      else
+        str << '/>'
+      end
+    end
+
+    # 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)}\" "
+      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
+    # values. We use an array for element attributes becuase misordering will
+    # break the xml and 1.8.7 does not support ordered hashes.
+    # @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)
+      attrs = self.class.xml_element_attributes + additional_attributes
+      values = instance_values
+      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}>"
+      end
+      str
+    end
+  end
+end

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,179 +1,179 @@
-# 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
-    # 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
-      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
-    # @return [Array]
-    attr_reader :allowed_types
-
-    # The index below which items cannot be removed
-    # @return [Integer]
-    def locked_at
-      defined?(@locked_at) ? @locked_at : nil
-    end
-
-    # 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
-      @locked_at = @list.size
-      self
-    end
-
-    # Unlock the list
-    # @return [self]
-    def unlock
-      @locked_at = nil
-      self
-    end
-    
-    def to_ary
-      @list
-    end
-
-    alias :to_a :to_ary
-
-    # join operator
-    # @param [Array] v 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 
-      end
-    end
-
-    # Concat operator
-    # @param [Any] v the data to be added
-    # @raise [ArgumentError] if the value being added is not one fo the allowed types
-    # @return [Integer] returns the index of the item added.
-    def <<(v)
-      DataTypeValidator.validate :SimpleTypedList_push, @allowed_types, v
-      @list << v
-      @list.size - 1
-    end 
-    
-    alias :push :<<
-    
-
-    # delete the item from the list
-    # @param [Any] v The item to be deleted.
-    # @raise [ArgumentError] if the item's index is protected by locking
-    # @return [Any] The item deleted
-    def delete(v)
-      return unless include? v
-      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
-      @list.delete v
-    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
-    end
-
-    # positional assignment. Adds the item at the index specified
-    # @param [Integer] index
-    # @param [Any] v
-    # @raise [ArgumentError] if the index is protected by locking
-    # @raise [ArgumentError] if the item is not one of the allowed types
-    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
-    end
-
-    # inserts an item at the index specfied
-    # @param [Integer] index
-    # @param [Any] v
-    # @raise [ArgumentError] if the index is protected by locking
-    # @raise [ArgumentError] if the index is not one of the allowed types
-    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)
-      v
-    end
-
-    # determines if the index is protected
-    # @param [Integer] 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 = '')
-      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 << '">')
-      each { |item| item.to_xml_string(str) }
-      str << ('</' << el_name << '>')
-    end
-
-  end
-
-
-end
+# 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
+    # 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
+      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
+    # @return [Array]
+    attr_reader :allowed_types
+
+    # The index below which items cannot be removed
+    # @return [Integer]
+    def locked_at
+      defined?(@locked_at) ? @locked_at : nil
+    end
+
+    # 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
+      @locked_at = @list.size
+      self
+    end
+
+    # Unlock the list
+    # @return [self]
+    def unlock
+      @locked_at = nil
+      self
+    end
+    
+    def to_ary
+      @list
+    end
+
+    alias :to_a :to_ary
+
+    # join operator
+    # @param [Array] v 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 
+      end
+    end
+
+    # Concat operator
+    # @param [Any] v the data to be added
+    # @raise [ArgumentError] if the value being added is not one fo the allowed types
+    # @return [Integer] returns the index of the item added.
+    def <<(v)
+      DataTypeValidator.validate :SimpleTypedList_push, @allowed_types, v
+      @list << v
+      @list.size - 1
+    end 
+    
+    alias :push :<<
+    
+
+    # delete the item from the list
+    # @param [Any] v The item to be deleted.
+    # @raise [ArgumentError] if the item's index is protected by locking
+    # @return [Any] The item deleted
+    def delete(v)
+      return unless include? v
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
+      @list.delete v
+    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
+    end
+
+    # positional assignment. Adds the item at the index specified
+    # @param [Integer] index
+    # @param [Any] v
+    # @raise [ArgumentError] if the index is protected by locking
+    # @raise [ArgumentError] if the item is not one of the allowed types
+    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
+    end
+
+    # inserts an item at the index specfied
+    # @param [Integer] index
+    # @param [Any] v
+    # @raise [ArgumentError] if the index is protected by locking
+    # @raise [ArgumentError] if the index is not one of the allowed types
+    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)
+      v
+    end
+
+    # determines if the index is protected
+    # @param [Integer] 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 = '')
+      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 << '">')
+      each { |item| item.to_xml_string(str) }
+      str << ('</' << el_name << '>')
+    end
+
+  end
+
+
+end