axlsx 2.0.1 → 2.1.0.pre

data/lib/axlsx/util/options_parser.rb

@@ -8,7 +8,8 @@ module Axlsx
     # @param [Hash] options Options to parse.
     def parse_options(options={})
       options.each do |key, value|
-        self.send("#{key}=", value) if self.respond_to?("#{key}=") && value != nil
+        key = :"#{key}="
+        self.send(key, value) if !value.nil? && self.respond_to?(key)
       end
     end
   end

data/lib/axlsx/util/parser.rb

@@ -9,28 +9,28 @@ module Axlsx
     
     # parse and assign string attribute
     def parse_string attr_name, xpath
-      send("#{attr_name.to_s}=", parse_value(xpath))
+      send("#{attr_name}=", parse_value(xpath))
     end
     
     # parse convert and assign node text to symbol
     def parse_symbol attr_name, xpath
       v = parse_value xpath
       v = v.to_sym unless v.nil?
-      send("#{attr_name.to_s}=", v)
+      send("#{attr_name}=", v)
     end
     
     # parse, convert and assign note text to integer
     def parse_integer attr_name, xpath
       v = parse_value xpath
       v = v.to_i if v.respond_to?(:to_i)
-      send("#{attr_name.to_s}=", v)
+      send("#{attr_name}=", v)
     end
     
     # parse, convert and assign node text to float
     def parse_float attr_name, xpath
       v = parse_value xpath
       v = v.to_f if v.respond_to?(:to_f)
-      send("#{attr_name.to_s}=", v)
+      send("#{attr_name}=", v)
     end
 
     # return node text based on xpath

data/lib/axlsx/util/serialized_attributes.rb

@@ -18,9 +18,7 @@ module Axlsx
       end
 
       # a reader for those attributes
-      def xml_attributes
-        @xml_attributes
-      end
+      attr_reader :xml_attributes
 
       # This helper registers the attributes that will be formatted as elements.
       def serializable_element_attributes(*symbols)
@@ -28,8 +26,20 @@ module Axlsx
       end
 
       # attr reader for element attributes
-      def xml_element_attributes
-        @xml_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
 
@@ -42,7 +52,7 @@ module Axlsx
     def serialized_attributes(str = '', additional_attributes = {})
       attributes = declared_attributes.merge! additional_attributes
       attributes.each do |key, value|
-        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(value, false)}\" "
+        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(Axlsx.booleanize(value), false)}\" "
       end
       str
     end

data/lib/axlsx/util/simple_typed_list.rb

@@ -8,7 +8,7 @@ module Axlsx
     # @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
+    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
@@ -16,9 +16,8 @@ module Axlsx
         raise ArgumentError, "Type must be a Class object or array of Class objects" unless type.is_a? Class
         @allowed_types = [type]
       end
-      @list = []
-      @locked_at = nil
-      @serialize_as = serialize_as
+      @serialize_as = serialize_as unless serialize_as.nil?
+      @list = Array.new(start_size)
     end
 
     # The class constants of allowed types
@@ -27,7 +26,9 @@ module Axlsx
 
     # The index below which items cannot be removed
     # @return [Integer]
-    attr_reader :locked_at
+    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.
@@ -54,6 +55,7 @@ module Axlsx
       end
       result
     end
+    
     # Lock this list at the current size
     # @return [self]
     def lock
@@ -61,18 +63,18 @@ module Axlsx
       self
     end
 
-    def to_ary
-      @list
-    end
-
-    alias :to_a :to_ary
-
     # 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
@@ -81,7 +83,7 @@ module Axlsx
     # @return [SimpleTypedList]
     def +(v)
       v.each do |item| 
-        DataTypeValidator.validate "SimpleTypedList.+", @allowed_types, item
+        DataTypeValidator.validate :SimpleTypedList_plus, @allowed_types, item
         @list << item 
       end
     end
@@ -91,19 +93,21 @@ module Axlsx
     # @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.<<", @allowed_types, v
