lutaml-model 0.8.115 → 0.8.117

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b924b08953808c53f7f6db9f9832ffa870b11a5d2c7fe450b1340d8b2f289562
-  data.tar.gz: 3ba1f1afe7b2a95e83f137f8d3944e56e0ba516962b261665c4c3b91de74824f
+  metadata.gz: 49af9f0bc6f8dd954e93d9d3ac641e212dbf526486c9c8a2eb3460ccfbf01cbf
+  data.tar.gz: cf20d264b0827b500c0dde7340b721c5ea89235341a55ef603f3e41dd461a31a
 SHA512:
-  metadata.gz: 2d956aca0be2bdbae7e513391962490429057f04ca4371be1477d4bbc29e79f8ad942beffbb40debf27db64f7be7e7c301110832439a3ece8eb4ece5e6c673d9
-  data.tar.gz: 7a384e7b06e927f9b78a129914de369c2befa23b14e84c6a9c2ba24e769c145dd0b0814fa3f92483516132020ced34c885c71872c251d41a8bdc6dff995b41db
+  metadata.gz: 62359095df53c8835748e08c60c8648f6e07a4e892536da699ded2f255ec176a8aee3e648012d27e62909af5e34426118f465d93adf616ed005e22273e990fbc
+  data.tar.gz: 7e1d1f54a24252a44a31e2a0d45e878c13b9a5d44115a856aafd383cf24adb731ad585d52b8a8d9d648557ee150e2c0b776a1edd18b405bf16c79e76fbf4c2a8

data/lib/lutaml/model/attribute.rb

@@ -977,6 +977,24 @@ instance_object = nil)
         end
 
         klass = resolve_polymorphic_class(resolved_type, value, options)
+        # A scalar handed to a mapped-model attribute crashed
+        # apply_mappings with an internal NoMethodError (key? on
+        # String, #978). A type declaring its own .cast owns scalar
+        # construction; base-cast identity types fall through to the
+        # legacy conversion chain, whose parse error names the token.
+        if serializable_type?(register) && !value.nil? &&
+            !value.is_a?(::Hash) && !value.is_a?(::Array) &&
+            !value.respond_to?(:key?) && klass.respond_to?(:cast) &&
+            klass.method(:cast).owner == klass.singleton_class
+          casted = klass.cast(value)
+          return casted if casted.is_a?(klass)
+
+          raise Lutaml::Model::IncorrectModelError,
+                "attribute '#{name}': the #{format} input for type " \
+                "#{klass} is a #{value.class}, and #{klass}.cast did " \
+                "not build one (received #{casted.class})"
+        end
+
         if can_serialize?(klass, value, format, options)
           propagated = Serialize::DeserializationContext.propagate(options)
           klass.apply_mappings(value, format,

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.115"
+    VERSION = "0.8.117"
   end
 end

data/lib/lutaml/xml/leptris/plan_serializer.rb

@@ -485,8 +485,12 @@ module Lutaml
                 # namespace). Contested names dispatch strictly by
                 # (URI, local), falling back to URI-less rows.
                 name = object.name
+                # Order entries may carry names with no mapped row (the
+                # parse records every child in document order); the
+                # layout cache kills its default proc to stay
+                # mutation-free, so a miss reads nil and drops below.
                 keys = name_keys[name]
-                if keys.length == 1
+                if keys&.length == 1
                   dispatch_key = keys.first
                   entry = rows_by_name[dispatch_key]
                 else

data/spec/lutaml/model/from_json_scalar_cast_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #978: a JSON scalar handed to a mapped-model attribute crashed with
+# an internal NoMethodError (key? on String) wrapped as
+# InvalidFormatError. A type that declares its own .cast owns scalar
+# construction from that scalar; a cast-less type falls through to the
+# legacy conversion chain, whose parse error surfaces the offending
+# token — the remedy there is declaring .cast on the type.
+RSpec.describe "from_json scalar into a mapped-model attribute" do
+  let(:marked_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+
+      key_value do
+        map "content", to: :content
+      end
+
+      def self.cast(value)
+        return value if value.is_a?(self)
+
+        new(content: value.to_s)
+      end
+    end
+  end
+
+  let(:plain_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+
+      key_value do
+        map "content", to: :content
+      end
+    end
+  end
+
+  let(:holder_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :description, "ScalarMarked"
+      attribute :plain_desc, "ScalarPlain"
+
+      key_value do
+        map "description", to: :description
+        map "plain_desc", to: :plain_desc
+      end
+    end
+  end
+
+  before do
+    stub_const("ScalarMarked", marked_class)
+    stub_const("ScalarPlain", plain_class)
+    stub_const("ScalarHolder", holder_class)
+  end
+
+  it "constructs the mapped value through the type's .cast" do
+    model = ScalarHolder.from_json('{"description": "text"}')
+
+    expect(model.description).to be_a(ScalarMarked)
+    expect(model.description.content).to eq("text")
+  end
+
+  it "falls through to the format parse error for a cast-less mapped type" do
+    expect { ScalarHolder.from_json('{"plain_desc": "text"}') }
+      .to raise_error(
+        Lutaml::Model::InvalidFormatError,
+        /unexpected token 'text'/,
+      )
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -516,6 +516,28 @@ RSpec.describe "XML plan fast path" do
       expect(fast_out).to include(%(<para kind="a">Hi <emph>there</emph> bye <emph>again</emph>!</para>))
     end
 
+    it "drops order entries whose names have no mapped row" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :a, :string, collection: true
+
+        xml do
+          element "d"
+          ordered
+          map_element "a", to: :a
+        end
+      end
+      xml = %(<d><a>1</a><note>extra</note><a>2</a></d>)
+
+      Lutaml::Model::Config.instance.xml_plan_fast_path = false
+      interp = klass.from_xml(xml).to_xml
+      Lutaml::Model::Config.instance.xml_plan_fast_path = true
+      fast_out = klass.from_xml(xml).to_xml
+      Lutaml::Model::Config.instance.xml_plan_fast_path = false
+
+      expect(fast_out).to eq(interp)
+      expect(fast_out).to eq("<d>\n  <a>1</a>\n  <a>2</a>\n</d>")
+    end
+
     it "reflects content mutations through the ordered fast serializer" do
       para = Class.new(Lutaml::Model::Serializable) do
         attribute :emph, :string, collection: true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.115
+  version: 0.8.117
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1750,6 +1750,7 @@ files:
 - spec/lutaml/model/enum_spec.rb
 - spec/lutaml/model/except_spec.rb
 - spec/lutaml/model/finalization_cache_spec.rb
+- spec/lutaml/model/from_json_scalar_cast_spec.rb
 - spec/lutaml/model/generator_defaults_spec.rb
 - spec/lutaml/model/global_context_spec.rb
 - spec/lutaml/model/global_register_spec.rb