lutaml-model 0.8.11 → 0.8.12

data/lib/lutaml/key_value/mapping.rb

@@ -218,17 +218,17 @@ module Lutaml
       end
 
       # Writers for deep_dup in subclasses
-      attr_writer :mappings, :register_mappings
+      attr_writer :register_mappings
 
       def deep_dup
-        self.class.new(@format).tap do |new_mapping|
+        dup_instance.tap do |new_mapping|
           new_mapping.mappings = duplicate_mappings
           new_mapping.register_mappings = Lutaml::Model::Utils.deep_dup(@register_mappings)
         end
       end
 
-      def duplicate_mappings
-        Lutaml::Model::Utils.deep_dup(@mappings)
+      def dup_instance
+        self.class.new(@format)
       end
 
       def find_by_to(to)

data/lib/lutaml/model/adapter_resolver.rb

@@ -370,15 +370,12 @@ module Lutaml
 
         # Detect available XML adapter.
         #
-        # @return [Symbol, nil] :nokogiri, :ox, :oga, :rexml, or nil
+        # Delegates to moxml which is the authority on XML adapter
+        # availability and platform constraints (Opal, MRI, etc.).
+        #
+        # @return [Symbol] adapter type name
         def detect_xml_adapter
-          return :oga if RuntimeCompatibility.opal?
-          return :nokogiri if Utils.safe_load("nokogiri", :Nokogiri)
-          return :ox if Utils.safe_load("ox", :Ox)
-          return :oga if Utils.safe_load("oga", :Oga)
-          return :rexml if Utils.safe_load("rexml", :REXML)
-
-          nil
+          Moxml::Config.runtime_default_adapter
         end
 
         # Detect available TOML adapter.

data/lib/lutaml/model/mapping/mapping.rb

@@ -3,6 +3,8 @@ module Lutaml
     class Mapping
       include DeepDupable
 
+      attr_writer :mappings
+
       def initialize
         @mappings = []
         @listeners = {} # target => [Listener, ...]
@@ -11,6 +13,16 @@ module Lutaml
         @mappings_imported = ::Hash.new { |h, k| h[k] = false }
       end
 
+      def deep_dup
+        duped = self.class.new
+        duped.mappings = duplicate_mappings
+        duped
+      end
+
+      def duplicate_mappings
+        Lutaml::Model::Utils.deep_dup(@mappings)
+      end
+
       # Get listeners for a specific target (element name/key).
       #
       # @param target [String, Symbol] The element name or key

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.11"
+    VERSION = "0.8.12"
   end
 end

data/lib/lutaml/toml/adapter/mapping.rb

@@ -8,10 +8,8 @@ module Lutaml
           super(:toml)
         end
 
-        def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
-          end
+        def dup_instance
+          self.class.new
         end
 
         def validate!(key, to, with, render_nil, render_empty)

data/lib/lutaml/xml/schema/xsd.rb

@@ -2,11 +2,12 @@
 
 # NOTE: Do NOT require lutaml/model here. This file is autoloaded via
 # Lutaml::Xml::Schema::Xsd, and requiring lutaml/model creates a circular
-# dependency since lutaml/xml.rb requires lutaml/model. The adapter type
-# is already set by lutaml/xml.rb at the end.
+# dependency since lutaml/xml.rb requires lutaml/model. This file only sets
+# a fallback XML adapter when no adapter has been selected yet.
 
-adapter = RUBY_ENGINE == "opal" ? :oga : :nokogiri
-Lutaml::Model::Config.xml_adapter_type = adapter unless defined?(Lutaml::Model::Config.xml_adapter_type)
+unless defined?(Lutaml::Model::Config.xml_adapter_type)
+  Lutaml::Model::Config.xml_adapter_type = Lutaml::Model::AdapterResolver.detect_xml_adapter
+end
 
 # Require the XsdNamespace class for XSD schema support
 require_relative "xsd_namespace"

data/lib/lutaml/xml/schema.rb

@@ -3,11 +3,14 @@
 module Lutaml
   module Xml
     module Schema
