lutaml-model 0.8.30 → 0.8.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b34b7ff545ae437b23517945172d87ca4a954c0c4fad64c15fce8e9f3f14e02c
-  data.tar.gz: 8db18d5b33eef8ea93d920ee49db17511095c697bbddda129ff6ab6506970ac7
+  metadata.gz: 1ffdb7bcf72a5a1f4b3339ed331fe96def70246dd36010d23a469e4d27c7f103
+  data.tar.gz: edb32bba950336b77f2257383aec513126d0bdfb53d6fefa7f5eecbf5fe48f74
 SHA512:
-  metadata.gz: 7134619f7177e46dfd8558489092814d1b84fdae0e0a8bd2a33c95afbf9fba721d81928a30a4911b8833baccfead7a70bd9bd2a0633c00e4cdcf45b50178a86e
-  data.tar.gz: fa4f5701225229b3d2f1b1e8a18d00797bf96fad94b99ff2875bf177f5fcfbeee418099a5fd0686245c1dffda6cd57d2f716411b315f5e87731e77f8e7700b51
+  metadata.gz: 489d6825726abe7fb758d544938a679c652e1a0eeb5699757eea57884197b4bd4890cda632231772226ac794ec91f5eac3fc21988594c1dba3c1151a1fe33dac
+  data.tar.gz: 782cba0c296ffa16381f1f36c5614ca7536e3c7a4e628cef77f71d27a1acf37eada825de229d186ca76115149970eb7a110d04a6a5177d1331132f5f6ba8db10

data/lib/lutaml/json/adapter/document.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "lutaml/key_value/document"
+
 module Lutaml
   module Json
     module Adapter

data/lib/lutaml/json/adapter/standard_adapter.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require_relative "../generator_options"
+require_relative "document"
 
 module Lutaml
   module Json

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.30"
+    VERSION = "0.8.31"
   end
 end

data/lib/lutaml/xml/format.rb

@@ -239,7 +239,21 @@ Lutaml::Model::Serialize.prepend(
 # ModelImportExt override (root?) must land on ClassMethods too. The other
 # two (FormatConversion, InstanceMethods) are already prepended unconditionally
 # above, so Opal's no-double-prepend rule means we don't repeat them here.
-if Lutaml::Model.opal?
+#
+# TruffleRuby (34.0.1) has the same propagation gap, on both the include
+# side and the extend/singleton side — a module prepended into an
+# already-extended module does not reach prior extenders' singleton chains
+# either (https://github.com/truffleruby/truffleruby/issues/4452). Without
+# the include-side re-prepends below, Mml.parse et al. die with
+# "undefined method 'pending_plan_root_element='". The extend side
+# additionally needs FormatConversion re-prepended onto Serializable's
+# singleton: otherwise `model PlainClass` runs the no-op base
+# add_format_specific_model_methods and plain (non-Serialize) model classes
+# never receive their XML accessors (encoding=, element_order=, ordered=,
+# mixed, doctype, xml_declaration, raw_schema_location), so
+# ModelTransform#apply_xml_mapping dies at `instance.encoding = ...` —
+# e.g. every relaton ItemData parse via Relaton::Cli.parse_xml.
+if Lutaml::Model.opal? || RUBY_ENGINE == "truffleruby"
   Lutaml::Model::Serializable.singleton_class.prepend(
     Lutaml::Xml::Serialization::ModelImportExt,
   )
@@ -251,6 +265,14 @@ if Lutaml::Model.opal?
   Lutaml::Model::Serialize::ClassMethods.prepend(
     Lutaml::Xml::Serialization::ModelImportExt,
   )
+
+  # TruffleRuby only: Opal's no-double-prepend rule makes the unconditional
+  # ClassMethods.prepend(FormatConversion) above sufficient there.
+  if RUBY_ENGINE == "truffleruby"
+    Lutaml::Model::Serializable.singleton_class.prepend(
+      Lutaml::Xml::Serialization::FormatConversion,
+    )
+  end
 end
 
 # Register XML-specific attribute override warning names

data/lib/lutaml/xml/mapping_rule.rb

@@ -323,7 +323,13 @@ module Lutaml
         strict_match = uri && ns_info[:prefix] &&
           !ns_info[:unqualified_same_ns] && !ns_info[:via_schema_default]
         if strict_match
-          ["#{uri}:#{name}"].freeze
+          # Type-level qualification stays lenient on parse: a W3C
+          # unprefixed attribute carries no namespace, and 0.8.19 bound
+          # it to the type-qualified rule (lutaml-model#786). Only rule
+          # and schema-level qualification is strictly prefixed-only.
+          names = ["#{uri}:#{name}"]
+          names << name.to_s if ns_info[:via_type_namespace]
+          names.freeze
         else
           namespaced_names(default_namespace)
         end
@@ -471,6 +477,7 @@ form_default = :unqualified)
         if attr && (type_ns_class = attr.type_namespace_class(register)) &&
             type_ns_class != :blank
           result = build_namespace_result_from_class(type_ns_class)
