xml-simple 1.0.11 → 1.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83fdfe764b21f66e184a245f9f908d2ed9678edd6d0734a33cac93030449c324
+  data.tar.gz: ecd9ac1ed12a0fb03f2b8fee924db65ec844dffda64f9553b76a626b2532635a
+SHA512:
+  metadata.gz: 652f1cbb3ef139e5450cdd2ad01fc4a22e23ec3174bd3d88c58b973f1c5c955673a365bbaa3e3c910ad60c190994e3e0e88fd4678af69d5981aadd2b0ecb019d
+  data.tar.gz: 40e7a0e3e6b0a42d178e8f6b782aca2e8a6d65ce87ab8aa06953d7dfe41b4ce115793018df2bab0b6238298d1c35ccdaa2fee9a0ea46ac927f2d2238d2f0146d

data/lib/xmlsimple.rb

@@ -1,7 +1,7 @@
 # = XmlSimple
 #
 # Author::    Maik Schmidt <contact@maik-schmidt.de>
-# Copyright:: Copyright (c) 2003-2006 Maik Schmidt
+# Copyright:: Copyright (c) 2003-2021 Maik Schmidt
 # License::   Distributes under the same terms as Ruby.
 #
 require 'rexml/document'
@@ -11,7 +11,7 @@ require 'stringio'
 class XmlSimple
   include REXML
 
-  @@VERSION = '1.0.11'
+  @@VERSION = '1.1.9'
 
   # A simple cache for XML documents that were already transformed
   # by xml_in.
@@ -23,7 +23,7 @@ class XmlSimple
     end
 
     # Saves a data structure into a file.
-    # 
+    #
     # data::
     #   Data structure to be saved.
     # filename::
@@ -121,12 +121,12 @@ class XmlSimple
   # Create a "global" cache.
   @@cache = Cache.new
 
-  # Creates and intializes a new XmlSimple object.
-  # 
+  # Creates and initializes a new XmlSimple object.
+  #
   # defaults::
   #   Default values for options.
   def initialize(defaults = nil)
-    unless defaults.nil? || defaults.instance_of?(Hash)
+    unless defaults.nil? || defaults.is_a?(Hash)
       raise ArgumentError, "Options have to be a Hash."
     end
     @default_options = normalize_option_names(defaults, (KNOWN_OPTIONS['in'] + KNOWN_OPTIONS['out']).uniq)
@@ -143,7 +143,7 @@ class XmlSimple
   #   - filename: Tries to load and parse filename.
   #   - IO object: Reads from object until EOF is detected and parses result.
   #   - XML string: Parses string.
-  #   
+  #
   # options::
   #   Options to be used.
   def xml_in(string = nil, options = nil)
@@ -151,7 +151,7 @@ class XmlSimple
 
     # If no XML string or filename was supplied look for scriptname.xml.
     if string.nil?
-      string = File::basename($0)
+      string = File::basename($0).dup
       string.sub!(/\.[^.]+$/, '')
       string += '.xml'
 
@@ -159,11 +159,11 @@ class XmlSimple
       @options['searchpath'].unshift(directory) unless directory.nil?
     end
 
-    if string.instance_of?(String)
+    if string.is_a?(String)
       if string =~ /<.*?>/m
         @doc = parse(string)
       elsif string == '-'
-        @doc = parse($stdin.readlines.to_s)
+        @doc = parse($stdin.read)
       else
         filename = find_xml_file(string, @options['searchpath'])
 
@@ -182,13 +182,13 @@ class XmlSimple
             return content if content
           }
         end
-        
+
         @doc = load_xml_file(filename)
       end
-    elsif string.kind_of?(IO) || string.kind_of?(StringIO)
-      @doc = parse(string.readlines.to_s)
+    elsif string.respond_to?(:read)
+      @doc = parse(string.read)
     else
-      raise ArgumentError, "Could not parse object of type: <#{string.type}>."
+      raise ArgumentError, "Could not parse object of type: <#{string.class}>."
     end
 
     result = collapse(@doc.root)
@@ -202,7 +202,7 @@ class XmlSimple
     xml_simple = XmlSimple.new
     xml_simple.xml_in(string, options)
   end
-  
+
   # Converts a data structure into an XML document.
   #
   # ref::
@@ -211,7 +211,7 @@ class XmlSimple
   #   Options to be used.
   def xml_out(ref, options = nil)
     handle_options('out', options)
-    if ref.instance_of?(Array)
+    if ref.is_a?(Array)
       ref = { @options['anonymoustag'] => ref }
     end
 