-      autoload :Xsd, "#{__dir__}/schema/xsd"
-      autoload :XsdSchema, "#{__dir__}/schema/xsd_schema"
-      autoload :RelaxngSchema, "#{__dir__}/schema/relaxng_schema"
-      autoload :Builder, "#{__dir__}/schema/builder"
-      autoload :BuiltinTypes, "#{__dir__}/schema/builtin_types"
+      Lutaml::Model::RuntimeCompatibility.autoload_native(
+        self,
+        Xsd: "#{__dir__}/schema/xsd",
+        XsdSchema: "#{__dir__}/schema/xsd_schema",
+        RelaxngSchema: "#{__dir__}/schema/relaxng_schema",
+        Builder: "#{__dir__}/schema/builder",
+        BuiltinTypes: "#{__dir__}/schema/builtin_types",
+      )
     end
   end
 end

data/lib/lutaml/xml/xml_orderable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # Mixin for XML element/attribute ordering state.
+    #
+    # Included by:
+    #   - Lutaml::Xml::Serialization::InstanceMethods (Serialize instances)
+    #   - Plain model classes via add_format_specific_model_methods
+    #
+    # Enables Lutaml::Model to check ordering capability with is_a? instead
+    # of respond_to?, following proper OOP type-checking.
+    module XmlOrderable
+      attr_accessor :element_order, :attribute_order, :ordered, :mixed
+    end
+  end
+end

data/lib/lutaml/xml.rb

@@ -42,16 +42,13 @@ module Lutaml
     # XML Schema modules
     autoload :Schema, "#{__dir__}/xml/schema"
 
-    # Detect available XML adapter
-    # @return [Symbol, nil] :nokogiri, :ox, :oga, :rexml, or nil
+    # Detect available XML adapter.
+    # Delegates to moxml, which is the authority on XML adapter
+    # availability and platform constraints.
+    #
+    # @return [Symbol] adapter type name
     def self.detect_xml_adapter
-      return :oga if Lutaml::Model::RuntimeCompatibility.opal?
-      return :nokogiri if Lutaml::Model::Utils.safe_load("nokogiri", :Nokogiri)
-      return :ox if Lutaml::Model::Utils.safe_load("ox", :Ox)
-      return :oga if Lutaml::Model::Utils.safe_load("oga", :Oga)
-      return :rexml if Lutaml::Model::Utils.safe_load("rexml", :REXML)
-
-      nil
+      Moxml::Config.runtime_default_adapter
     end
 
     # Get the current XML adapter
