caxlsx 3.4.1 → 4.1.0

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,12 +1,33 @@
+# 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
@@ -16,7 +37,6 @@ module Axlsx
         @allowed_types = [type]
       end
       @serialize_as = serialize_as unless serialize_as.nil?
-      @list = Array.new(start_size)
     end
 
     # The class constants of allowed types
@@ -37,16 +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
+      return clone if size.zero?
 
-      row_count = @list.size
-      max_column_count = @list.map { |row| row.cells.size }.max
+      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]
+          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
@@ -59,7 +79,7 @@ module Axlsx
     # Lock this list at the current size
     # @return [self]
     def lock
-      @locked_at = @list.size
+      @locked_at = size
       self
     end
 
@@ -70,22 +90,16 @@ module Axlsx
       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,8 +108,8 @@ 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
+      super
+      size - 1
     end
 
     alias :push :<<
@@ -108,17 +122,16 @@ module Axlsx
       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
@@ -126,12 +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
@@ -139,42 +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,15 +1,17 @@
+# 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
@@ -31,9 +33,9 @@ module Axlsx
 
     # 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
@@ -61,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
@@ -74,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
@@ -132,7 +133,7 @@ module Axlsx
       @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])

data/lib/axlsx/util/validators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Validate a value against a specific list of allowed values.
   class RestrictionValidator
@@ -8,7 +10,7 @@ module Axlsx
     # @raise [ArgumentError] Raised if the value provided is not in the list of choices.
     # @return [Boolean] true if validation succeeds.
     def self.validate(name, choices, v)
-      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)
+      raise ArgumentError, format(ERR_RESTRICTION, v.to_s, name, choices.inspect) unless choices.include?(v)
 
       true
     end
@@ -29,7 +31,7 @@ module Axlsx
                else
                  min < value && value < max
                end
-      raise ArgumentError, (ERR_RANGE % [value.inspect, min.to_s, max.to_s, inclusive]) unless passes
+      raise ArgumentError, format(ERR_RANGE, value.inspect, min.to_s, max.to_s, inclusive) unless passes
     end
   end
 
@@ -39,7 +41,7 @@ module Axlsx
     # @param [Regexp] regex The regular expression to evaluate
     # @param [Any] v The value to validate.
     def self.validate(name, regex, v)
-      raise ArgumentError, (ERR_REGEX % [v.inspect, regex.to_s]) unless (v.respond_to?(:to_s) && v.to_s.match(regex))
+      raise ArgumentError, format(ERR_REGEX, v.inspect, regex.to_s) unless v.respond_to?(:to_s) && regex.match?(v.to_s)
     end
   end
 
@@ -53,14 +55,14 @@ module Axlsx
     # @return [Boolean] true if validation succeeds.
     # @see validate_boolean
     def self.validate(name, types, v, other = false)
-      if other.is_a?(Proc)
-        raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless other.call(v)
+      if other.is_a?(Proc) && !other.call(v)
+        raise ArgumentError, format(ERR_TYPE, v.inspect, name, types.inspect)
       end
+
       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])
+      return if Array(types).any? { |t| v_class <= t }
+
+      raise ArgumentError, format(ERR_TYPE, v.inspect, name, types.inspect)
     end
   end
 
@@ -68,7 +70,7 @@ module Axlsx
   # @para, [Any] v the value to validate
   # @raise [ArgumentError] raised if the value cannot be converted to an integer
   def self.validate_integerish(v)
-    raise ArgumentError, (ERR_INTEGERISH % v.inspect) unless (v.respond_to?(:to_i) && v.to_i.is_a?(Integer))
+    raise ArgumentError, format(ERR_INTEGERISH, v.inspect) unless v.respond_to?(:to_i) && v.to_i.is_a?(Integer)
   end
 
   # Requires that the value is between -54000000 and 54000000
@@ -76,11 +78,11 @@ module Axlsx
   # @raise [ArgumentError] raised if the value cannot be converted to an integer between the allowed angle values for chart label rotation.
   # @return [Boolean] true if the data is valid
   def self.validate_angle(v)
-    raise ArgumentError, (ERR_ANGLE % v.inspect) unless (v.to_i >= -5400000 && v.to_i <= 5400000)
+    raise ArgumentError, format(ERR_ANGLE, v.inspect) unless v.to_i >= -5400000 && v.to_i <= 5400000
   end
 
   # Validates an unsigned intger