@@ -222,7 +222,7 @@ class XmlSimple
         @options['rootname'] = keys[0]
       end
     elsif @options['rootname'] == ''
-      if ref.instance_of?(Hash)
+      if ref.is_a?(Hash)
         refsave = ref
         ref = {}
         refsave.each { |key, value|
@@ -258,21 +258,21 @@ class XmlSimple
     xml_simple = XmlSimple.new
     xml_simple.xml_out(hash, options)
   end
-  
+
   private
 
   # Declare options that are valid for xml_in and xml_out.
   KNOWN_OPTIONS = {
     'in'  => %w(
-      keyattr keeproot forcecontent contentkey noattr
-      searchpath forcearray suppressempty anonymoustag
-      cache grouptags normalisespace normalizespace
-      variables varattr keytosymbol
+      keyattr keeproot forcecontent contentkey noattr searchpath
+      forcearray suppressempty anonymoustag cache grouptags
+      normalisespace normalizespace variables varattr keytosymbol
+      attrtosymbol attrprefix conversions kebabtosnakecase
     ),
     'out' => %w(
       keyattr keeproot contentkey noattr rootname
       xmldeclaration outputfile noescape suppressempty
-      anonymoustag indent grouptags noindent
+      anonymoustag indent grouptags noindent attrprefix selfclose
     )
   }
 
@@ -285,11 +285,13 @@ class XmlSimple
   DEF_FORCE_ARRAY     = true
   DEF_INDENTATION     = '  '
   DEF_KEY_TO_SYMBOL   = false
-  
+  DEF_ATTR_TO_SYMBOL  = false
+  DEF_KEBAB_TO_SNAKE  = false
+
   # Normalizes option names in a hash, i.e., turns all
   # characters to lower case and removes all underscores.
-  # Additionally, this method checks, if an unknown option
-  # was used and raises an according exception.
+  # Additionally, this method checks if an unknown option
+  # was used, and raises an according exception.
   #
   # options::
   #   Hash to be normalized.
@@ -299,18 +301,17 @@ class XmlSimple
     return nil if options.nil?
     result = Hash.new
     options.each { |key, value|
-      lkey = key.downcase
-      lkey.gsub!(/_/, '')
+      lkey = key.to_s.downcase.gsub(/_/, '')
       if !known_options.member?(lkey)
-        raise ArgumentError, "Unrecognised option: #{lkey}."
+        raise ArgumentError, "Unrecognized option: #{lkey}."
       end
       result[lkey] = value
     }
     result
   end
-  
+
   # Merges a set of options with the default options.
-  # 
+  #
   # direction::
   #  'in':  If options should be handled for xml_in.
   #  'out': If options should be handled for xml_out.
@@ -319,7 +320,7 @@ class XmlSimple
   def handle_options(direction, options)
     @options = options || Hash.new
 
-    raise ArgumentError, "Options must be a Hash!" unless @options.instance_of?(Hash)
+    raise ArgumentError, "Options must be a Hash!" unless @options.is_a?(Hash)
 
     unless KNOWN_OPTIONS.has_key?(direction)
       raise ArgumentError, "Unknown direction: <#{direction}>."
@@ -354,6 +355,8 @@ class XmlSimple
 
     @options['keytosymbol'] = DEF_KEY_TO_SYMBOL unless @options.has_key?('keytosymbol')
 
+    @options['attrtosymbol'] = DEF_ATTR_TO_SYMBOL unless @options.has_key?('attrtosymbol')
+
     if @options.has_key?('contentkey')
       if @options['contentkey'] =~ /^-(.*)$/
         @options['contentkey']    = $1
@@ -369,7 +372,7 @@ class XmlSimple
     @options['normalisespace'] = 0 if @options['normalisespace'].nil?
 
     if @options.has_key?('searchpath')
-      unless @options['searchpath'].instance_of?(Array)
+      unless @options['searchpath'].is_a?(Array)
         @options['searchpath'] = [ @options['searchpath'] ]
       end
     else
@@ -394,13 +397,13 @@ class XmlSimple
       if !scalar(@options['keyattr'])
         # Convert keyattr => { elem => '+attr' }
         #      to keyattr => { elem => ['attr', '+'] }
-        if @options['keyattr'].instance_of?(Hash)
+        if @options['keyattr'].is_a?(Hash)
           @options['keyattr'].each { |key, value|
             if value =~ /^([-+])?(.*)$/
               @options['keyattr'][key] = [$2, $1 ? $1 : '']
             end
           }
-        elsif !@options['keyattr'].instance_of?(Array)
+        elsif !@options['keyattr'].is_a?(Array)
           raise ArgumentError, "'keyattr' must be String, Hash, or Array!"
         end
       else
@@ -411,17 +414,17 @@ class XmlSimple
     end
 
     if @options.has_key?('forcearray')
-      if @options['forcearray'].instance_of?(Regexp)
+      if @options['forcearray'].is_a?(Regexp)
         @options['forcearray'] = [ @options['forcearray'] ]
       end
 
-      if @options['forcearray'].instance_of?(Array)
+      if @options['forcearray'].is_a?(Array)
         force_list = @options['forcearray']
         unless force_list.empty?
           @options['forcearray'] = {}
           force_list.each { |tag|
-            if tag.instance_of?(Regexp)
-              unless @options['forcearray']['_regex'].instance_of?(Array)
+            if tag.is_a?(Regexp)
+              unless @options['forcearray']['_regex'].is_a?(Array)
                 @options['forcearray']['_regex'] = []
               end
               @options['forcearray']['_regex'] << tag
@@ -439,11 +442,11 @@ class XmlSimple
       @options['forcearray'] = DEF_FORCE_ARRAY
     end
 
-    if @options.has_key?('grouptags') && !@options['grouptags'].instance_of?(Hash)
+    if @options.has_key?('grouptags') && !@options['grouptags'].is_a?(Hash)
       raise ArgumentError, "Illegal value for 'GroupTags' option - expected a Hash."
     end
 
-    if @options.has_key?('variables') && !@options['variables'].instance_of?(Hash)
+    if @options.has_key?('variables') && !@options['variables'].is_a?(Hash)
       raise ArgumentError, "Illegal value for 'Variables' option - expected a Hash."
     end
 
@@ -452,6 +455,8 @@ class XmlSimple
     elsif @options.has_key?('varattr')
       @_var_values = {}
     end
+
+    @options['kebabtosnakecase'] = DEF_KEBAB_TO_SNAKE unless @options.has_key?('kebabtosnakecase')
   end
 
   # Actually converts an XML document element into a data structure.
@@ -480,7 +485,7 @@ class XmlSimple
         result[@options['contentkey']] = content
       end
     elsif element.has_text? # i.e. it has only text.
-      return collapse_text_node(result, element)
+      return collapse_text_node(result, element) # calls merge, which converts
     end
 
     # Turn Arrays into Hashes if key fields present.
@@ -489,18 +494,21 @@ class XmlSimple
     # Disintermediate grouped tags.
     if @options.has_key?('grouptags')
       result.each { |key, value|
-        next unless (value.instance_of?(Hash) && (value.size == 1))
+        # In results, key should already be converted
+        raise("Unconverted key '#{key}' found. Should be '#{kebab_to_snake_case key}'.") if (key != kebab_to_snake_case(key))
+        next unless (value.is_a?(Hash) && (value.size == 1))
         child_key, child_value = value.to_a[0]
+        child_key = kebab_to_snake_case child_key # todo test whether necessary
         if @options['grouptags'][key] == child_key
           result[key] = child_value
         end
       }
     end
-    
-    # Fold Hases containing a single anonymous Array up into just the Array.
-    if count == 1 
+
+    # Fold Hashes containing a single anonymous Array up into just the Array.
+    if count == 1
       anonymoustag = @options['anonymoustag']
-      if result.has_key?(anonymoustag) && result[anonymoustag].instance_of?(Array)
+      if result.has_key?(anonymoustag) && result[anonymoustag].is_a?(Array)
         return result[anonymoustag]
       end
     end
@@ -538,16 +546,17 @@ class XmlSimple
   end
 
   # Folds all arrays in a Hash.
-  # 
+  #
   # hash::
   #   Hash to be folded.
   def fold_arrays(hash)
     fold_amount = 0
     keyattr = @options['keyattr']
-    if (keyattr.instance_of?(Array) || keyattr.instance_of?(Hash))
+    if (keyattr.is_a?(Array) || keyattr.is_a?(Hash))
       hash.each { |key, value|
-        if value.instance_of?(Array)
-          if keyattr.instance_of?(Array)
+        key = kebab_to_snake_case key
+        if value.is_a?(Array)
+          if keyattr.is_a?(Array)
             hash[key] = fold_array(value)
           else
             hash[key] = fold_array_by_name(key, value)
@@ -568,13 +577,13 @@ class XmlSimple
   def fold_array(array)
     hash = Hash.new
     array.each { |x|
-      return array unless x.instance_of?(Hash)
+      return array unless x.is_a?(Hash)
       key_matched = false
       @options['keyattr'].each { |key|
         if x.has_key?(key)
           key_matched = true
           value = x[key]
-          return array if value.instance_of?(Hash) || value.instance_of?(Array)
+          return array if value.is_a?(Hash) || value.is_a?(Array)
           value = normalise_space(value) if @options['normalisespace'] == 1
           x.delete(key)
           hash[value] = x
@@ -586,7 +595,7 @@ class XmlSimple
     hash = collapse_content(hash) if @options['collapseagain']
     hash
   end
-  
+
   # Folds an Array to a Hash, if possible. Folding happens
   # according to the content of keyattr, which has to be
   # a Hash.
@@ -601,9 +610,9 @@ class XmlSimple
 
     hash = Hash.new
     array.each { |x|
-      if x.instance_of?(Hash) && x.has_key?(key)
+      if x.is_a?(Hash) && x.has_key?(key)
         value = x[key]
-        return array if value.instance_of?(Hash) || value.instance_of?(Array)
+        return array if value.is_a?(Hash) || value.is_a?(Array)
         value = normalise_space(value) if @options['normalisespace'] == 1
         hash[value] = x
         hash[value]["-#{key}"] = hash[value][key] if flag == '-'
@@ -624,12 +633,12 @@ class XmlSimple
   def collapse_content(hash)
     content_key = @options['contentkey']
     hash.each_value { |value|
-      return hash unless value.instance_of?(Hash) && value.size == 1 && value.has_key?(content_key)
+      return hash unless value.is_a?(Hash) && value.size == 1 && value.has_key?(content_key)
       hash.each_key { |key| hash[key] = hash[key][content_key] }
     }
     hash
   end
-  
+
   # Adds a new key/value pair to an existing Hash. If the key to be added
   # does already exist and the existing value associated with key is not
   # an Array, it will be converted into an Array. Then the new value is
@@ -642,37 +651,42 @@ class XmlSimple
   # value::
   #   Value to be associated with key.
   def merge(hash, key, value)
-    if value.instance_of?(String)
+    key = kebab_to_snake_case key
+    if value.is_a?(String)
       value = normalise_space(value) if @options['normalisespace'] == 2
 
+      if conv = @options['conversions'] and conv = conv.find {|c,_| c.match(key)} and conv = conv.at(1)
+        value = conv.call(value)
+      end
+
       # do variable substitutions
       unless @_var_values.nil? || @_var_values.empty?
         value.gsub!(/\$\{(\w+)\}/) { |x| get_var($1) }
       end
-      
+
       # look for variable definitions
       if @options.has_key?('varattr')
-        varattr = @options['varattr']
+        varattr = kebab_to_snake_case @options['varattr']
         if hash.has_key?(varattr)
           set_var(hash[varattr], value)
         end
       end
     end
-    
+
     #patch for converting keys to symbols
     if @options.has_key?('keytosymbol')
       if @options['keytosymbol'] == true
         key = key.to_s.downcase.to_sym
       end
     end
-    
+
     if hash.has_key?(key)
-      if hash[key].instance_of?(Array)
+      if hash[key].is_a?(Array)
         hash[key] << value
       else
         hash[key] = [ hash[key], value ]
       end
-    elsif value.instance_of?(Array) # Handle anonymous arrays.
+    elsif value.is_a?(Array) # Handle anonymous arrays.
       hash[key] = [ value ]
     else
       if force_array?(key)
@@ -683,21 +697,21 @@ class XmlSimple
     end
     hash
   end
-  
+
   # Checks, if the 'forcearray' option has to be used for
   # a certain key.
   def force_array?(key)
     return false if key == @options['contentkey']
     return true if @options['forcearray'] == true
     forcearray = @options['forcearray']
-    if forcearray.instance_of?(Hash)
-      return true if forcearray.has_key?(key) 
+    if forcearray.is_a?(Hash)
+      return true if forcearray.has_key?(key)
       return false unless forcearray.has_key?('_regex')
       forcearray['_regex'].each { |x| return true if key =~ x }
     end
     return false
   end
-  
+
   # Converts the attributes array of a document node into a Hash.
   # Returns an empty Hash, if node has no attributes.
   #
@@ -705,21 +719,28 @@ class XmlSimple
   #   Document node to extract attributes from.
   def get_attributes(node)
     attributes = {}
-    node.attributes.each { |n,v| attributes[n] = v }
+    if @options['attrprefix']
+      node.attributes.each { |n,v| attributes["@" + kebab_to_snake_case(n)] = v }
+    elsif @options.has_key?('attrtosymbol') and @options['attrtosymbol'] == true
+      #patch for converting attribute names to symbols
+      node.attributes.each { |n,v| attributes[kebab_to_snake_case(n).to_sym] = v }
+    else
+      node.attributes.each { |n,v| attributes[kebab_to_snake_case(n)] = v }
+    end
+
     attributes
   end
-  
+
   # Determines, if a document element has mixed content.
   #
   # element::
   #   Document element to be checked.
   def has_mixed_content?(element)
-    if element.has_text? && element.has_elements?
-      return true if element.texts.join('') !~ /^\s*$/s
-    end
-    false
+    element.has_text? &&
+      element.has_elements? &&
+      !element.texts.join('').strip.empty?
   end
-  
+
   # Called when a variable definition is encountered in the XML.
   # A variable definition looks like
   #    <element attrname="name">value</element>
@@ -737,7 +758,7 @@ class XmlSimple
       return "${#{name}}"
     end
   end
-  
+
   # Recurses through a data structure building up and returning an
   # XML representation of that structure as a string.
   #
@@ -765,12 +786,12 @@ class XmlSimple
     end
 
     # Unfold hash to array if possible.
-    if ref.instance_of?(Hash) && !ref.empty? && !@options['keyattr'].empty? && indent != ''
+    if ref.is_a?(Hash) && !ref.empty? && !@options['keyattr'].empty? && indent != ''
       ref = hash_to_array(name, ref)
     end
 
     result = []
-    if ref.instance_of?(Hash)
+    if ref.is_a?(Hash)
       # Reintermediate grouped values if applicable.
       if @options.has_key?('grouptags')
         ref.each { |key, value|
@@ -779,7 +800,7 @@ class XmlSimple
           end
         }
       end
-      
+
       nested = []
       text_content = nil
       if named
@@ -788,7 +809,7 @@ class XmlSimple
 
       if !ref.empty?
         ref.each { |key, value|
-          next if !key.nil? && key[0, 1] == '-'
+          next if !key.nil? && key.to_s[0, 1] == '-'
           if value.nil?
             unless @options.has_key?('suppressempty') && @options['suppressempty'].nil?
               raise ArgumentError, "Use of uninitialized value!"
@@ -796,7 +817,13 @@ class XmlSimple
             value = {}
           end
 
-          if !scalar(value) || @options['noattr']
+          # Check for the '@' attribute prefix to allow separation of attributes and elements
+
+          if (@options['noattr'] ||
+              (@options['attrprefix'] && !(key =~ /^@(.*)/)) ||
+              !scalar(value)
+             ) &&
+             key != @options['contentkey']
             nested << value_to_xml(value, key, indent + @options['indent'])
           else
             value = value.to_s
@@ -804,11 +831,11 @@ class XmlSimple
             if key == @options['contentkey']
               text_content = value
             else
-              result << ' ' << key << '="' << value << '"'
+              result << ' ' << ($1||key) << '="' << value << '"'
             end
           end
         }
-      else
+      elsif !@options['selfclose']
         text_content = ''
       end
 
@@ -831,13 +858,13 @@ class XmlSimple
       else
         result << ' />' << nl
       end
-    elsif ref.instance_of?(Array)
+    elsif ref.is_a?(Array)
       ref.each { |value|
         if scalar(value)
           result << indent << '<' << name << '>'
           result << (@options['noescape'] ? value.to_s : escape_value(value.to_s))
           result << '</' << name << '>' << nl
-        elsif value.instance_of?(Hash)
+        elsif value.is_a?(Hash)
           result << value_to_xml(value, name, indent)
         else
           result << indent << '<' << name << '>' << nl
@@ -852,31 +879,31 @@ class XmlSimple
     @ancestors.pop if !scalar(ref)
     result.join('')
   end
-  
+
   # Checks, if a certain value is a "scalar" value. Whatever
   # that will be in Ruby ... ;-)
-  # 
+  #
   # value::
   #   Value to be checked.
   def scalar(value)
-    return false if value.instance_of?(Hash) || value.instance_of?(Array)
+    return false if value.is_a?(Hash) || value.is_a?(Array)
     return true
   end
 
   # Attempts to unfold a hash of hashes into an array of hashes. Returns
   # a reference to th array on success or the original hash, if unfolding
   # is not possible.
-  # 
+  #
   # parent::
-  #   
+  #
   # hashref::
   #   Reference to the hash to be unfolded.
   def hash_to_array(parent, hashref)
     arrayref = []
     hashref.each { |key, value|
-      return hashref unless value.instance_of?(Hash)
+      return hashref unless value.is_a?(Hash)
 
-      if @options['keyattr'].instance_of?(Hash)
+      if @options['keyattr'].is_a?(Hash)
         return hashref unless @options['keyattr'].has_key?(parent)
         arrayref << { @options['keyattr'][parent][0] => key }.update(value)
       else
@@ -885,7 +912,7 @@ class XmlSimple
     }
     arrayref
   end
-  
+
   # Replaces XML markup characters by their external entities.
   #
   # data::
@@ -893,7 +920,7 @@ class XmlSimple
   def escape_value(data)
     Text::normalize(data)
   end
-  
+
   # Removes leading and trailing whitespace and sequences of
   # whitespaces from a string.
   #
@@ -918,7 +945,7 @@ class XmlSimple
         return value.nil?
     end
   end
-  
+
   # Converts a document node into a String.
   # If the node could not be converted into a String
   # for any reason, default will be returned.
@@ -928,11 +955,11 @@ class XmlSimple
   # default::
   #   Value to be returned, if node could not be converted.
   def node_to_text(node, default = nil)
-    if node.instance_of?(REXML::Element) 
+    if node.is_a?(REXML::Element)
       node.texts.map { |t| t.value }.join('')
-    elsif node.instance_of?(REXML::Attribute)
+    elsif node.is_a?(REXML::Attribute)
       node.value.nil? ? default : node.value.strip
-    elsif node.instance_of?(REXML::Text)
+    elsif node.is_a?(REXML::Text)
       node.value.strip
     else
       default
@@ -951,7 +978,7 @@ class XmlSimple
   def parse(xml_string)
     Document.new(xml_string)
   end
-  
+
   # Searches in a list of paths for a certain file. Returns
   # the full path to the file, if it could be found. Otherwise,
   # an exception will be raised.
@@ -978,20 +1005,20 @@ class XmlSimple
     end
     raise ArgumentError, "Could not find <#{filename}> in <#{searchpath.join(':')}>"
   end
-  
+
   # Loads and parses an XML configuration file.
   #
   # filename::
   #   Name of the configuration file to be loaded.
   #
   # The following exceptions may be raised:
-  # 
+  #
   # Errno::ENOENT::
   #   If the specified file does not exist.
   # REXML::ParseException::
   #   If the specified file is not wellformed.
   def load_xml_file(filename)
-    parse(File.readlines(filename).to_s)
+    parse(IO::read(filename))
   end
 
   # Caches the data belonging to a certain file.
@@ -1016,6 +1043,20 @@ class XmlSimple
       }
     end
   end
+
+  # Substitutes underscores for hyphens if the KebabToSnakeCase option is selected. For when you don't
+  # want to refer to keys by hash[:'my-key'] but instead as hash[:my_key]
+  #
+  # key::
+  #   Key to be converted.
+  def kebab_to_snake_case(key)
+    return key unless (@options['kebabtosnakecase'])
+
+    is_symbol = key.is_a? Symbol
+    key = key.to_s.gsub(/-/, '_')
+    key = key.to_sym if is_symbol
+    key
+  end
 end
 
 # vim:sw=2

metadata

@@ -1,46 +1,57 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: xml-simple
-version: !ruby/object:Gem::Version 
-  version: 1.0.11
-date: 2007-03-12 00:00:00 +01:00
-summary: A very simple API for XML processing.
-require_paths: 
-- lib
-email: contact@maik-schmidt.de
-homepage: http://xml-simple.rubyforge.org
-rubyforge_project: xml-simple
-description: 
-autorequire: xmlsimple
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+version: !ruby/object:Gem::Version
+  version: 1.1.9
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: 
+authors:
 - Maik Schmidt
-files: 
-- lib/xmlsimple.rb
-test_files: []
-
-rdoc_options: []
-
-extra_rdoc_files: []
-
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: contact@maik-schmidt.de
 executables: []
-
 extensions: []
-
+extra_rdoc_files: []
+files:
+- lib/xmlsimple.rb
+homepage: https://github.com/maik/xml-simple
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-dependencies: []
-
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A simple API for XML processing.
+test_files: []