+          result[:via_type_namespace] = true
           # CRITICAL W3C FLAG: Mark when attribute is in same namespace as parent with :unqualified
           # Serialization code will check this to omit prefix per attributeFormDefault
           if type_ns_class.uri == parent_ns_class&.uri && form_default == :unqualified

data/lib/lutaml/xml/model_transform.rb

@@ -985,9 +985,41 @@ effective_register = lutaml_register)
           parent_ns_class = nil
           form_default = :unqualified
         end
-        rule.attribute_match_names(attr, effective_register, parent_ns_class,
-                                   form_default,
-                                   options[:default_namespace])
+        names = rule.attribute_match_names(attr, effective_register,
+                                           parent_ns_class, form_default,
+                                           options[:default_namespace])
+
+        # #786 lenient alias (["uri:name", "name"] from a type-qualified
+        # rule): the unprefixed form must not steal the value when a
+        # sibling namespace-less rule owns the bare local name (#744
+        # disjointness). No sibling — the alias keeps 0.8.19 leniency.
+        if names.size == 2 && !names[1].include?(":") &&
+            instance_is_serialize &&
+            unqualified_sibling_attribute_rule?(instance, rule,
+                                                effective_register)
+          names = names.first(1)
+        end
+        names
+      end
+
+      # Whether another attribute rule with the same local name resolves
+      # namespace-less (no rule namespace, no value-type namespace) —
+      # the #744 owner of the unprefixed source form.
+      def unqualified_sibling_attribute_rule?(instance, rule,
+                                              effective_register)
+        mapping = instance.class.mappings_for(:xml, effective_register)
+        return false unless mapping
+
+        attrs = instance.class.attributes(effective_register)
+        mapping.mappings.any? do |sib|
+          next false unless sib.attribute? && !sib.equal?(rule)
+          next false unless sib.name.to_s == rule.name.to_s
+          next false if sib.namespace_set?
+
+          sib_attr = attrs[sib.to]
+          type_ns = sib_attr&.type_namespace_class(effective_register)
+          type_ns.nil? || type_ns == :blank
+        end
       end
 
       # [namespace_class, attribute_form_default] for the instance's model,

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -140,9 +140,25 @@ parent_element_form_default)
           actual_class = resolve_polymorphic_class(rule, value, is_polymorphic,
                                                    is_polymorphic_subtype)
 
+          # Dispatch on value's actual class when it is a Serializable that
+          # differs from the declared attribute_type. This covers ad-hoc
+          # polymorphism (caller assigns an unrelated Serializable to a typed
+          # slot) and prevents the wrong transformation being applied
+          # silently. Subsumes is_polymorphic_subtype; preserved here for
+          # the resolve_polymorphic_class call above.
+          union || is_polymorphic ||
+            (value.is_a?(Lutaml::Model::Serialize) &&
+             value.class != rule.attribute_type)
+
           # Get transformation for the actual class. Unions resolve the member
           # from the value's own class, like polymorphism.