-  UINT_VALIDATOR = lambda { |arg| arg.respond_to?(:>=) && arg >= 0 }
+  UINT_VALIDATOR = ->(arg) { arg.respond_to?(:>=) && arg >= 0 }
 
   # Requires that the value is a Integer and is greater or equal to 0
   # @param [Any] v The value validated
@@ -104,12 +106,16 @@ module Axlsx
     DataTypeValidator.validate :signed_int, Integer, v
   end
 
+  VALID_BOOLEAN_CLASSES = [TrueClass, FalseClass, Integer, String, Symbol].freeze
+  VALID_BOOLEAN_VALUES = [true, false, 1, 0, '1', '0', 'true', 'false', :true, :false].freeze
+  BOOLEAN_VALIDATOR = ->(arg) { VALID_BOOLEAN_VALUES.include?(arg) }
+
   # Requires that the value is a form that can be evaluated as a boolean in an xml document.
   # The value must be an instance of String, Integer, Symbol, TrueClass or FalseClass and
   # 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, [String, Integer, Symbol, TrueClass, FalseClass], v, lambda { |arg| [0, 1, "true", "false", :true, :false, true, false, "0", "1"].include?(arg) })
+    DataTypeValidator.validate(:boolean, VALID_BOOLEAN_CLASSES, v, BOOLEAN_VALIDATOR)
   end
 
   # Requires that the value is a String
@@ -130,53 +136,71 @@ module Axlsx
     RegexValidator.validate "number_with_unit", /\A[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)\Z/, v
   end
 
+  SCALE_10_400_VALIDATOR = ->(arg) { arg >= 10 && arg <= 400 }
+
   # Requires that the value is an integer ranging from 10 to 400.
   def self.validate_scale_10_400(v)
-    DataTypeValidator.validate "page_scale", Integer, v, lambda { |arg| arg >= 10 && arg <= 400 }
+    DataTypeValidator.validate "page_scale", Integer, v, SCALE_10_400_VALIDATOR
   end
 
+  SCALE_0_10_400_VALIDATOR = ->(arg) { arg == 0 || (arg >= 10 && arg <= 400) }
+
   # 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", Integer, v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
+    DataTypeValidator.validate "page_scale", Integer, v, SCALE_0_10_400_VALIDATOR
   end
 
+  VALID_PAGE_ORIENTATION_VALUES = [:default, :landscape, :portrait].freeze
+
   # Requires that the value is one of :default, :landscape, or :portrait.
   def self.validate_page_orientation(v)
-    RestrictionValidator.validate "page_orientation", [:default, :landscape, :portrait], v
+    RestrictionValidator.validate "page_orientation", VALID_PAGE_ORIENTATION_VALUES, v
   end
 
+  VALID_CELL_U_VALUES = [:none, :single, :double, :singleAccounting, :doubleAccounting].freeze
+
   # Requires that the value is one of :none, :single, :double, :singleAccounting, :doubleAccounting
   def self.validate_cell_u(v)
-    RestrictionValidator.validate "cell run style u", [:none, :single, :double, :singleAccounting, :doubleAccounting], v
+    RestrictionValidator.validate "cell run style u", VALID_CELL_U_VALUES, v
   end
 
+  VALID_FAMILY_VALUES = (1..5).freeze
+
   # validates cell style family which must be between 1 and 5
   def self.validate_family(v)
-    RestrictionValidator.validate "cell run style family", 1..5, v
+    RestrictionValidator.validate "cell run style family", VALID_FAMILY_VALUES, v
   end
 
+  VALID_PATTERN_TYPE_VALUES = [:none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown, :darkUp, :darkGrid,
+                               :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625].freeze
+
   # Requires that the value is valid pattern type.
   # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
   # :darkUp, :darkGrid, :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, or :gray0625.
   # @param [Any] v The value validated
   def self.validate_pattern_type(v)
-    RestrictionValidator.validate :pattern_type, [:none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown, :darkUp, :darkGrid,
-                                                  :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625], v
+    RestrictionValidator.validate :pattern_type, VALID_PATTERN_TYPE_VALUES, v
   end
 
+  VALID_TIME_PERIOD_TYPE_VALUES = [:today, :yesterday, :tomorrow, :last7Days, :thisMonth, :lastMonth, :nextMonth, :thisWeek, :lastWeek, :nextWeek].freeze
+
   # Requires that the value is one of the ST_TimePeriod types
   # valid time period types are today, yesterday, tomorrow, last7Days,
   # thisMonth, lastMonth, nextMonth, thisWeek, lastWeek, nextWeek
   def self.validate_time_period_type(v)
