nori 2.8.0 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac639b2fdf06325300d7a65de3e8de963d6b6deed94eba8a5c5560ec99e29e28
-  data.tar.gz: 5837f3e91314f284171ac6b97ebd21d8b6d2bcd769aea32c854c4818523a15da
+  metadata.gz: ad5bbd690d533a62edcdedfe9a4f3d96f117e6cb744a64b9e268676189be1f92
+  data.tar.gz: f8d68043348d270b1e7eeb93b1ae9dfd7abbb18b52181a655b0001d34900d492
 SHA512:
-  metadata.gz: b315e0f90e75a5d225d83b0248b7d5e554ad1eab8e06b37e7cd25c5dacce146bfff6ef3e40e7ff37d4e07eb142b255b6d7a026512cd1f0d94622dcc6669d0ff0
-  data.tar.gz: 5fa332d507687ea25c1f2517944aff167916275f149ed590d097bc04aec39b3cf57532eeab5cee37167df4c69e68267908f80ef3c223dd84bf3c1baf881e3815
+  metadata.gz: 81a096bff5c1d667ba3f51d8474c6b9732cf3c128ccb0b17ccf73af780fb83e0b2f60883f4ed26b9a426465e4f4b89d77aaa2ff090d1b174ab138a779280fd0e
+  data.tar.gz: ae0f9173142a7e0f544c0a70a6de05877d96d884d03a87d8154052efb587ba6a5ca93898f2bd4127193e1742d7db1eaf500277797e561cbf6590d7ab6d50ca8d