+      DataTypeValidator.validate :SimpleTypedList_push, @allowed_types, v
       @list << v
       @list.size - 1
-    end
+    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 @list.include? v
-      raise ArgumentError, "Item is protected and cannot be deleted" if protected? @list.index(v)
+      return unless include? v
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
       @list.delete v
     end
 
@@ -122,7 +126,7 @@ module Axlsx
     # @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.<<", @allowed_types, v
+      DataTypeValidator.validate :SimpleTypedList_insert, @allowed_types, v
       raise ArgumentError, "Item is protected and cannot be changed" if protected? index
       @list[index] = v
       v
@@ -134,7 +138,7 @@ module Axlsx
     # @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.<<", @allowed_types, 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
@@ -143,38 +147,10 @@ module Axlsx
     # determines if the index is protected
     # @param [Integer] index
     def protected? index
-      return false unless @locked_at.is_a? Fixnum
-      index < @locked_at
+      return false unless locked_at.is_a? Fixnum
+      index < locked_at
     end
 
-    # override the equality method so that this object can be compared to a simple array.
-    # if this object's list is equal to the specifiec array, we return true.
-    def ==(v)
-      v == @list
-    end
-    # method_mission override to pass allowed methods to the list.
-    # @note
-    #  the following methods are not allowed
-    #   :replace
-    #   :insert
-    #   :collect!
-    #   :map!
-    #   :pop
-    #   :delete_if
-    #   :reverse!
-    #   :shift
-    #   :shuffle!
-    #   :slice!
-    #   :sort!
-    #   :uniq!
-    #   :unshift
-    #   :zip
-    #   :flatten!
-    #   :fill
-    #   :drop
-    #   :drop_while
-    #   :delete_if
-    #   :clear
     DESTRUCTIVE = ['replace', 'insert', 'collect!', 'map!', 'pop', 'delete_if',
                    'reverse!', 'shift', 'shuffle!', 'slice!', 'sort!', 'uniq!',
                    'unshift', 'zip', 'flatten!', 'fill', 'drop', 'drop_while',
@@ -188,13 +164,13 @@ module Axlsx
         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="' << @list.size.to_s << '">'
-      @list.each { |item| item.to_xml_string(str) }
-      str << '</' << el_name << '>'
+      str << ('<' << el_name << ' count="' << size.to_s << '">')
+      each { |item| item.to_xml_string(str) }
+      str << ('</' << el_name << '>')
     end
 
   end

data/lib/axlsx/util/storage.rb

@@ -6,14 +6,14 @@ module Axlsx
 
     # 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"
+    PACKING = "s32 s1 c2 l3 x16 x4 q2 l q".freeze
 
     # storage types
     TYPES = {
       :root=>5,
       :stream=>2,
       :storage=>1
-    }
+    }.freeze
 
     # Creates a byte string for this storage
     # @return [String] 
@@ -45,7 +45,7 @@ module Axlsx
     # 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
 
@@ -116,7 +116,7 @@ module Axlsx
     # 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
 

data/lib/axlsx/util/string.rb

@@ -0,0 +1,7 @@
+unless String.method_defined? :prepend
+  class String
+    def prepend(other_str)
+      insert(0, other_str)
+    end
+  end
+end

data/lib/axlsx/util/validators.rb

@@ -52,19 +52,17 @@ module Axlsx
     # @return [Boolean] true if validation succeeds.
     # @see validate_boolean
     def self.validate(name, types, v, other=false)
-      types = [types] unless types.is_a? Array
       if other.is_a?(Proc)
          raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless other.call(v)
       end
-      if v.class == Class
-        types.each { |t| return if v.ancestors.include?(t) }
-      else
-        types.each { |t| return if v.is_a?(t) }
+      v_class = v.is_a?(Class) ? v : v.class
+      Array(types).each do |t| 
+        return if v_class <= t
       end
       raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect])
     end
   end