-    RestrictionValidator.validate :time_period_type, [:today, :yesterday, :tomorrow, :last7Days, :thisMonth, :lastMonth, :nextMonth, :thisWeek, :lastWeek, :nextWeek], v
+    RestrictionValidator.validate :time_period_type, VALID_TIME_PERIOD_TYPE_VALUES, v
   end
 
+  VALID_ICON_SET_VALUES = ["3Arrows", "3ArrowsGray", "3Flags", "3TrafficLights1", "3TrafficLights2", "3Signs", "3Symbols", "3Symbols2", "4Arrows", "4ArrowsGray", "4RedToBlack", "4Rating", "4TrafficLights", "5Arrows", "5ArrowsGray", "5Rating", "5Quarters"].freeze
+
   # Requires that the value is one of the valid ST_IconSet types
   # Allowed values are: 3Arrows, 3ArrowsGray, 3Flags, 3TrafficLights1, 3TrafficLights2, 3Signs, 3Symbols, 3Symbols2, 4Arrows, 4ArrowsGray, 4RedToBlack, 4Rating, 4TrafficLights, 5Arrows, 5ArrowsGray, 5Rating, 5Quarters
   def self.validate_icon_set(v)
-    RestrictionValidator.validate :iconSet, ["3Arrows", "3ArrowsGray", "3Flags", "3TrafficLights1", "3TrafficLights2", "3Signs", "3Symbols", "3Symbols2", "4Arrows", "4ArrowsGray", "4RedToBlack", "4Rating", "4TrafficLights", "5Arrows", "5ArrowsGray", "5Rating", "5Quarters"], v
+    RestrictionValidator.validate :iconSet, VALID_ICON_SET_VALUES, v
   end
 
+  VALID_CONDITIONAL_FORMATTING_TYPE_VALUES = [:expression, :cellIs, :colorScale, :dataBar, :iconSet, :top10, :uniqueValues, :duplicateValues, :containsText, :notContainsText, :beginsWith, :endsWith, :containsBlanks, :notContainsBlanks, :containsErrors, :notContainsErrors, :timePeriod, :aboveAverage].freeze
+
   # Requires that the value is valid conditional formatting type.
   # valid types must be one of expression, cellIs, colorScale,
   # dataBar, iconSet, top10, uniqueValues, duplicateValues,
@@ -185,131 +209,167 @@ module Axlsx
   # notContainsErrors, timePeriod, aboveAverage
   # @param [Any] v The value validated
   def self.validate_conditional_formatting_type(v)
-    RestrictionValidator.validate :conditional_formatting_type, [:expression, :cellIs, :colorScale, :dataBar, :iconSet, :top10, :uniqueValues, :duplicateValues, :containsText, :notContainsText, :beginsWith, :endsWith, :containsBlanks, :notContainsBlanks, :containsErrors, :notContainsErrors, :timePeriod, :aboveAverage], v
+    RestrictionValidator.validate :conditional_formatting_type, VALID_CONDITIONAL_FORMATTING_TYPE_VALUES, v
   end
 
+  VALID_CONDITION_FORMATTING_VALUE_OBJECT_TYPE_VALUES = [:num, :percent, :max, :min, :formula, :percentile].freeze
+
   # Requires thatt he value is a valid conditional formatting value object type.
   # valid types must be one of num, percent, max, min, formula and percentile
   def self.validate_conditional_formatting_value_object_type(v)
-    RestrictionValidator.validate :conditional_formatting_value_object_type, [:num, :percent, :max, :min, :formula, :percentile], v
+    RestrictionValidator.validate :conditional_formatting_value_object_type, VALID_CONDITION_FORMATTING_VALUE_OBJECT_TYPE_VALUES, v
   end
 
+  VALID_CONDITIONAL_FORMATTING_OPERATOR_VALUES = [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween, :containsText, :notContains, :beginsWith, :endsWith].freeze
+
   # Requires that the value is valid conditional formatting operator.
   # valid operators must be one of lessThan, lessThanOrEqual, equal,
   # notEqual, greaterThanOrEqual, greaterThan, between, notBetween,
   # containsText, notContains, beginsWith, endsWith
   # @param [Any] v The value validated
   def self.validate_conditional_formatting_operator(v)