data/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.9.1] - 2026-07-05
+
+### Fixed
+
+* Under `:serializable`, a typecast value no longer drops the node's attributes. A text node whose content gets converted to a non-String (by `:advanced_typecasting` or a bare `type=` cast) now takes the same hash shape as string values: `<status source="ldap">true</status>` becomes `{"#text" => true, "@source" => "ldap"}` instead of a bare `true` that silently lost `@source`. This closes a data-dependent hole in the profile's no-silent-loss promise, where the same element kept or dropped its attributes depending on what its text happened to look like. The value at `#text` is whatever the typecasting produced. Combined with `standards: true` no typecasting happens and `#text` is always a string.
+
+* The `#text` key of the `:serializable` hash shape now goes through `:convert_tags_to` like every other key. Previously a key-converting formula (for example one that symbolizes keys) produced converted element and attribute keys next to a raw `"#text"` string key in the same hash. Nori's contract is that a `:convert_tags_to` formula sees every key it emits, which also means a caller who prefers a plain `text` key over the XML JSON convention can now map `"#text"` in their formula.
+
+## [2.9.0] - 2026-07-05
+
+### Changed
+
+* The `:standards` profile no longer applies schema-less typing. Under `Nori.new(standards: true)`, `:advanced_typecasting` now defaults to `false` (an explicit `advanced_typecasting: true` still wins), and the bare un-namespaced `type=` and `nil=` attributes become ordinary attributes instead of casting instructions. No more `type=` conversions (`integer`, `date`, `decimal`, `array`, `file`, ...), and only a prefixed `xsi:nil="true"` marks an element nil. These conventions come from Rails' `Hash.from_xml` (inherited via crack and merb), not from any XML spec. Without a schema, character data is just text. Knowing that `<id>123</id>` holds an integer is the business of a schema-aware layer, not a guess from string shape. Parsing without the profile is completely unchanged.
+
+### Added
+
+* Add the `:serializable` profile option. `Nori.new(serializable: true)` returns plain, directly-serializable data with no custom value classes. A text node that also has attributes becomes a Hash in the XML JSON convention (`{"#text" => content}` merged with our existing `@`-prefixed attributes instead of a `Nori::StringWithAttributes`, and a text node without attributes becomes a plain `String`. A `type="file"` node is no longer decoded into a `Nori::StringIOFile`, it folds into text and attributes like any other node, leaving the base64 content untouched for the caller to decode. That `type=` decoding is a Rails/ActiveSupport `Hash.from_xml` convention Nori inherited via crack and merb, not part of any XML spec, which is why the plain-data profile drops it. With this, values survive `to_json`, `to_yaml`, and `Marshal`. Opt-in on the 2.x line, probably the default in Nori 3.0. Reported by @ArnoldMEDLINQ ([#107](https://github.com/savonrb/nori/issues/107)), thanks to @dub357 for pinpointing the cause and finding [#106](https://github.com/savonrb/nori/pull/106), and thanks to @ekzobrain whose hash-shape approach this builds on.
+
 ## [2.8.0] - 2026-07-04
 
 ### Added
@@ -255,4 +273,6 @@ 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
+[2.9.1]: https://github.com/savonrb/nori/compare/v2.9.0...v2.9.1
+[2.9.0]: https://github.com/savonrb/nori/compare/v2.8.0...v2.9.0
+[2.8.0]: https://github.com/savonrb/nori/compare/v2.7.1...v2.8.0

data/README.md

@@ -2,8 +2,8 @@ Nori
 ====
 
 [![CI](https://github.com/savonrb/nori/actions/workflows/test.yml/badge.svg)](https://github.com/savonrb/nori/actions/workflows/test.yml)
-[![Gem Version](https://badge.fury.io/rb/nori.svg)](http://badge.fury.io/rb/nori)
-[![Code Climate](https://codeclimate.com/github/savonrb/nori.svg)](https://codeclimate.com/github/savonrb/nori)
+[![Gem Version](https://img.shields.io/gem/v/nori.svg)](https://rubygems.org/gems/nori)
+[![Coverage Status](https://coveralls.io/repos/github/savonrb/nori/badge.svg?branch=main)](https://coveralls.io/github/savonrb/nori?branch=main)
 
 Really simple XML parsing ripped from Crack, which ripped it from Merb.  
 
@@ -50,6 +50,11 @@ result["foo"].attributes
 # => {"bar"=>"baz"}
 ```
 
+Because `StringWithAttributes` hides the attributes on an accessor, they are
+lost on a plain `to_json` and callers have to type-check each value. The
+[`serializable`](#serializable) profile returns a plain Hash instead and will
+probably be the default in 3.0.
+
 ## advanced_typecasting
 
 Nori can automatically convert string values to `TrueClass`, `FalseClass`, `Time`, `Date`, and `DateTime`:
@@ -183,3 +188,60 @@ Members of the profile:
   Nori.new(:standards => true).parse('<foo bar="baz"/>')
   # => {"foo"=>""}
   ```
+
+- **no schema-less typing.** Without a schema, character data is just text, so
+  the profile implies `advanced_typecasting: false` (overridable) and ignores
+  the bare `type=` and `nil=` attribute conventions that Nori inherited from
+  Rails' `Hash.from_xml`. A `type="integer"` no longer casts, a `type="array"`
+  no longer folds children into an Array, and both stay visible as ordinary
+  attributes. Only the prefixed `xsi:nil="true"` still marks an element nil,
+  because that convention comes from XML Schema Instance itself.
+
+  ```ruby
+  Nori.new(:standards => true).parse('<id type="integer">123</id>')
+  # => {"id"=>"123"}    (with "type" accessible via #attributes)
+  ```
+
+## serializable
+
+`serializable` is a profile that makes Nori return plain, directly-serializable
+data with no custom value classes. It is opt-in on the 2.x line and will
+probably become the default in 3.0.
+
+```ruby
+Nori.new(:serializable => true)
+```
+
+Members of the profile:
+
+- **text nodes with attributes become a Hash.** A tag with both text content
+  and attributes maps to the XML JSON convention (`{"#text" => content}` merged
+  with the `@`-prefixed attributes) instead of a `Nori::StringWithAttributes`.
+  This is the same `@`-keyed shape element nodes already use, so the attributes
+  survive `to_json`, `to_yaml`, and `Marshal`. A text node without attributes
+  stays a plain `String`. Typecast values keep their attributes the same way
+  (`{"#text" => true, "@source" => "ldap"}`) – attributes are never silently
+  dropped under the profile. The `#text` key goes through `convert_tags_to`
+  like every other key, so a key-converting formula can reshape it (or drop
+  the `#` entirely).
+
+  ```ruby
+  Nori.new(:serializable => true).parse('<foo bar="baz">Content</foo>')
+  # => {"foo"=>{"#text"=>"Content", "@bar"=>"baz"}}
+
+  Nori.new(:serializable => true).parse('<foo>Content</foo>')
+  # => {"foo"=>"Content"}
+  ```
+
+- **`type="file"` nodes are not decoded.** Without the profile, a node carrying
+  `type="file"` is base64-decoded into a `Nori::StringIOFile` with its filename
+  and content type. The profile skips that. The node folds into text and
+  attributes like any other, leaving the base64 content as a plain `String` for
+  the caller to decode. This `type=` decoding is a Rails/ActiveSupport
+  `Hash.from_xml` convention Nori inherited through crack and merb, not part of
+  any XML specification, so the plain-data profile leaves it behind.
+
+  ```ruby
+  Nori.new(:serializable => true).parse('<doc type="file" name="x.pdf">aGVsbG8=</doc>')
+  # => {"doc"=>{"#text"=>"aGVsbG8=", "@type"=>"file", "@name"=>"x.pdf"}}
+  ```

data/lib/nori/version.rb

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

data/lib/nori/xml_utility_node.rb

@@ -92,12 +92,11 @@ class Nori
         attributes = Hash[*intermediate]
       end
 
-      # leave the type alone if we don't know what it is
-      @type = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+      @type = bare_type(attributes)
 
       @nil_element = false
       attributes.keys.each do |key|
-        if result = /^((.*):)?nil$/.match(key)
+        if result = nil_attribute_pattern.match(key)
           @nil_element = attributes.delete(key) == "true"
           attributes.delete("xmlns:#{result[2]}") if result[1]
         end
@@ -130,12 +129,17 @@ class Nori
     # 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.
+    # becomes a {StringIOFile}, unless the +:serializable+ profile is enabled.
+    # That profile returns plain data only, so a file node folds into text and
+    # attributes like any other node and the base64 content is left undecoded.
+    # A node with text content becomes a typecast scalar. Every other node
+    # folds its children into an array or a hash. Under the +:standards+
+    # profile no bare type attribute is honored ({#bare_type}), so file
+    # decoding, array folding and typecasting never happen there.
     #
     # @return [Hash{String => Object}] the node name mapped to its value
     def to_hash
-      return { name => file_value } if @type == "file"
+      return { name => file_value } if @type == "file" && !@options[:serializable]
       return { name => text_value } if @text
 
       groups = group_children
@@ -211,6 +215,36 @@ class Nori
 
     private
 
+    # The value of the bare (un-namespaced) type attribute, or nil under
+    # the +:standards+ profile. A recognized type is consumed from the
+    # attributes because typecasting replaces it with the value it
+    # describes. An unrecognized type stays visible as an ordinary
+    # attribute. The bare attribute is a Rails +Hash.from_xml+ convention
+    # rather than XML, so the +:standards+ profile never reads it and the
+    # attribute passes through as ordinary data.
+    #
+    # @param attributes [Hash{String => String}] the element's attributes
+    # @return [String, nil] the type name, or nil when there is none to honor
+    def bare_type(attributes)
+      return nil if @options[:standards]
+
+      if self.class.available_typecasts.include?(attributes["type"])
+        attributes.delete("type")
+      else
+        attributes["type"]
+      end
+    end
+
+    # The attribute forms that declare an element nil. The prefixed form
+    # is the XML Schema Instance convention (xsi:nil). The bare +nil+ form
+    # is a Rails +Hash.from_xml+ convention, so the +:standards+ profile
+    # only accepts the prefixed form.
+    #
+    # @return [Regexp] the pattern, with the prefix in capture group 2
+    def nil_attribute_pattern
+      @options[:standards] ? /^((.+):)nil$/ : /^((.*):)?nil$/
+    end
+
     # Decodes the base64 content of a node typed as "file" into a
     # {StringIOFile} carrying the filename and content type attributes.
     def file_value
@@ -221,10 +255,16 @@ class Nori
     end
 
     # Typecasts the text content of the node. String results are wrapped
-    # so the node's attributes stay accessible on the value.
+    # so the node's attributes stay accessible on the value. Typecast
+    # non-String results can only carry the attributes under the
+    # +:serializable+ profile, where every value with attributes takes the
+    # hash shape. Without the profile they are returned bare and the
+    # attributes are dropped, because a {StringWithAttributes} cannot wrap
+    # them.
     def text_value
       value = typecast_value(inner_html)
       value = advanced_typecasting(value) if value.is_a?(String) && @options[:advanced_typecasting]
+      return serializable_value(value) if @options[:serializable]
       value.is_a?(String) ? string_with_attributes(value) : value
     end
 
@@ -278,14 +318,43 @@ class Nori
       value.is_a?(String) ? string_with_attributes(value) : value
     end
 
-    # Wraps a string value so the node's attributes stay accessible
-    # through {StringWithAttributes#attributes}.
+    # Combines a string +value+ with the node's attributes in the shape the
+    # active output profile calls for.
+    #
+    # By default the value is a {StringWithAttributes}: a String carrying the
+    # node's attributes on {StringWithAttributes#attributes}. Under the
+    # +:serializable+ profile the value becomes plain, directly-serializable
+    # data instead, so no custom String subclass is returned.
+    #
+    # @param value [String] the typecast text content of the node
+    # @return [StringWithAttributes, Hash{String => String}, String] the value
+    #   in the configured representation
     def string_with_attributes(value)
+      return serializable_value(value) if @options[:serializable]
+
       string = StringWithAttributes.new(value)
       string.attributes = attributes
       string
     end
 
+    # The +:serializable+ representation of a +value+ and the node's
+    # attributes. A node with attributes maps to the XML JSON convention
+    # (+{"#text" => value}+ merged with the "@"-prefixed attributes) and a
+    # node without attributes maps to the plain value. This holds for
+    # typecast non-String values too, so attributes are never silently
+    # dropped under the profile. The +#text+ key and the attribute keys go
+    # through the same tag conversion as every other key
+    # ({#prefixed_attribute_name}), so a +:convert_tags_to+ formula sees
+    # each key Nori emits.
+    #
+    # @param value [Object] the typecast text content of the node
+    # @return [Hash{String => Object}, Object] the hash shape when the node
+    #   has attributes, otherwise the plain +value+
+    def serializable_value(value)
+      return value if attributes.empty?
+      { prefixed_attribute_name("#text") => value }.merge(prefixed_attributes)
+    end
+
     def try_to_convert(value, &block)
       block.call(value)
     rescue ArgumentError

data/lib/nori.rb

@@ -25,6 +25,7 @@ class Nori
       :convert_dashes_to_underscores => true,
       :scrub_xml                     => true,
       :standards                     => false,
+      :serializable                  => false,
       :parser                        => :nokogiri
     }
 
@@ -56,17 +57,22 @@ class Nori
   #
   # 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.
+  # (+:consistent_empty_tags+ with an empty-string +:empty_tag_value+),
+  # turns off +:advanced_typecasting+ (schema-less values are text, their
+  # types are the business of a schema-aware layer) and, in the parsers,
+  # honors xml:space. These are defaults, so an explicit option 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 => "" }
+    {
+      :consistent_empty_tags => true,
+      :empty_tag_value       => "",
+      :advanced_typecasting  => false
+    }
   end
 
   def load_parser(parser)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nori
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.9.1
 platform: ruby
 authors:
 - Daniel Harrington