-          child_transformation = if union
+          # Unions and unrelated Serializables dispatch on the value's
+          # own class (subsumes the subtype case); polymorphic config
+          # keeps its resolved-class dispatch (the class_map target).
+          child_transformation = if union ||
+              (!is_polymorphic &&
+               value.is_a?(Lutaml::Model::Serialize) &&
+               value.class != rule.attribute_type)
                                    value.class.transformation_for(:xml,
                                                                   register)
                                  elsif is_polymorphic || is_polymorphic_subtype

data/lib/lutaml/yaml/adapter/document.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "lutaml/key_value/document"
+
 module Lutaml
   module Yaml
     module Adapter

data/lib/lutaml/yaml/adapter/standard_adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "document"
+
 require "date"
 require "yaml"
 

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -36,9 +36,13 @@ module Lutaml
                                       @attributes
                                     end
 
-          require "yeptris"
-          require "yeptris/yaml"
-          Yeptris::YAML.dump(attributes_to_serialize)
+          # Generation must match the standard (Psych) adapter's output
+          # byte-for-byte: document separator, quoting of digit-leading
+          # strings, flow styles. The neutral Yeptris::YAML.dump is
+          # deliberately headerless, so parity goes through the
+          # Psych-compatible face of the same engine.
+          require "yeptris/psych"
+          Yeptris::Psych.dump(attributes_to_serialize)
         end
       end
     end

data/spec/lutaml/model/raw_adapter_require_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# The adapter resolver loads adapter files by raw path (load_adapter_file),
+# bypassing the autoload tree that normally defines Document before
+# StandardAdapter references it at class-definition time. Each deep adapter
+# require must therefore be self-sufficient.
+RSpec.describe "raw adapter requires" do
+  it "loads the json yeptris adapter without the namespace preloaded" do
+    out = `bundle exec ruby -e 'require "lutaml/json/adapter/yeptris_adapter"; puts Lutaml::Json::Adapter::YeptrisAdapter.name' 2>&1`
+    expect(out).to include("Lutaml::Json::Adapter::YeptrisAdapter")
+  end
+
+  it "loads the yaml yeptris adapter without the namespace preloaded" do
+    out = `bundle exec ruby -e 'require "lutaml/yaml/adapter/yeptris_adapter"; puts Lutaml::Yaml::Adapter::YeptrisAdapter.name' 2>&1`
+    expect(out).to include("Lutaml::Yaml::Adapter::YeptrisAdapter")
+  end
+
+  it "loads the json standard adapter standalone" do
+    out = `bundle exec ruby -e 'require "lutaml/json/adapter/standard_adapter"; puts Lutaml::Json::Adapter::StandardAdapter.name' 2>&1`
+    expect(out).to include("Lutaml::Json::Adapter::StandardAdapter")
+  end
+end