-    RestrictionValidator.validate :conditional_formatting_type, [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween, :containsText, :notContains, :beginsWith, :endsWith], v
+    RestrictionValidator.validate :conditional_formatting_type, VALID_CONDITIONAL_FORMATTING_OPERATOR_VALUES, v
   end
 
+  VALID_GRADIENT_TYPE_VALUES = [:linear, :path].freeze
+
   # Requires that the value is a gradient_type.
   # valid types are :linear and :path
   # @param [Any] v The value validated
   def self.validate_gradient_type(v)
-    RestrictionValidator.validate :gradient_type, [:linear, :path], v
+    RestrictionValidator.validate :gradient_type, VALID_GRADIENT_TYPE_VALUES, v
   end
 
+  VALID_SCATTER_STYLE_VALUES = [:none, :line, :lineMarker, :marker, :smooth, :smoothMarker].freeze
+
   # Requires that the value is a valid scatterStyle
   # must be one of :none | :line | :lineMarker | :marker | :smooth | :smoothMarker
   # must be one of "none" | "line" | "lineMarker" | "marker" | "smooth" | "smoothMarker"
   # @param [Symbol|String] v the value to validate
   def self.validate_scatter_style(v)
-    Axlsx::RestrictionValidator.validate "ScatterChart.scatterStyle", [:none, :line, :lineMarker, :marker, :smooth, :smoothMarker], v.to_sym
+    Axlsx::RestrictionValidator.validate "ScatterChart.scatterStyle", VALID_SCATTER_STYLE_VALUES, v.to_sym
   end
 
+  VALID_HORIZONTAL_ALIGNMENT_VALUES = [:general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed].freeze
+
   # Requires that the value is a valid horizontal_alignment
   # :general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed are allowed
   # @param [Any] v The value validated
   def self.validate_horizontal_alignment(v)
-    RestrictionValidator.validate :horizontal_alignment, [:general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed], v
+    RestrictionValidator.validate :horizontal_alignment, VALID_HORIZONTAL_ALIGNMENT_VALUES, v
   end
 
+  VALID_VERTICAL_ALIGNMENT_VALUES = [:top, :center, :bottom, :justify, :distributed].freeze
+
   # Requires that the value is a valid vertical_alignment
   # :top, :center, :bottom, :justify, :distributed are allowed
   # @param [Any] v The value validated
   def self.validate_vertical_alignment(v)
-    RestrictionValidator.validate :vertical_alignment, [:top, :center, :bottom, :justify, :distributed], v
+    RestrictionValidator.validate :vertical_alignment, VALID_VERTICAL_ALIGNMENT_VALUES, v
   end
 
+  VALID_CONTENT_TYPE_VALUES = [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, JPEG_CT, GIF_CT, PNG_CT, DRAWING_CT, COMMENT_CT, VML_DRAWING_CT, PIVOT_TABLE_CT, PIVOT_TABLE_CACHE_DEFINITION_CT].freeze
+
   # Requires that the value is a valid content_type
   # TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, DRAWING_CT, COMMENT_CT are allowed
   # @param [Any] v The value validated
   def self.validate_content_type(v)
-    RestrictionValidator.validate :content_type, [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, JPEG_CT, GIF_CT, PNG_CT, DRAWING_CT, COMMENT_CT, VML_DRAWING_CT, PIVOT_TABLE_CT, PIVOT_TABLE_CACHE_DEFINITION_CT], v
+    RestrictionValidator.validate :content_type, VALID_CONTENT_TYPE_VALUES, v
   end
 
+  VALID_RELATIONSHIP_TYPE_VALUES = [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R, COMMENT_R, VML_DRAWING_R, COMMENT_R_NULL, PIVOT_TABLE_R, PIVOT_TABLE_CACHE_DEFINITION_R].freeze
+
   # Requires that the value is a valid relationship_type
   # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R are allowed
   # @param [Any] v The value validated
   def self.validate_relationship_type(v)
-    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R, COMMENT_R, VML_DRAWING_R, COMMENT_R_NULL, PIVOT_TABLE_R, PIVOT_TABLE_CACHE_DEFINITION_R], v
+    RestrictionValidator.validate :relationship_type, VALID_RELATIONSHIP_TYPE_VALUES, v
   end
 
+  VALID_TABLE_ELEMENT_TYPE_VALUES = [:wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues].freeze
+
   # Requires that the value is a valid table element type
   # :wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues are allowed
   # @param [Any] v The value validated
   def self.validate_table_element_type(v)