@@ -174,8 +171,8 @@ Lutaml::Model::FormatRegistry.register(
   ],
   adapter_options: if Lutaml::Model::RuntimeCompatibility.opal?
                      {
-                       available: %i[oga],
-                       default: :oga,
+                       available: %i[rexml],
+                       default: :rexml,
                      }
                    else
                      {

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

@@ -8,10 +8,8 @@ module Lutaml
           super(:yaml)
         end
 
-        def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
-          end
+        def dup_instance
+          self.class.new
         end
       end
     end

data/lib/lutaml/yamls/adapter/mapping.rb

@@ -4,7 +4,7 @@ module Lutaml
   module Yamls
     module Adapter
       class Mapping < Lutaml::KeyValue::Mapping
-        attr_reader :yamls_sequence
+        attr_accessor :yamls_sequence
 
         def initialize
           super(:yaml)
@@ -15,9 +15,13 @@ module Lutaml
           @yamls_sequence.instance_eval(&)
         end
 
+        def dup_instance
+          self.class.new
+        end
+
         def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
+          super.tap do |new_mapping|
+            new_mapping.yamls_sequence = @yamls_sequence&.dup
           end
         end
       end

data/lutaml-model.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", ">= 0.1.20"
+  spec.add_dependency "moxml", ">= 0.1.22"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"

data/spec/lutaml/model/opal_smoke_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Opal compatibility", if: RUBY_ENGINE == "opal" do
+  it "includes Serialize in a class" do
+    klass = Class.new { include Lutaml::Model::Serialize }
+    expect(klass.include?(Lutaml::Model::Serialize)).to be true
+  end
+
+  it "defines attributes and serializes to hash" do
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :age, :integer
+    end
+
+    instance = person.new(name: "Alice", age: 30)
+    expect(instance.to_hash).to eq({ "name" => "Alice", "age" => 30 })
+  end
+
+  it "round-trips JSON serialization" do
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :age, :integer
+    end
+
+    instance = person.from_json('{"name":"Bob","age":25}')
+    expect(instance.name).to eq("Bob")
+    expect(instance.age).to eq(25)
+  end
+
+  it "handles collections" do
+    team = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :members, :string, collection: true
+    end
+
+    instance = team.new(members: %w[Alice Bob Carol])
+    expect(instance.members).to eq(%w[Alice Bob Carol])
+  end
+
+  it "handles defaults" do
+    widget = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :active, :boolean, default: -> { true }
+    end
+
+    instance = widget.new(name: "test")
+    expect(instance.active).to be true
+  end
+
+  it "handles type coercion" do
+    record = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :count, :integer
+      attribute :ratio, :float
+      attribute :flag, :boolean
+    end
+
+    instance = record.new(count: "42", ratio: "3.14", flag: "true")
+    expect(instance.count).to eq(42)
+    expect(instance.ratio).to eq(3.14)
+    expect(instance.flag).to be true
+  end
+
+  it "handles nested models" do
+    address = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :city, :string
+      attribute :zip, :string
+    end
+
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :address, address
+    end
+
+    instance = person.new(name: "Alice",
+                          address: address.new(
+                            city: "NYC", zip: "10001",
+                          ))
+    expect(instance.address.city).to eq("NYC")
+  end
+
+  it "handles YAML serialization" do
+    config = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :host, :string
+      attribute :port, :integer
+    end
+
+    instance = config.from_yaml("host: localhost\nport: 8080\n")
+    expect(instance.host).to eq("localhost")
+    expect(instance.port).to eq(8080)
+  end
+
+  it "RuntimeCompatibility detects Opal" do
+    expect(Lutaml::Model::RuntimeCompatibility.opal?).to be true
+  end
+
+  it "AdapterResolver auto-detects REXML" do
+    adapter = Lutaml::Model::AdapterResolver.detect_xml_adapter
+    expect(adapter).to eq(:rexml)
+  end
+end

data/spec/lutaml/xml/opal_xml_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML with REXML under Opal", if: RUBY_ENGINE == "opal" do
+  before do
+    Lutaml::Model::Config.xml_adapter_type = :rexml
+  end
+
+  it "round-trips XML through parse and serialize" do
+    klass = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      xml do
+        root "person"
+        map_element "name", to: :name
+      end
+    end
+
+    instance = klass.from_xml("<person><name>Alice</name></person>")
+    expect(instance.name).to eq("Alice")
+    expect(instance.to_xml).to include("<name>Alice</name>")
+  end
+
+  it "handles XML attributes" do
+    klass = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :id, :string
+      attribute :value, :string
+      xml do
+        root "item"
+        map_attribute "id", to: :id
+        map_element "value", to: :value
+      end
+    end
+
+    instance = klass.from_xml('<item id="42"><value>test</value></item>')
+    expect(instance.id).to eq("42")
+    expect(instance.value).to eq("test")
+  end
+
+  it "handles nested elements" do
+    address = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :city, :string
+      xml do
+        root "address"
+        map_element "city", to: :city
+      end
+    end
+
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :address, address
+      xml do
+        root "person"
+        map_element "name", to: :name
+        map_element "address", to: :address
+      end
+    end
+
+    instance = person.from_xml("<person><name>Alice</name><address><city>NYC</city></address></person>")
+    expect(instance.name).to eq("Alice")
+    expect(instance.address.city).to eq("NYC")
+  end
+
+  it "handles element collections" do
+    list = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :items, :string, collection: true
+      xml do
+        root "list"
+        map_element "item", to: :items
+      end
+    end
+
+    instance = list.from_xml("<list><item>a</item><item>b</item><item>c</item></list>")
+    expect(instance.items).to eq(%w[a b c])
+  end
+
+  it "handles mixed content" do
+    paragraph = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :content, :string, collection: true
+      xml do
+        root "p"
+        mixed_content
+        map_content to: :content
+      end
+    end
+
+    instance = paragraph.from_xml("<p>Hello <b>world</b> end</p>")
+    expect(instance.content.join).to include("Hello")
+  end
+
+  it "serializes to XML with correct structure" do
+    item = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :title, :string
+      attribute :count, :integer
+      xml do
+        root "item"
+        map_element "title", to: :title
+        map_element "count", to: :count
+      end
+    end
+
+    instance = item.new(title: "Widget", count: 5)
+    xml = instance.to_xml
+    expect(xml).to include("<title>Widget</title>")
+    expect(xml).to include("<count>5</count>")
+  end
+
+  it "handles XmlOrderable on plain model classes" do
+    plain_model = Class.new do
+      attr_accessor :data
+    end
+
+    Class.new do
+      include Lutaml::Model::Serialize
+
+      const_set(:MODEL_CLASS, plain_model)
+      model plain_model
+      attribute :data, :string
+      xml do
+        root "data"
+        map_element "data", to: :data
+      end
+    end
+
+    expect(plain_model.ancestors).to include(Lutaml::Xml::XmlOrderable)
+  end
+
+  it "uses REXML adapter by default under Opal" do
+    expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
+  end
+end

data/spec/lutaml/xml/xml_spec.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "open3"
 require "lutaml/xml"
 
 RSpec.describe Lutaml::Xml do
-  describe "standalone loading" do
-    let(:lib_path) { File.expand_path("../../../lib", __dir__) }
+  let(:lib_path) { File.expand_path("../../../lib", __dir__) }
 
-    it "lazy-loads the schema namespace from the XML entry point" do
-      # rubocop:disable Style/CommandLiteral
-      result = `#{RbConfig.ruby} -I#{lib_path} -e 'require "lutaml/xml"; abort "missing Schema autoload" unless Lutaml::Xml.autoload?(:Schema); abort "missing Xsd autoload" unless Lutaml::Xml::Schema.const_defined?(:Xsd, false); puts :ok' 2>&1`
-      # rubocop:enable Style/CommandLiteral
+  def run_ruby(script)
+    stdout, stderr, status = Open3.capture3(
+      RbConfig.ruby, "-I#{lib_path}", "-e", script
+    )
 
-      expect($?.success?).to be(true), result
+    [stdout + stderr, status]
+  end
+
+  describe "standalone loading" do
+    it "lazy-loads the schema namespace from the XML entry point" do
+      script = <<~RUBY
+        require "lutaml/xml"
+        abort "missing Schema autoload" unless Lutaml::Xml.autoload?(:Schema)
+        unless Lutaml::Xml::Schema.const_defined?(:Xsd, false)
+          abort "missing Xsd autoload"
+        end
+        puts :ok
+      RUBY
+
+      result, status = run_ruby(script)
+
+      expect(status.success?).to be(true), result
       expect(result).to include("ok")
     end
   end
@@ -22,6 +38,44 @@ RSpec.describe Lutaml::Xml do
       expect(described_class::Schema.const_defined?(:Xsd, false))
         .to be(!Lutaml::Model::RuntimeCompatibility.opal?)
     end
+
+    it "does not autoload schema constants when loaded under Opal" do
+      script = <<~'RUBY'
+        require "lutaml/model/runtime_compatibility"
+
+        module Lutaml
+          module Model
+            module RuntimeCompatibility
+              def self.opal?
+                true
+              end
+            end
+          end
+        end
+
+        require "lutaml/xml/schema"
+
+        schema_constants = %i[
+          Xsd XsdSchema RelaxngSchema Builder BuiltinTypes
+        ]
+
+        loaded_constants = schema_constants.select do |constant_name|
+          Lutaml::Xml::Schema.autoload?(constant_name) ||
+            Lutaml::Xml::Schema.const_defined?(constant_name, false)
+        end
+
+        if loaded_constants.any?
+          abort "loaded schema constants: #{loaded_constants.join(', ')}"
+        end
+
+        puts :ok
+      RUBY
+
+      result, status = run_ruby(script)
+
+      expect(status.success?).to be(true), result
+      expect(result).to include("ok")
+    end
   end
 
   describe "schema methods" do
@@ -66,9 +120,6 @@ RSpec.describe Lutaml::Xml do
       hide_const("Ox") if Object.const_defined?(:Ox)
       hide_const("Oga") if Object.const_defined?(:Oga)
       hide_const("REXML") if Object.const_defined?(:REXML)
-
-      # Stub require to prevent any actual requires during testing
-      allow(Lutaml::Model::Utils).to receive(:require).and_return(true)
     end
 
     context "when Nokogiri is available" do
@@ -101,9 +152,9 @@ RSpec.describe Lutaml::Xml do
       end
     end
 
-    context "when no adapters are available" do
-      it "returns nil" do
-        expect(described_class.detect_xml_adapter).to be_nil
+    context "when no adapters are detected" do
+      it "falls back to moxml default (:nokogiri)" do
+        expect(described_class.detect_xml_adapter).to eq(:nokogiri)
       end
     end
 

data/spec/support/opal.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Opal runtime patches for lutaml-model specs
+if RUBY_ENGINE == "opal"
+  Lutaml::Model::Config.xml_adapter_type = :rexml
+end