-
+  
 
   # Requires that the value can be converted to an integer
   # @para, [Any] v the value to validate
@@ -80,12 +78,15 @@ module Axlsx
   def self.validate_angle(v)
     raise ArgumentError, (ERR_ANGLE % v.inspect) unless (v.to_i >= -5400000 && v.to_i <= 5400000)
   end
+  
+  UINT_VALIDATOR = lambda { |arg| arg.respond_to?(:>=) && arg >= 0 }
+  
   # Requires that the value is a Fixnum or Integer and is greater or equal to 0
   # @param [Any] v The value validated
   # @raise [ArgumentError] raised if the value is not a Fixnum or Integer value greater or equal to 0
   # @return [Boolean] true if the data is valid
   def self.validate_unsigned_int(v)
-    DataTypeValidator.validate(:unsigned_int, [Fixnum, Integer], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
+    DataTypeValidator.validate(:unsigned_int, Integer, v, UINT_VALIDATOR)
   end
 
   # Requires that the value is a Fixnum Integer or Float and is greater or equal to 0
@@ -93,13 +94,13 @@ module Axlsx
   # @raise [ArgumentError] raised if the value is not a Fixnun, Integer, Float value greater or equal to 0
   # @return [Boolean] true if the data is valid
   def self.validate_unsigned_numeric(v)
-    DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg.to_i >= 0 })
+    DataTypeValidator.validate(:unsigned_numeric, Numeric, v, UINT_VALIDATOR)
   end
 
-  # Requires that the value is a Fixnum or Integer
+  # Requires that the value is a Integer
   # @param [Any] v The value validated
   def self.validate_int(v)
-    DataTypeValidator.validate :unsigned_int, [Fixnum, Integer], v
+    DataTypeValidator.validate :signed_int, Integer, v
   end
 
   # Requires that the value is a form that can be evaluated as a boolean in an xml document.
@@ -107,7 +108,7 @@ module Axlsx
   # it must be one of 0, 1, "true", "false", :true, :false, true, false, "0", or "1"
   # @param [Any] v The value validated
   def self.validate_boolean(v)
-    DataTypeValidator.validate(:boolean, [Fixnum, String, Integer, Symbol, TrueClass, FalseClass], v, lambda { |arg| [0, 1, "true", "false", :true, :false, true, false, "0", "1"].include?(arg) })
+    DataTypeValidator.validate(:boolean, [String, Integer, Symbol, TrueClass, FalseClass], v, lambda { |arg| [0, 1, "true", "false", :true, :false, true, false, "0", "1"].include?(arg) })
   end
 
   # Requires that the value is a String
@@ -130,12 +131,12 @@ module Axlsx
 
   # Requires that the value is an integer ranging from 10 to 400.
   def self.validate_scale_10_400(v)
-    DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg >= 10 && arg <= 400 }
+    DataTypeValidator.validate "page_scale", Integer, v, lambda { |arg| arg >= 10 && arg <= 400 }
   end
 
   # Requires that the value is an integer ranging from 10 to 400 or 0.
   def self.validate_scale_0_10_400(v)
-    DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
+    DataTypeValidator.validate "page_scale", Integer, v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
   end
 
   # Requires that the value is one of :default, :landscape, or :portrait.
@@ -297,4 +298,10 @@ module Axlsx
   def self.validate_display_blanks_as(v)
     RestrictionValidator.validate :display_blanks_as, [:gap, :span, :zero], v
   end
+
+  # Requires that the value is one of :visible, :hidden, :very_hidden
+  def self.validate_view_visibility(v)
+    RestrictionValidator.validate :visibility, [:visible, :hidden, :very_hidden], v
+  end
+
 end

data/lib/axlsx/version.rb

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

data/lib/axlsx/workbook/defined_name.rb

@@ -24,16 +24,16 @@
 # </xsd:simpleContent>
 
 module Axlsx
