caxlsx 2.0.2

data/lib/axlsx/util/validators.rb

@@ -0,0 +1,300 @@
+# encoding: UTF-8
+module Axlsx
+  # Validate a value against a specific list of allowed values.
+  class RestrictionValidator
+    # Perform validation
+    # @param [String] name The name of what is being validatied. This is included in the error message
+    # @param [Array] choices The list of choices to validate against
+    # @param [Any] v The value to be validated
+    # @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)
+      true
+    end
+  end
+
+  # Validate that the value provided is between a specific range
+  # Note that no data conversions will be done for you!
+  # Comparisons will be made using < and > or <= and <= when the inclusive parameter is true
+  class RangeValidator
+    # @param [String] name The name of what is being validated
+    # @param [Any] min The minimum allowed value
+    # @param [Any] max The maximum allowed value
+    # @param [Any] value The value to be validated
+    # @param [Boolean] inclusive Flag indicating if the comparison should be inclusive.
+    def self.validate(name, min, max, value, inclusive = true)
+      passes = if inclusive
+                 min <= value && value <= max
+               else
+                 min < value && value < max
+               end
+      raise ArgumentError, (ERR_RANGE % [value.inspect, min.to_s, max.to_s, inclusive]) unless passes
+    end
+  end
+  # Validates the value against the regular expression provided.
+  class RegexValidator
+    # @param [String] name The name of what is being validated. This is included in the output when the value is invalid
+    # @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))
+    end
+  end
+
+  # Validate that the class of the value provided is either an instance or the class of the allowed types and that any specified additional validation returns true.
+  class DataTypeValidator
+    # Perform validation
+    # @param [String] name The name of what is being validated. This is included in the error message
+    # @param [Array, Class] types A single class or array of classes that the value is validated against.
+    # @param [Block] other Any block that must evaluate to true for the value to be valid
+    # @raise [ArugumentError] Raised if the class of the value provided is not in the specified array of types or the block passed returns false
+    # @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) }
+      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
+  # @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))
+  end
+
+  # Requires that the value is between -54000000 and 54000000
+  # @param [Any] v The value validated
+  # @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)
+  end
+  # 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 })
+  end
+
+  # Requires that the value is a Fixnum Integer or Float and is greater or equal to 0
+  # @param [Any] v The value validated
+  # @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 })
+  end
+
+  # Requires that the value is a Fixnum or Integer
+  # @param [Any] v The value validated
+  def self.validate_int(v)
+    DataTypeValidator.validate :unsigned_int, [Fixnum, Integer], v
+  end
+
+  # 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 Fixnum, 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, [Fixnum, 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
+  # @param [Any] v The value validated
+  def self.validate_string(v)
+    DataTypeValidator.validate :string, String, v
+  end
+
+  # Requires that the value is a Float
+  # @param [Any] v The value validated
+  def self.validate_float(v)
+    DataTypeValidator.validate :float, Float, v
+  end
+
+  # Requires that the value is a string containing a positive decimal number followed by one of the following units:
+  # "mm", "cm", "in", "pt", "pc", "pi"
+  def self.validate_number_with_unit(v)
+    RegexValidator.validate "number_with_unit", /\A[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)\Z/, v
+  end
+
+  # 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 }
+  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) }
+  end
+
+  # 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
+  end
+  # 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
+  end
+
+  # 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
+  end
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # Requires that the value is valid conditional formatting type.
+  # valid types must be one of expression, cellIs, colorScale,
+  # dataBar, iconSet, top10, uniqueValues, duplicateValues,
+  # containsText, notContainsText, beginsWith, endsWith,
+  # containsBlanks, notContainsBlanks, containsErrors,
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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, :time, :whole], v
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+end

data/lib/axlsx/version.rb

@@ -0,0 +1,5 @@
+module Axlsx
+
+  # The current version
+  VERSION = "2.0.2"
+end

data/lib/axlsx/workbook/defined_name.rb

