nori 2.7.1 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e562b494afc72df387f136e51af0c5e0445b528b5515eedad7f60b3d49d207a5
-  data.tar.gz: 5eabad83b50392e39973058c70d6307ddaaeea47934c292fbd472ee0f93680f9
+  metadata.gz: ac639b2fdf06325300d7a65de3e8de963d6b6deed94eba8a5c5560ec99e29e28
+  data.tar.gz: 5837f3e91314f284171ac6b97ebd21d8b6d2bcd769aea32c854c4818523a15da
 SHA512:
-  metadata.gz: 6366a2ac0d9dd99e4fd7b0f32d95dfb21f76885ab18fc7f3f7767c5e257b61e3817d2bf13f9a113feb2482fdb6f5a912956ef5d17a3f868a9139e9b55683402f
-  data.tar.gz: cf295850b06961ed67644a8c06c61152cecf5c8512f8a74a03115e47fe8f9a567300d9af8d91504013777400882869cb7016c80563015e6423e86718c7b828bd
+  metadata.gz: b315e0f90e75a5d225d83b0248b7d5e554ad1eab8e06b37e7cd25c5dacce146bfff6ef3e40e7ff37d4e07eb142b255b6d7a026512cd1f0d94622dcc6669d0ff0
+  data.tar.gz: 5fa332d507687ea25c1f2517944aff167916275f149ed590d097bc04aec39b3cf57532eeab5cee37167df4c69e68267908f80ef3c223dd84bf3c1baf881e3815

data/CHANGELOG.md