-  # This element defines the defined names that are defined within this workbook. 
+  # This element defines the defined names that are defined within this workbook.
   # Defined names are descriptive text that is used to represents a cell, range of cells, formula, or constant value.
   # Use easy-to-understand names, such as Products, to refer to hard to understand ranges, such as Sales!C20:C30.
-  # A defined name in a formula can make it easier to understand the purpose of the formula. 
+  # A defined name in a formula can make it easier to understand the purpose of the formula.
   # @example
   #     The formula =SUM(FirstQuarterSales) might be easier to identify than =SUM(C20:C30
   #
   # Names are available to any sheet.
   # @example
-  #     If the name ProjectedSales refers to the range A20:A30 on the first worksheet in a workbook, 
+  #     If the name ProjectedSales refers to the range A20:A30 on the first worksheet in a workbook,
   #     you can use the name ProjectedSales on any other sheet in the same workbook to refer to range A20:A30 on the first worksheet.
   # Names can also be used to represent formulas or values that do not change (constants).
   #
@@ -71,7 +71,7 @@ module Axlsx
     #                                         applied. This represents the source data range, unfiltered.
     #                                      b. This defined name refers to a range to which an AutoFilter has been
     #                                         applied.
-    #                           _xlnm.Extract: this defined name refers to the range containing the filtered output 
+    #                           _xlnm.Extract: this defined name refers to the range containing the filtered output
     #                                           values resulting from applying an advanced filter criteria to a source range.
     #                         Miscellaneous
     #                           _xlnm.Consolidate_Area: the defined name refers to a consolidation area.
@@ -88,14 +88,14 @@ module Axlsx
     #                             This attribute is used when there is an add-in or other code project associated with the file.
     # @option [Boolean] vb_proceedure - Specifies a boolean value that indicates whether the defined name is related to an external function, command, or other executable code.
     # @option [Boolean] xlm - Specifies a boolean value that indicates whether the defined name is related to an external function, command, or other executable code.
-    # @option [Integer] function_group_id - Specifies the function group index if the defined name refers to a function. 
+    # @option [Integer] function_group_id - Specifies the function group index if the defined name refers to a function.
     #                                       The function group defines the general category for the function.
     #                                       This attribute is used when there is an add-in or other code project associated with the file.
     #                                       See Open Office XML Part 1 for more info.
     # @option [String] short_cut_key - Specifies the keyboard shortcut for the defined name.
-    # @option [Boolean] publish_to_server - Specifies a boolean value that indicates whether the defined name is included in the 
+    # @option [Boolean] publish_to_server - Specifies a boolean value that indicates whether the defined name is included in the
     #                                       version of the workbook that is published to or rendered on a Web or application server.
-    # @option [Boolean] workbook_parameter - Specifies a boolean value that indicates that the name is used as a workbook parameter on a 
+    # @option [Boolean] workbook_parameter - Specifies a boolean value that indicates that the name is used as a workbook parameter on a
     #                                        version of the workbook that is published to or rendered on a Web or application server.
     def initialize(formula, options={})
       @formula = formula
@@ -116,14 +116,13 @@ module Axlsx
     boolean_attr_accessor :workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden
 
     serializable_attributes :short_cut_key, :status_bar, :help, :description, :custom_menu, :comment,
-      :workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden, :name, :local_sheet_id
+      :workbook_parameter, :publish_to_server, :xlm, :vb_proceedure, :function, :hidden, :local_sheet_id
 
     def to_xml_string(str='')
-      raise ArgumentError, 'you must specify the name for this defined name. Please read the documentation for Axlsx::DefinedName for more details' unless name 
-      str << '<definedName '
+      raise ArgumentError, 'you must specify the name for this defined name. Please read the documentation for Axlsx::DefinedName for more details' unless name
+      str << ('<definedName ' << 'name="' << name << '" ')
       serialized_attributes str
-      str << '>' << @formula
-      str << '</definedName>'
+      str << ('>' << @formula << '</definedName>')
     end
   end
 end