data/spec/lutaml/xml/cross_class_dispatch_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_string: true
+
+require "spec_helper"
+
+# When a caller assigns an unrelated Lutaml::Model::Serializable (not a
+# declared subtype) to a typed slot, serialisation must use the value's own
+# class mapping rules. The prior behaviour reused the declared
+# attribute_type's child_transformation regardless of value.class, which
+# silently applied the wrong rules and raised NoMethodError on whichever
+# Ruby attribute name differed.
+#
+# See BUGREPORT.element-builder-dispatch-on-value-class.md for the original
+# analysis and sts-ruby PR #47 for the downstream trigger.
+RSpec.describe "ElementBuilder cross-class dispatch" do
+  let(:declared_type) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        root "declared"
+        map_element "name", to: :name
+      end
+    end
+  end
+
+  let(:actual_type) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :different_name, :string
+
+      xml do
+        root "actual"
+        map_element "different-name", to: :different_name
+      end
+    end
+  end
+
+  let(:holder_class) do
+    declared = declared_type
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :child, declared
+
+      xml do
+        root "holder"
+        map_element "child", to: :child
+      end
+    end
+  end
+
+  it "serialises an unrelated Serializable using its own mapping" do
+    holder = holder_class.new
+    holder.child = actual_type.new(different_name: "x")
+    xml = holder.to_xml
+
+    parsed = Nokogiri::XML(xml)
+    expect(parsed.at_css("different-name").content).to eq("x")
+  end
+
+  it "preserves the declared-type fast path for matching classes" do
+    holder = holder_class.new
+    holder.child = declared_type.new(name: "y")
+    xml = holder.to_xml
+
+    parsed = Nokogiri::XML(xml)
+    expect(parsed.at_css("name").content).to eq("y")
+  end
+
+  it "round-trips the XML output (parsing yields declared type by design)" do
+    # Deserialisation cannot infer the runtime-assigned class without a
+    # discriminator; it instantiates the declared type. The XML round-trip
+    # itself must still be lossless.
+    holder = holder_class.new
+    holder.child = actual_type.new(different_name: "round-trip")
+    xml = holder.to_xml
+
+    reparsed = holder_class.from_xml(xml)
+    expect(reparsed.child).to be_a(declared_type)
+    expect(xml).to include("<different-name>round-trip</different-name>")
+  end
+end

data/spec/lutaml/xml/plain_model_accessors_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model"
+
+# Regression spec for the XML accessor wiring of plain (non-Serialize)
+# model classes declared via `model PlainClass`.
+#
+# The accessors are installed by
+# FormatConversion#add_format_specific_model_methods, which must override
+# the no-op base through Serialize::ClassMethods' prepend chain. Engines
+# that do not propagate a prepend into an already-extended module to prior
+# extenders' singleton chains (TruffleRuby —
+# https://github.com/truffleruby/truffleruby/issues/4452) silently lose the
+# override; this spec fails there without the format.rb re-prepend.
+RSpec.describe "Plain model class XML accessors" do
+  let(:plain_class) { Class.new }
+
+  let(:wrapper_class) do
+    pc = plain_class
+    Class.new(Lutaml::Model::Serializable) do
+      model pc
+
+      xml do
+        element "thing"
+      end
+
+      def self.name
+        "PlainModelWrapper"
+      end
+    end
+  end
+
+  it "installs the XML accessors on the plain model class" do
+    wrapper_class # force the `model` declaration
+
+    %i[encoding encoding= doctype= element_order= ordered= mixed=
+       xml_declaration= raw_schema_location=].each do |m|
+      expect(plain_class.method_defined?(m)).to(be(true),
+                                                "expected #{plain_class} to define ##{m}")
+    end
+  end
+
+  it "parses XML into the plain model instance" do
+    instance = wrapper_class.from_xml("<thing/>")
+
+    expect(instance).to be_a(plain_class)
+    expect(instance.element_order).not_to be_nil
+  end
+end

