lutaml-model 0.8.132 → 0.8.133

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83ece4646bc4f2ecd052f6ba5edf994cb512b4be3a08e8a1778c5b357daab424
-  data.tar.gz: 9bac20d16559163de764a7148974724c199cacbce0d88d945b932c7d36ccaa19
+  metadata.gz: 7ea94bb734406bacfb047edb9c580a3f224f19c497b4f506440da60d381cd1bf
+  data.tar.gz: 96f7c71f51a0ec8b863eec77b894ec611ff3a4e8b59354ec9b477e6470258852
 SHA512:
-  metadata.gz: 27120683de1ff8d9c95049e683dffdf302aa43edf9a4e5e6debda189df3903fdf98f4722200eb4106285e86dfabb170b77fcaea3313c6e1a8e8e548ec2db0eab
-  data.tar.gz: 26a84cc1b288f7b829c1bdb44360adc7211843e506d1d51c1f416c411636fa6099dee79fd26d4d41a7e22b5eaf3ef1510d9580dbe49318ac8c2b9e02b80974bc
+  metadata.gz: 4e61d4a02ebb21a794de64a0301a3489b045b8562ce8e1a8f3522b227bea1632882e7e09d1ce6fe18352d41c8fe62d2a5d9652b315dda76a220cbd30fe15f3cf
+  data.tar.gz: 60c206b080775425586980a1f3b484db2280be9e9b73bc365237210f64c90fc3faa80f1f9e9a42e94259a9a83ba1edab1ceecc25bb804147ecd3e31ead97c15d

data/lib/lutaml/model/type/hash.rb

@@ -18,22 +18,37 @@ module Lutaml
         end
 
         def self.normalize_hash(hash)
-          return hash["text"] if hash.keys == ["text"]
+          xml = hash.is_a?(Lutaml::Model::MappingHash)
+          return hash["text"] if text_node?(hash)
 
-          hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+          hash = hash.to_h if xml
 
-          normalized_hash = hash.transform_values do |value|
+          normalized = hash.transform_values do |value|
             normalize_value(value)
           end
+          xml ? (normalized["elements"] || normalized) : normalized
+        end
 
-          normalized_hash["elements"] || normalized_hash
+        # {"text" => string} is the XML text-node convention and
+        # collapses to the string. Any other "text" key — structured
+        # values, or appearing alongside other keys in non-XML data —
+        # is ordinary data and must round-trip verbatim
+        # (lutaml/lutaml-model#1013).
+        def self.text_node?(hash)
+          # ::String — unqualified String resolves to Type::String here
+          hash.is_a?(::Hash) && hash.keys == ["text"] &&
+            hash["text"].is_a?(::String)
         end
 
         def self.normalize_value(value)
           return value unless value.is_a?(::Hash)
 
           nested = normalize_hash(value)
-          nested.is_a?(::Hash) ? nested.except("text") : nested
+          if value.is_a?(Lutaml::Model::MappingHash) && nested.is_a?(::Hash)
+            nested.except("text")
+          else
+            nested
+          end
         end
 
         def self.serialize(value)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.132"
+    VERSION = "0.8.133"
   end
 end

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -178,8 +178,13 @@ module Lutaml
                     elsif val.is_a?(Lutaml::Model::Serializable)
                       collection_indices[attr_name] += 1
                       collection_indices[attr_name] == 1 ? val : nil
+                    else
+                      # Scalar mapped elements (e.g. a string-valued
+                      # <main>) are part of the mixed content too.
+                      collection_indices[attr_name] += 1
+                      val
                     end
-              yield(obj) if obj
+              yield(obj) unless obj.nil? || (obj.is_a?(String) && obj.empty?)
             end
           end
 

data/spec/lutaml/model/mixed_content_spec.rb

@@ -1449,4 +1449,36 @@ RSpec.describe "MixedContent" do
                       described_class
     end
   end
+
+  describe "each_mixed_content with string-valued mapped elements" do
+    it "yields scalar mapped elements, not only Arrays and Serializable children" do
+      xml = "<title-wrap><main>Test Document</main></title-wrap>"
+      model = MixedContentSpec::TitleWrap.from_xml(xml)
+
+      expect(model.main).to eq("Test Document")
+
+      yielded = model.each_mixed_content.to_a
+      expect(yielded).to include("Test Document")
+    end
+
+    it "skips empty scalar values" do
+      xml = "<title-wrap><main></main></title-wrap>"
+      model = MixedContentSpec::TitleWrap.from_xml(xml)
+
+      yielded = model.each_mixed_content.to_a
+      expect(yielded).not_to include("")
+    end
+  end
+end
+
+module MixedContentSpec
+  class TitleWrap < Lutaml::Model::Serializable
+    attribute :main, :string
+
+    xml do
+      element "title-wrap"
+      mixed_content
+      map_element "main", to: :main
+    end
+  end
 end

data/spec/lutaml/model/type/hash_spec.rb

@@ -6,11 +6,30 @@ RSpec.describe Lutaml::Model::Type::Hash do
       expect(described_class.cast(nil)).to be_nil
     end
 
-    it "returns text content from hash with only text key" do
-      hash = { "text" => "content" }
+    it "returns text content from a MappingHash with only text key" do
+      hash = Lutaml::Model::MappingHash.new
+      hash["text"] = "content"
       expect(described_class.cast(hash)).to eq "content"
     end
 
+    # lutaml/lutaml-model#1013: a "text" key holding structured data
+    # (or appearing alongside other keys in non-XML data) is ordinary
+    # data and must round-trip verbatim
+    it "preserves a structured text key from a plain hash" do
+      hash = { "text" => { "type" => "string", "description" => "y" } }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
+    it "preserves text alongside other keys in a plain hash" do
+      hash = { "text" => "content", "other" => "value" }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
+    it "preserves an elements key from a plain hash" do
+      hash = { "elements" => [{ "a" => 1 }] }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
     it "normalizes MappingHash to regular Hash" do
       mapping_hash = Lutaml::Model::MappingHash.new
       mapping_hash["key"] = "value"
@@ -18,28 +37,29 @@ RSpec.describe Lutaml::Model::Type::Hash do
     end
 
     context "with nested hashes" do
-      let(:input) do
-        {
-          "key1" => {
-            "text" => "content1",
-            "other" => "value1",
-          },
-          "key2" => {
-            "text" => "content2",
-            "other" => "value2",
-          },
-        }
-      end
-
-      let(:expected_hash) do
-        {
+      it "filters out text keys from nested MappingHashes" do
+        child1 = Lutaml::Model::MappingHash.new
+        child1["text"] = "content1"
+        child1["other"] = "value1"
+        child2 = Lutaml::Model::MappingHash.new
+        child2["text"] = "content2"
+        child2["other"] = "value2"
+        input = Lutaml::Model::MappingHash.new
+        input["key1"] = child1
+        input["key2"] = child2
+        expected = {
           "key1" => { "other" => "value1" },
           "key2" => { "other" => "value2" },
         }
+        expect(described_class.cast(input)).to eq(expected)
       end
 
-      it "filters out text keys from nested hashes" do
-        expect(described_class.cast(input)).to eq(expected_hash)
+      it "preserves text keys in nested plain hashes" do
+        input = {
+          "key1" => { "text" => "content1", "other" => "value1" },
+          "key2" => { "text" => "content2", "other" => "value2" },
+        }
+        expect(described_class.cast(input)).to eq(input)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.132
+  version: 0.8.133
 platform: ruby
 authors:
 - Ribose Inc.