@@ -0,0 +1,129 @@
+#  <definedNames>
+#    <definedName name="_xlnm.Print_Titles" localSheetId="0">Sheet1!$1:$1</definedName>
+#  </definedNames>
+
+#<xsd:complexType name="CT_DefinedName">
+# <xsd:simpleContent>
+# <xsd:extension base="ST_Formula">
+# <xsd:attribute name="name" type="s:ST_Xstring" use="required"/>
+# <xsd:attribute name="comment" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="customMenu" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="description" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="help" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="statusBar" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="localSheetId" type="xsd:unsignedInt" use="optional"/>
+# <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/>
+# <xsd:attribute name="function" type="xsd:boolean" use="optional" default="false"/>
+# <xsd:attribute name="vbProcedure" type="xsd:boolean" use="optional" default="false"/>
+# <xsd:attribute name="xlm" type="xsd:boolean" use="optional" default="false"/>
+# <xsd:attribute name="functionGroupId" type="xsd:unsignedInt" use="optional"/>
+# <xsd:attribute name="shortcutKey" type="s:ST_Xstring" use="optional"/>
+# <xsd:attribute name="publishToServer" type="xsd:boolean" use="optional" default="false"/>
+# <xsd:attribute name="workbookParameter" type="xsd:boolean" use="optional" default="false"/>
+# </xsd:extenstion>
+# </xsd:simpleContent>
+
+module Axlsx
+  # 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. 
+  # @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, 
+  #     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).
+  #
+  # @example
+  #     The name SalesTax can be used to represent the sales tax amount (such as 6.2 percent) applied to sales transactions.
+  # You can also link to a defined name in another workbook, or define a name that refers to cells in another workbook.
+  #
+  # @example
+  #     The formula =SUM(Sales.xls!ProjectedSales) refers to the named range ProjectedSales in the workbook named Sales.
+  # A compliant producer or consumer considers a defined name in the range A1-XFD1048576 to be an error.
+  # All other names outside this range can be defined as names and overrides a cell reference if an ambiguity exists.
+  #
+  # @example
+  #     For clarification: LOG10 is always a cell reference, LOG10() is always formula, LOGO1000 can be a defined name that overrides a cell reference.
+  class DefinedName
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+    # creates a new DefinedName.
+    # @param [String] formula - the formula the defined name references
+    # @param [Hash] options - A hash of key/value pairs that will be mapped to this instances attributes.
+    #
+    # @option [String] name - Specifies the name that appears in the user interface for the defined name.
+    #                         This attribute is required.
+    #                         The following built-in names are defined in this SpreadsheetML specification:
+    #                         Print
+    #                           _xlnm.Print_Area: this defined name specifies the workbook's print area.
+    #                           _xlnm.Print_Titles: this defined name specifies the row(s) or column(s) to repeat
+    #                                                the top of each printed page.
+    #                         Filter & Advanced Filter
+    #                           _xlnm.Criteria: this defined name refers to a range containing the criteria values
+    #                                  to be used in applying an advanced filter to a range of data.
+    #                           _xlnm._FilterDatabase: can be one of the following
+    #                                     a. this defined name refers to a range to which an advanced filter has been
+    #                                         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 
+    #                                           values resulting from applying an advanced filter criteria to a source range.
+    #                         Miscellaneous
+    #                           _xlnm.Consolidate_Area: the defined name refers to a consolidation area.
+    #                           _xlnm.Database: the range specified in the defined name is from a database data source.
+    #                           _xlnm.Sheet_Title: the defined name refers to a sheet title.
+    # @option [String] comment - A comment to optionally associate with the name
+    # @option [String] custom_menu - The menu text for the defined name
+    # @option [String] description - An optional description for the defined name
+    # @option [String] help - The help topic to display for this defined name
+    # @option [String] status_bar - The text to display on the application status bar when this defined name has focus
+    # @option [String] local_sheet_id - Specifies the sheet index in this workbook where data from an external reference is displayed
+    # @option [Boolean] hidden - Specifies a boolean value that indicates whether the defined name is hidden in the user interface.
+    # @option [Boolean] function - Specifies a boolean value that indicates that the defined name refers to a user-defined function.
+    #                             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. 
+    #                                       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 
+    #                                       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 
+    #                                        version of the workbook that is published to or rendered on a Web or application server.
+    def initialize(formula, options={})
+      @formula = formula
+      parse_options options
+    end
+
+    attr_reader :local_sheet_id
+
+    # The local sheet index (0-based)
+    # @param [Integer] value the unsigned integer index of the sheet this defined_name applies to.
+    def local_sheet_id=(value)
+      Axlsx::validate_unsigned_int(value)
+      @local_sheet_id = value
+    end
+
+    string_attr_accessor :short_cut_key, :status_bar, :help, :description, :custom_menu, :comment, :name, :formula
+
+    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
+
+    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 '
+      serialized_attributes str
+      str << '>' << @formula
+      str << '</definedName>'
+    end
+  end
+end

data/lib/axlsx/workbook/defined_names.rb

@@ -0,0 +1,21 @@
+module Axlsx
+  # a simple types list of DefinedName objects
+  class DefinedNames < SimpleTypedList
+
+    # creates the DefinedNames object
+    def initialize
+      super DefinedName
+    end
+
+    # Serialize to xml
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      return if @list.empty?
+      str << "<definedNames>"
+      each { |defined_name| defined_name.to_xml_string(str) }
+      str << '</definedNames>'
+    end
+  end
+end
+