data/spec/lutaml/xml/type_qualified_attribute_leniency_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# An attribute rule with no namespace of its own whose VALUE TYPE is
+# namespace-qualified (Lutaml::Xml::Type::Configurable) must keep
+# binding unprefixed source attributes — per W3C Namespaces an
+# unprefixed attribute carries no namespace, and 0.8.19 matched it
+# leniently. The #758 strict prefixed-only match applies to rule- and
+# schema-level qualification, not to the value type's (lutaml-model#786).
+module TypeQualifiedAttributeLeniencySpec
+  class W14Ns < Lutaml::Xml::Namespace
+    uri "http://schemas.microsoft.com/office/word/2010/wordml"
+    prefix_default "w14"
+    element_form_default :qualified
+    attribute_form_default :qualified
+  end
+
+  class W14String < Lutaml::Model::Type::String
+    include Lutaml::Xml::Type::Configurable
+
+    xml do
+      namespace W14Ns
+    end
+  end
+
+  class WNs < Lutaml::Xml::Namespace
+    uri "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+    prefix_default "w"
+    element_form_default :qualified
+  end
+
+  W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml"
+
+  class Bookmark < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :v, W14String
+
+    xml do
+      element "bookmarkStart"
+      namespace WNs
+      map_attribute "id", to: :id
+      map_attribute "displacedByCustomXml", to: :v
+    end
+  end
+end
+
+RSpec.describe "type-qualified attribute rules" do
+  it "bind unprefixed source attributes (W3C: unprefixed = no namespace)" do
+    xml = %(<w:bookmarkStart xmlns:w="#{TypeQualifiedAttributeLeniencySpec::W_NS}" displacedByCustomXml="next" id="0"/>)
+    doc = TypeQualifiedAttributeLeniencySpec::Bookmark.from_xml(xml)
+
+    expect(doc.v).to eq("next")
+    expect(doc.id).to eq("0")
+    expect(doc.to_xml).to include(%(w14:displacedByCustomXml="next"))
+  end
+
+  it "keep binding prefixed source attributes in the type namespace" do
+    xml = %(<w:bookmarkStart xmlns:w="#{TypeQualifiedAttributeLeniencySpec::W_NS}" xmlns:w14="#{TypeQualifiedAttributeLeniencySpec::W14_NS}" w14:displacedByCustomXml="next" id="0"/>)
+    doc = TypeQualifiedAttributeLeniencySpec::Bookmark.from_xml(xml)
+
+    expect(doc.v).to eq("next")
+    expect(doc.to_xml).to include(%(w14:displacedByCustomXml="next"))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.30
+  version: 0.8.31
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1734,6 +1734,7 @@ files:
 - spec/lutaml/model/ordered_content_spec.rb
 - spec/lutaml/model/polymorphic_spec.rb
 - spec/lutaml/model/processing_instruction_spec.rb
+- spec/lutaml/model/raw_adapter_require_spec.rb
 - spec/lutaml/model/raw_element_spec.rb
 - spec/lutaml/model/register_key_value_spec.rb
 - spec/lutaml/model/register_methods_spec.rb
@@ -1859,6 +1860,7 @@ files:
 - spec/lutaml/xml/conformance/xml_namespaces_spec.rb
 - spec/lutaml/xml/conformance/xml_schema_instance_spec.rb
 - spec/lutaml/xml/content_model_validation_spec.rb
+- spec/lutaml/xml/cross_class_dispatch_spec.rb
 - spec/lutaml/xml/data_model_spec.rb
 - spec/lutaml/xml/decisions/decision_engine_spec.rb
 - spec/lutaml/xml/decisions/decision_spec.rb
@@ -1914,6 +1916,7 @@ files:
 - spec/lutaml/xml/ordered_method_spec.rb
 - spec/lutaml/xml/out_of_namespace_parsing_spec.rb
 - spec/lutaml/xml/pipeline_integration_spec.rb
+- spec/lutaml/xml/plain_model_accessors_spec.rb
 - spec/lutaml/xml/plan_fast_path_spec.rb
 - spec/lutaml/xml/plan_walk_spec.rb
 - spec/lutaml/xml/prefix_control_spec.rb
@@ -1954,6 +1957,7 @@ files:
 - spec/lutaml/xml/type_namespace_prefix_spec.rb
 - spec/lutaml/xml/type_namespace_resolver_spec.rb
 - spec/lutaml/xml/type_namespace_roundtrip_spec.rb
+- spec/lutaml/xml/type_qualified_attribute_leniency_spec.rb
 - spec/lutaml/xml/validate_xml_with_constructs_spec.rb
 - spec/lutaml/xml/validate_xml_with_spec.rb
 - spec/lutaml/xml/w3c_types_spec.rb