@@ -1,19 +1,38 @@
-# 2.7.1 (2024-07-28)
+# Nori changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.8.0] - 2026-07-04
+
+### Added
+
+* Add the `:standards` profile option. `Nori.new(standards: true)` turns on Nori's spec-correct parsing as a group rather than one flag at a time. Its first members are xml:space honoring (whitespace-only text under `xml:space="preserve"` is kept instead of stripped, with inheritance and `xml:space="default"` reset per [XML 1.0 §2.10](https://www.w3.org/TR/xml/#sec-white-space)) and the XML string-value model for empty elements (implies `:consistent_empty_tags` with an empty-string `:empty_tag_value`, both still overridable). Opt-in on the 2.x line, default in 3.0. Thanks to @md5 for raising the `xml:space="preserve"` case on [#97](https://github.com/savonrb/nori/issues/97).
+
+* [#97](https://github.com/savonrb/nori/issues/97) Add the `:consistent_empty_tags` option ([#109](https://github.com/savonrb/nori/pull/109)). When enabled, every empty tag becomes the `:empty_tag_value`, whether it has attributes or not. A string value keeps the attributes accessible via `#attributes`, and an explicit `xsi:nil="true"` always becomes `nil`. Reported by @lukasbischof, who also proposed a fix in [#98](https://github.com/savonrb/nori/pull/98). Thanks to @md5 for surfacing another instance of it and pinpointing the cause.
+
+### Fixed
+
+* Whitespace-only CDATA content is no longer stripped. A `<![CDATA[   ]]>` section is the author's explicit literal-data marker, so its content is now preserved as text instead of being dropped, on both the Nokogiri and REXML parsers. Previously such a tag parsed to `nil` (or, with attributes, dropped the content and kept only the attributes). Non-whitespace CDATA is unchanged, and ordinary whitespace-only text is still stripped as before. Surfaced while auditing whitespace handling for [#97](https://github.com/savonrb/nori/issues/97), the same empty-tag/whitespace spec-compliance work as the `:consistent_empty_tags` option above.
+
+## 2.7.1 (2024-07-28)
 
 * Stop monkey-patching String with #snakecase by @mchu in https://github.com/savonrb/nori/pull/102
 
-# 2.7.0 (2024-02-13)
+## 2.7.0 (2024-02-13)
 
 * Added support for ruby 3.1, 3.2, 3.3. Dropped support for ruby 2.7 and below.
 * Feature: `Nori::Parser` has a new option, `:scrub_xml`, which defaults to true, for scrubbing invalid characters ([#72](https://github.com/savonrb/nori/pull/72)). This should allow documents containing invalid characters to still be parsed.
 * Fix: REXML parser changes `&lt;` inside CDATA to `<` ([#94](https://github.com/savonrb/nori/pull/94))
 * Change: `Object#blank?` is no longer patched in.
 
-# 2.6.0 (2015-05-06)
+## 2.6.0 (2015-05-06)
 
 * Feature: [#69](https://github.com/savonrb/nori/pull/69) Add option to convert empty tags to a value other than nil.
 
-# 2.5.0 (2015-03-31)
+## 2.5.0 (2015-03-31)
 
 * Formally drop support for ruby 1.8.7. Installing Nori from rubygems for that version should no longer attempt to install versions that will not work.
 * BREAKING CHANGE: Newlines are now preserved when present in the value of inner text nodes. See the example below:
@@ -31,7 +50,7 @@ Nori.new.parse("<outer>\n&lt;embedded&gt;\n&lt;one&gt;&lt;/one&gt;\n&lt;two&gt;&
 => {"outer"=>"<embedded>\n<one></one>\n<two></two>\n<embedded>\n"}
 ```
 
-# 2.4.0 (2014-04-19)
+## 2.4.0 (2014-04-19)
 
 * Change: Dropped support for ruby 1.8, rubinius and ree
 
@@ -39,42 +58,42 @@ Nori.new.parse("<outer>\n&lt;embedded&gt;\n&lt;one&gt;&lt;/one&gt;\n&lt;two&gt;&
 
 * Feature: Added `:convert_dashes_to_underscore` option
 
-# 2.3.0 (2013-07-26)
+## 2.3.0 (2013-07-26)
 
 * Change: `Nori#find` now ignores namespace prefixes in Hash keys it is searching through.
 
 * Fix: Limited Nokogiri to < 1.6, because v1.6 dropped support for Ruby 1.8.
 
-# 2.2.0 (2013-04-25)
+## 2.2.0 (2013-04-25)
 
 * Feature: [#42](https://github.com/savonrb/nori/pull/42) adds the `:delete_namespace_attributes`
   option to remove namespace attributes like `xmlns:*` or `xsi:*`.
 
-# 2.1.0 (2013-04-21)
+## 2.1.0 (2013-04-21)
 
 * Feature: Added `Nori.hash_key` and `Nori#find` to work with Hash keys generated by Nori.
   Original issue: [savonrb/savon#393](https://github.com/savonrb/savon/pull/393)
 
-# 2.0.4 (2013-02-26)
+## 2.0.4 (2013-02-26)
 
 * Fix: [#37](https://github.com/savonrb/nori/issues/37) special characters
   problem on Ruby 1.9.3-p392.
 
-# 2.0.3 (2013-01-10)
+## 2.0.3 (2013-01-10)
 
 * Fix for remote code execution bug. For more in-depth information, read about the
   recent [Rails hotfix](https://groups.google.com/forum/?fromgroups=#!topic/rubyonrails-security/61bkgvnSGTQ).
   Please make sure to upgrade now!
 
-# 2.0.2 (YANKED)
+## 2.0.2 (YANKED)
 
 * Yanked because of a problem with XML that starts with an instruction tag.
 
-# 2.0.1 (YANKED)
+## 2.0.1 (YANKED)
 
 * Yanked because of a problem with XML that starts with an instruction tag.
 
-# 2.0.0 (2012-12-12)
+## 2.0.0 (2012-12-12)
 
 Please make sure to read the updated README for how to use the new version.
 
@@ -235,3 +254,5 @@ Please make sure to read the updated README for how to use the new version.
 
 ## 0.1.0 2009-03-28
 * Initial release.
+
+[2.8.0]: https://github.com/savonrb/nori/compare/v2.7.1...2.8.0

data/README.md

@@ -107,3 +107,79 @@ parser = Nori.new(:convert_dashes_to_underscores => false)
 parser.parse('<any-tag>foo bar</any-tag>')
 # => {"any-tag"=>"foo bar"}
 ```
+
+## empty_tag_value
+
+By default, an empty tag becomes `nil`. The `empty_tag_value` option replaces that value.
+
+```ruby
+Nori.new.parse('<foo/>')
+# => {"foo"=>nil}
+
+Nori.new(:empty_tag_value => "").parse('<foo/>')
+# => {"foo"=>""}
+```
+
+The option does not apply to empty tags with attributes.
+They become a hash of their prefixed attributes instead.
+
+```ruby
+Nori.new(:empty_tag_value => "").parse('<foo bar="baz"/>')
+# => {"foo"=>{"@bar"=>"baz"}}
+```
+
+## consistent_empty_tags
+
+With `consistent_empty_tags`, every empty tag (with or without attributes) becomes the `empty_tag_value`.
+
+```ruby
+Nori.new(:consistent_empty_tags => true).parse('<foo bar="baz"/>')
+# => {"foo"=>nil}
+```
+
+A string `empty_tag_value` keeps the attributes accessible on the value,
+and an explicit `xsi:nil="true"` always becomes `nil`.
+
+```ruby
+parser = Nori.new(:consistent_empty_tags => true, :empty_tag_value => "")
+
+result = parser.parse('<foo bar="baz"/>')
+# => {"foo"=>""}
+
+result["foo"].attributes
+# => {"bar"=>"baz"}
+
+parser.parse('<foo xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>')
+# => {"foo"=>nil}
+```
+
+## standards
+
+`standards` is a profile that turns on Nori's spec-correct parsing as a group,
+rather than one flag at a time. It is opt-in on the 2.x line and becomes the
+default in Nori 3.0.
+
+```ruby
+Nori.new(:standards => true)
+```
+
+Members of the profile:
+
+- **xml:space honoring** ([XML 1.0 §2.10](https://www.w3.org/TR/xml/#sec-white-space)).
+  Whitespace-only text under `xml:space="preserve"` is kept instead of stripped.
+  The nearest ancestor that sets `xml:space` wins, and `xml:space="default"`
+  resets to the stripping behavior.
+
+  ```ruby
+  Nori.new(:standards => true).parse('<name xml:space="preserve">   </name>')
+  # => {"name"=>"   "}
+  ```
+
+- **the XML string-value model for empty elements.** The profile implies
+  `consistent_empty_tags: true` with `empty_tag_value: ""`. Both remain
+  overridable, so passing either option explicitly wins over the profile.
+
+  ```ruby
+  Nori.new(:standards => true).parse('<foo bar="baz"/>')
+  # => {"foo"=>""}
+  ```

data/lib/nori/parser/nokogiri.rb

@@ -9,23 +9,44 @@ class Nori
     module Nokogiri
 
       class Document < ::Nokogiri::XML::SAX::Document
+        # Marks a text node that came from a CDATA section so the whitespace
+        # stripping in {#end_element} and {#characters} leaves it alone.
+        # A CDATA section is the author's explicit literal-data marker
+        # (XML 1.0 §2.7), so its content is real even when it is only
+        # whitespace and is never trimmed. The marker never reaches the
+        # output because {XMLUtilityNode#inner_html} joins children into
+        # a plain string.
+        class CDataText < ::String; end
+
         attr_accessor :options
 
         def stack
           @stack ||= []
         end
 
+        # Tracks the xml:space value in effect for each open element so
+        # {#preserve_whitespace?} can honor XML 1.0 §2.10 inheritance.
+        def space_stack
+          @space_stack ||= []
+        end
+
         def start_element(name, attrs = [])
-          stack.push Nori::XMLUtilityNode.new(options, name, Hash[*attrs.flatten])
+          attributes = Hash[*attrs.flatten]
+          space_stack.push xml_space(attributes)
+          stack.push Nori::XMLUtilityNode.new(options, name, attributes)
         end
 
         # To keep backward behaviour compatibility
-        # delete last child if it is a space-only text node
+        # delete last child if it is a space-only text node.
+        # CDATA content is literal and is never stripped, and under
+        # xml:space="preserve" whitespace-only text is kept too.
         def end_element(name)
+          preserve = preserve_whitespace?
+          space_stack.pop
           if stack.size > 1
             last = stack.pop
             maybe_string = last.children.last
-            if maybe_string.is_a?(String) and maybe_string.strip.empty?
+            if !preserve and maybe_string.is_a?(String) and !maybe_string.is_a?(CDataText) and maybe_string.strip.empty?
               last.children.pop
             end
             stack.last.add_node last
@@ -34,15 +55,41 @@ class Nori
 
         # If this node is a successive character then add it as is.
         # First child being a space-only text node will not be added
-        # because there is no previous characters.
+        # because there is no previous characters, unless xml:space="preserve"
+        # is in effect.
         def characters(string)
           last = stack.last
-          if last and last.children.last.is_a?(String) or string.strip.size > 0
+          if last and (preserve_whitespace? or last.children.last.is_a?(String) or string.strip.size > 0)
             last.add_node(string)
           end
         end
 
-        alias cdata_block characters
+        # Adds the CDATA section content verbatim.
+        def cdata_block(string)
+          last = stack.last
+          last.add_node(CDataText.new(string)) if last
+        end
+
+        private
+
+        # The xml:space value for an element. Its own declaration if it has one,
+        # otherwise the value inherited from the nearest ancestor.
+        # Defaults to "default". See XML 1.0 §2.10.
+        #
+        # @param attributes [Hash{String => String}] the element's attributes
+        # @return [String] "preserve", "default", or an inherited value
+        def xml_space(attributes)
+          attributes["xml:space"] || space_stack.last || "default"
+        end
+
+        # Whether whitespace-only text must be kept for the current element.
+        # Only the +:standards+ profile honors xml:space. Otherwise
+        # insignificant whitespace is stripped as before.
+        #
+        # @return [Boolean]
+        def preserve_whitespace?
+          options[:standards] && space_stack.last == "preserve"
+        end
 
       end
 

data/lib/nori/parser/rexml.rb

@@ -12,6 +12,9 @@ class Nori
 
       def self.parse(xml, options)
         stack = []
+        # Tracks the xml:space value in effect for each open element so
+        # whitespace-only text can be kept under xml:space="preserve".
+        space_stack = []
         parser = ::REXML::Parsers::BaseParser.new(xml)
 
         while true
@@ -23,21 +26,47 @@ class Nori
           when :end_doctype, :start_doctype
             # do nothing
           when :start_element
+            space_stack.push xml_space(event[2], space_stack)
             stack.push Nori::XMLUtilityNode.new(options, event[1], event[2])
           when :end_element
+            space_stack.pop
             if stack.size > 1
               temp = stack.pop
               stack.last.add_node(temp)
             end
           when :text
-            stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
+            # Whitespace-only text is insignificant and stripped, unless
+            # xml:space="preserve" is in effect under the :standards profile.
+            keep = preserve_whitespace?(options, space_stack) || event[1].strip.length > 0
+            stack.last.add_node(event[1]) if keep && !stack.empty?
           when :cdata
-            stack.last.add_node(raw_data[1]) unless raw_data[1].strip.length == 0 || stack.empty?
+            # CDATA is the author's explicit literal-data marker (XML 1.0 §2.7),
+            # so whitespace-only CDATA is kept rather than stripped like text.
+            stack.last.add_node(raw_data[1]) unless stack.empty?
           end
         end
         stack.length > 0 ? stack.pop.to_hash : {}
       end
 
+      # The xml:space value for an element: its own declaration if it has
+      # one, otherwise the value inherited from the nearest ancestor.
+      # Defaults to "default". See XML 1.0 §2.10.
+      #
+      # @param attributes [Hash{String => String}] the element's attributes
+      # @param space_stack [Array<String>] the ancestor xml:space values
+      # @return [String] "preserve", "default", or an inherited value
+      def self.xml_space(attributes, space_stack)
+        (attributes && attributes["xml:space"]) || space_stack.last || "default"
+      end
+
+      # Whether whitespace-only text must be kept for the current element.
+      # Only the +:standards+ profile honors xml:space.
+      #
+      # @return [Boolean]
+      def self.preserve_whitespace?(options, space_stack)
+        options[:standards] && space_stack.last == "preserve"
+      end
+
       def self.unnormalize(event)
         event.map do |el|
           if el.is_a?(String)

data/lib/nori/string_io_file.rb

@@ -1,3 +1,5 @@
+require "stringio"
+
 class Nori
   class StringIOFile < StringIO
 

data/lib/nori/version.rb

@@ -1,3 +1,3 @@
 class Nori
-  VERSION = '2.7.1'
+  VERSION = '2.8.0'
 end

data/lib/nori/xml_utility_node.rb

@@ -127,59 +127,21 @@ class Nori
       @children << node
     end
 
+    # Converts the node into a hash with the node name as its single key.
+    #
+    # The value depends on the shape of the node. A node typed as "file"
+    # becomes a {StringIOFile}. A node with text content becomes a typecast
+    # scalar. Every other node folds its children into an array or a hash.
+    #
+    # @return [Hash{String => Object}] the node name mapped to its value
     def to_hash
-      if @type == "file"
-        f = StringIOFile.new((@children.first || '').unpack('m').first)
-        f.original_filename = attributes['name'] || 'untitled'
-        f.content_type = attributes['content_type'] || 'application/octet-stream'
-        return { name => f }
-      end
+      return { name => file_value } if @type == "file"
+      return { name => text_value } if @text
 
-      if @text
-        t = typecast_value(inner_html)
-        t = advanced_typecasting(t) if t.is_a?(String) && @options[:advanced_typecasting]
-
-        if t.is_a?(String)
-          t = StringWithAttributes.new(t)
-          t.attributes = attributes
-        end
-
-        return { name => t }
-      else
-        #change repeating groups into an array
-        groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
-
-        out = nil
-        if @type == "array"
-          out = []
-          groups.each do |k, v|
-            if v.size == 1
-              out << v.first.to_hash.entries.first.last
-            else
-              out << v.map{|e| e.to_hash[k]}
-            end
-          end
-          out = out.flatten
-
-        else # If Hash
-          out = {}
-          groups.each do |k,v|
-            if v.size == 1
-              out.merge!(v.first)
-            else
-              out.merge!( k => v.map{|e| e.to_hash[k]})
-            end
-          end
-          out.merge! prefixed_attributes unless attributes.empty?
-          out = out.empty? ? @options[:empty_tag_value] : out
-        end
-
-        if @type && out.nil?
-          { name => typecast_value(out) }
-        else
-          { name => out }
-        end
-      end
+      groups = group_children
+      value = @type == "array" ? array_value(groups) : hash_value(groups)
+      value = typecast_value(value) if @type && value.nil?
+      { name => value }
     end
 
     # Typecasts a value based upon its type. For instance, if
@@ -248,6 +210,82 @@ class Nori
     alias to_s to_html
 
     private
+
+    # Decodes the base64 content of a node typed as "file" into a
+    # {StringIOFile} carrying the filename and content type attributes.
+    def file_value
+      file = StringIOFile.new((@children.first || '').unpack('m').first)
+      file.original_filename = attributes['name'] || 'untitled'
+      file.content_type = attributes['content_type'] || 'application/octet-stream'
+      file
+    end
+
+    # Typecasts the text content of the node. String results are wrapped
+    # so the node's attributes stay accessible on the value.
+    def text_value
+      value = typecast_value(inner_html)
+      value = advanced_typecasting(value) if value.is_a?(String) && @options[:advanced_typecasting]
+      value.is_a?(String) ? string_with_attributes(value) : value
+    end
+
+    # Groups the child nodes by their name so repeating siblings can be
+    # folded into arrays.
+    #
+    # @return [Hash{String => Array<XMLUtilityNode>}]
+    def group_children
+      @children.inject({}) { |hash, child| (hash[child.name] ||= []) << child; hash }
+    end
+
+    # Collects the values of all child nodes for a node typed as "array".
+    def array_value(groups)
+      values = []
+      groups.each do |child_name, nodes|
+        if nodes.size == 1
+          values << nodes.first.to_hash.entries.first.last
+        else
+          values << nodes.map { |node| node.to_hash[child_name] }
+        end
+      end
+      values.flatten
+    end
+
+    # Folds the child nodes and the prefixed attributes into a hash.
+    # An empty result becomes the :empty_tag_value option.
+    def hash_value(groups)
+      return consistent_empty_value if @options[:consistent_empty_tags] && groups.empty?
+
+      value = {}
+      groups.each do |child_name, nodes|
+        if nodes.size == 1
+          value.merge!(nodes.first.to_hash)
+        else
+          value.merge!(child_name => nodes.map { |node| node.to_hash[child_name] })
+        end
+      end
+      value.merge!(prefixed_attributes) unless attributes.empty?
+      value.empty? ? @options[:empty_tag_value] : value
+    end
+
+    # Resolves an element without children and without text when the
+    # :consistent_empty_tags option is set. The element becomes the
+    # :empty_tag_value option no matter which attributes it carries.
+    # A string value keeps the attributes accessible on the value.
+    # An explicit xsi:nil="true" wins over the option and becomes nil.
+    def consistent_empty_value
+      return nil if @nil_element
+
+      value = @options[:empty_tag_value]
+      value.is_a?(String) ? string_with_attributes(value) : value
+    end
+
+    # Wraps a string value so the node's attributes stay accessible
+    # through {StringWithAttributes#attributes}.
+    def string_with_attributes(value)
+      string = StringWithAttributes.new(value)
+      string.attributes = attributes
+      string
+    end
+
     def try_to_convert(value, &block)
       block.call(value)
     rescue ArgumentError

data/lib/nori.rb

@@ -20,14 +20,16 @@ class Nori
       :convert_tags_to               => nil,
       :convert_attributes_to         => nil,
       :empty_tag_value               => nil,
+      :consistent_empty_tags         => false,
       :advanced_typecasting          => true,
       :convert_dashes_to_underscores => true,
       :scrub_xml                     => true,
+      :standards                     => false,
       :parser                        => :nokogiri
     }
 
     validate_options! defaults.keys, options.keys
-    @options = defaults.merge(options)
+    @options = defaults.merge(standards_defaults(options)).merge(options)
   end
 
   def find(hash, *path)
@@ -49,6 +51,24 @@ class Nori
   end
 
   private
+
+  # The defaults implied by the +:standards+ profile.
+  #
+  # The profile groups the spec-correct behaviors under a single opt-in.
+  # It turns on the XML string-value model for empty elements
+  # (+:consistent_empty_tags+ with an empty-string +:empty_tag_value+) and,
+  # in the parsers, xml:space honoring. These are defaults, so an explicit
+  # +:consistent_empty_tags+ or +:empty_tag_value+ passed by the caller
+  # still wins. When the profile is off the hash is empty and parsing is
+  # unchanged.
+  #
+  # @param options [Hash] the options passed to {#initialize}
+  # @return [Hash] the implied defaults, or +{}+ when the profile is off
+  def standards_defaults(options)
+    return {} unless options[:standards]
+    { :consistent_empty_tags => true, :empty_tag_value => "" }
+  end
+
   def load_parser(parser)
     require "nori/parser/#{parser}"
     Parser.const_get PARSERS[parser]

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: nori
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.8.0
 platform: ruby
 authors:
 - Daniel Harrington
 - John Nunemaker
 - Wynn Netherland
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -26,20 +25,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: stringio
+  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'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '13.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '13.3'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -74,18 +87,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".devcontainer/devcontainer.json"
-- ".github/dependabot.yml"
-- ".github/workflows/test.yml"
-- ".gitignore"
-- ".rspec"
 - CHANGELOG.md
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
-- benchmark/benchmark.rb
-- benchmark/soap_response.xml
 - lib/nori.rb
 - lib/nori/core_ext.rb
 - lib/nori/core_ext/hash.rb
@@ -96,18 +100,11 @@ files:
 - lib/nori/string_with_attributes.rb
 - lib/nori/version.rb
 - lib/nori/xml_utility_node.rb
-- nori.gemspec
-- spec/nori/api_spec.rb
-- spec/nori/core_ext/hash_spec.rb
-- spec/nori/nori_spec.rb
-- spec/nori/string_utils_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/savonrb/nori
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -122,8 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: XML to Hash translator
 test_files: []