-    RestrictionValidator.validate :table_element_type, [:wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues], v
+    RestrictionValidator.validate :table_element_type, VALID_TABLE_ELEMENT_TYPE_VALUES, v
   end
 
+  VALID_DATA_VALIDATION_ERROR_STYLE_VALUES = [:information, :stop, :warning].freeze
+
   # Requires that the value is a valid data_validation_error_style
   # :information, :stop, :warning
   # @param [Any] v The value validated
   def self.validate_data_validation_error_style(v)
-    RestrictionValidator.validate :validate_data_validation_error_style, [:information, :stop, :warning], v
+    RestrictionValidator.validate :validate_data_validation_error_style, VALID_DATA_VALIDATION_ERROR_STYLE_VALUES, v
   end
 
+  VALID_DATA_VALIDATION_OPERATOR_VALUES = [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween].freeze
+
   # Requires that the value is valid data validation operator.
   # valid operators must be one of lessThan, lessThanOrEqual, equal,
   # notEqual, greaterThanOrEqual, greaterThan, between, notBetween
   # @param [Any] v The value validated
   def self.validate_data_validation_operator(v)
-    RestrictionValidator.validate :data_validation_operator, [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween], v
+    RestrictionValidator.validate :data_validation_operator, VALID_DATA_VALIDATION_OPERATOR_VALUES, v
   end
 
+  VALID_DATA_VALIDATION_TYPE_VALUES = [:custom, :data, :decimal, :list, :none, :textLength, :date, :time, :whole].freeze
+
   # Requires that the value is valid data validation type.
   # valid types must be one of custom, data, decimal, list, none, textLength, time, whole
   # @param [Any] v The value validated
   def self.validate_data_validation_type(v)
-    RestrictionValidator.validate :data_validation_type, [:custom, :data, :decimal, :list, :none, :textLength, :date, :time, :whole], v
+    RestrictionValidator.validate :data_validation_type, VALID_DATA_VALIDATION_TYPE_VALUES, v
   end
 
+  VALID_SHEET_VIEW_TYPE_VALUES = [:normal, :page_break_preview, :page_layout].freeze
+
   # Requires that the value is a valid sheet view type.
   # valid types must be one of normal, page_break_preview, page_layout
   # @param [Any] v The value validated
   def self.validate_sheet_view_type(v)
-    RestrictionValidator.validate :sheet_view_type, [:normal, :page_break_preview, :page_layout], v
+    RestrictionValidator.validate :sheet_view_type, VALID_SHEET_VIEW_TYPE_VALUES, v
   end
 
+  VALID_PANE_TYPE_VALUES = [:bottom_left, :bottom_right, :top_left, :top_right].freeze
+
   # Requires that the value is a valid active pane type.
   # valid types must be one of bottom_left, bottom_right, top_left, top_right
   # @param [Any] v The value validated
   def self.validate_pane_type(v)
-    RestrictionValidator.validate :active_pane_type, [:bottom_left, :bottom_right, :top_left, :top_right], v
+    RestrictionValidator.validate :active_pane_type, VALID_PANE_TYPE_VALUES, v
   end
 
+  VALID_SPLIT_STATE_TYPE_VALUES = [:frozen, :frozen_split, :split].freeze
+
   # Requires that the value is a valid split state type.
   # valid types must be one of frozen, frozen_split, split
   # @param [Any] v The value validated
   def self.validate_split_state_type(v)
-    RestrictionValidator.validate :split_state_type, [:frozen, :frozen_split, :split], v
+    RestrictionValidator.validate :split_state_type, VALID_SPLIT_STATE_TYPE_VALUES, v
   end
 
+  VALID_DISPLAY_BLANK_AS_VALUES = [:gap, :span, :zero].freeze
+
   # 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
+    RestrictionValidator.validate :display_blanks_as, VALID_DISPLAY_BLANK_AS_VALUES, v
   end
 
+  VALID_VIEW_VISIBILITY_VALUES = [:visible, :hidden, :very_hidden].freeze
+
   # 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
+    RestrictionValidator.validate :visibility, VALID_VIEW_VISIBILITY_VALUES, v
   end
 
+  VALID_MARKER_SYMBOL_VALUES = [:default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x].freeze
+
   # Requires that the value is one of :default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x
   def self.validate_marker_symbol(v)
-    RestrictionValidator.validate :marker_symbol, [:default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x], v
+    RestrictionValidator.validate :marker_symbol, VALID_MARKER_SYMBOL_VALUES, v
   end
 end