lutaml-model 0.8.19 → 0.8.23

data/spec/lutaml/json/adapter/standard_adapter_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/json/adapter/standard_adapter"
+
+RSpec.describe Lutaml::Json::Adapter::StandardAdapter do
+  let(:attributes) { { "name" => "John", "age" => 30 } }
+
+  describe ".parse" do
+    # json 3.0 removed create_additions and now raises ArgumentError on any
+    # unknown keyword, so the parser must be called without it.
+    it "parses without passing removed generator keywords to the json gem" do
+      expect(described_class.parse('{"name":"John","age":30}'))
+        .to eq(attributes)
+    end
+  end
+
+  describe "#to_json" do
+    subject(:document) { described_class.new(attributes) }
+
+    it "serializes with no options" do
+      expect(document.to_json).to eq('{"name":"John","age":30}')
+    end
+
+    # :register and :pretty are LutaML's own options. json 2.x ignored unknown
+    # options; json 3.0 raises ArgumentError, so they must be stripped before
+    # they reach JSON.generate.
+    it "strips LutaML options that the json generator does not accept" do
+      expect(document.to_json(register: :default_register))
+        .to eq('{"name":"John","age":30}')
+    end
+
+    it "strips LutaML options when generating pretty output" do
+      expect(document.to_json(pretty: true, register: :default_register))
+        .to eq(%({\n  "name": "John",\n  "age": 30\n}))
+    end
+
+    # An ALLOWLIST and a denylist of LutaML's own option names behave
+    # identically for :register and :pretty. Only a key nobody enumerated
+    # tells them apart -- and json 3.0 raises on it.
+    it "strips a caller option nobody enumerated" do
+      expect(document.to_json(some_unknown_option: 1))
+        .to eq('{"name":"John","age":30}')
+    end
+
+    # json 3.0 removed :escape_slash. Dropping it would silently stop escaping
+    # slashes; it is the old alias of :script_safe, so it is translated.
+    it "honours escape_slash on every json version" do
+      expect(described_class.new({ "a" => "x/y" }).to_json(escape_slash: true))
+        .to eq('{"a":"x\\/y"}')
+    end
+
+    # The filter is an allowlist, not a passthrough: genuine generator options
+    # must still reach JSON.generate.
+    it "forwards options the json generator does accept" do
+      expect(document.to_json(register: :default_register, space: " "))
+        .to eq('{"name": "John","age": 30}')
+    end
+  end
+
+  describe "nesting inside another JSON.generate call" do
+    subject(:document) { described_class.new(attributes) }
+
+    # Ruby's generator hands #to_json a JSON::State, not an options hash.
+    # json 3.0 removed JSON::State#[], so reading :pretty off it raises.
+    it "serializes when nested in a Hash passed to JSON.generate" do
+      expect(JSON.generate({ "doc" => document }))
+        .to eq('{"doc":{"name":"John","age":30}}')
+    end
+
+    it "serializes when nested in an Array passed to JSON.generate" do
+      expect(JSON.generate([document])).to eq('[{"name":"John","age":30}]')
+    end
+
+    # A DEFAULT state renders compact, which is also what a DISCARDED state
+    # produces, so the two examples above cannot tell them apart. These carry
+    # formatting, so dropping the state changes the output.
+    it "inherits the outer indent when nested in a pretty Hash" do
+      expect(JSON.pretty_generate({ "doc" => document }))
+        .to eq(%({\n  "doc": {\n    "name": "John",\n    "age": 30\n  }\n}))
+    end
+
+    it "inherits the outer indent when nested in a pretty Array" do
+      expect(JSON.pretty_generate([document]))
+        .to eq(%([\n  {\n    "name": "John",\n    "age": 30\n  }\n]))
+    end
+
+    it "honours a configured JSON::State handed to #to_json directly" do
+      # A DEFAULT state renders compact, which is also what a discarded state
+      # produces -- so the state has to carry formatting for this to mean
+      # anything.
+      state = JSON::State.new(indent: "  ", object_nl: "\n", space: " ")
+      expect(document.to_json(state))
+        .to eq(%({\n  "name": "John",\n  "age": 30\n}))
+    end
+  end
+
+  describe Lutaml::Json::GeneratorOptions do
+    # The derived half of the allowlist reads JSON::State, which Opal's JSON
+    # shim does not define. BASE_PERMITTED is what the filter falls back to
+    # there, so it has to stand on its own.
+    # BASE_PERMITTED is the whole allowlist on Opal, whose JSON shim has no
+    # State class for DERIVED_PERMITTED to read. So it has to stand alone
+    # against the real generator, not merely be a subset of something larger.
+    it "permits only options the running generator actually accepts" do
+      rejected = described_class::BASE_PERMITTED.reject do |key|
+        JSON.generate({ "a" => 1 }, key => nil)
+        true
+      rescue ArgumentError => e
+        # "unknown keyword" means the generator does not know this option at
+        # all. Any other complaint -- a type error about the nil value we
+        # passed -- means it knows the option and only dislikes the value.
+        !e.message.include?("unknown keyword")
+      rescue StandardError
+        true
+      end
+
+      expect(rejected).to eq([])
+    end
+
+    # Opal's JSON shim defines no State class, so DERIVED_PERMITTED is empty
+    # there and the whole module must still load. Asserting that
+    # BASE_PERMITTED contains some symbols does not exercise the guard; only
+    # loading the file with JSON::State absent does.
+    it "loads and still permits the base set when JSON::State is absent" do
+      hide_const("JSON::State")
+
+      mod = Module.new
+      mod.module_eval(
+        File.read(File.expand_path("../../../../lib/lutaml/json/generator_options.rb", __dir__)),
+      )
+      permitted = mod.const_get(:Lutaml).const_get(:Json)
+        .const_get(:GeneratorOptions)::PERMITTED
+
+      expect(permitted).to eq(described_class::BASE_PERMITTED)
+    end
+
+    it "carries the formatting options pretty output depends on" do
+      expect(described_class::BASE_PERMITTED)
+        .to include(:indent, :object_nl, :space, :space_before)
+    end
+
+    it "rejects a non-Hash options argument" do
+      expect(described_class.filter(nil)).to eq({})
+    end
+
+    it "treats nil as LutaML options" do
+      expect(described_class.lutaml_options?(nil)).to be(true)
+    end
+
+    it "treats a Hash as LutaML options" do
+      expect(described_class.lutaml_options?({ pretty: true })).to be(true)
+    end
+
+    it "does not treat a JSON::State as LutaML options" do
+      expect(described_class.lutaml_options?(JSON::State.new)).to be(false)
+    end
+  end
+end

data/spec/lutaml/jsonld/adapter_spec.rb

@@ -43,4 +43,23 @@ RSpec.describe Lutaml::JsonLd::Adapter do
     round_tripped = JSON.parse(result)
     expect(round_tripped).to eq(jsonld_hash.transform_keys(&:to_s))
   end
+
+  describe "a JSON::State handed to #to_jsonld" do
+    subject(:document) { described_class.new({ "@id" => "urn:x", "n" => 1 }) }
+
+    # Ruby's generator only ever calls #to_json, so a state reaches #to_jsonld
+    # only from a direct caller. json 3.0 removed JSON::State#[], so the state
+    # must be forwarded to the payload rather than read as an options hash.
+    it "honours a state that carries formatting" do
+      state = JSON::State.new(indent: "  ", object_nl: "\n", space: " ")
+
+      expect(document.to_jsonld(state))
+        .to eq(%({\n  "@id": "urn:x",\n  "n": 1\n}))
+    end
+
+    it "renders compactly for a default state" do
+      expect(document.to_jsonld(JSON::State.new))
+        .to eq('{"@id":"urn:x","n":1}')
+    end
+  end
 end

data/spec/lutaml/model/attribute_apply_value_map_spec.rb

@@ -18,7 +18,8 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
     it "maps nil through value_map[:nil] => :empty to [] (collection)" do
       expect(
-        attribute(:string, collection: true).apply_value_map(nil, { nil: :empty }),
+        attribute(:string, collection: true).apply_value_map(nil,
+                                                             { nil: :empty }),
       ).to eq([])
     end
 
@@ -34,13 +35,15 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       custom_collection_class = Class.new(Lutaml::Model::Collection) do
         instances :items, member_class
       end
-      attr = described_class.new("items", member_class, collection: custom_collection_class)
+      attr = described_class.new("items", member_class,
+                                 collection: custom_collection_class)
       result = attr.apply_value_map(nil, { nil: :empty })
       expect(result).to be_a(custom_collection_class)
     end
 
     it "maps nil through value_map[:nil] => :omitted to UninitializedClass" do
-      expect(attribute(:string).apply_value_map(nil, { nil: :omitted })).to eq(uninit)
+      expect(attribute(:string).apply_value_map(nil,
+                                                { nil: :omitted })).to eq(uninit)
     end
   end
 
@@ -50,12 +53,14 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
     end
 
     it "maps '' through value_map[:empty] => :empty preserving '' for scalar" do
-      expect(attribute(:string).apply_value_map("", { empty: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map("",
+                                                { empty: :empty })).to eq("")
     end
 
     it "maps [] through value_map[:empty] => :empty preserving [] for collection" do
       expect(
-        attribute(:string, collection: true).apply_value_map([], { empty: :empty }),
+        attribute(:string, collection: true).apply_value_map([],
+                                                             { empty: :empty }),
       ).to eq([])
     end
 
@@ -69,11 +74,13 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "omitted handling" do
     it "maps UninitializedClass through value_map[:omitted] => :nil" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :nil })).to be_nil
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :nil })).to be_nil
     end
 
     it "maps UninitializedClass through value_map[:omitted] => :empty" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :empty })).to eq("")
     end
 
     it "does NOT route UninitializedClass through the :empty branch" do
@@ -81,18 +88,21 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       # utils.rb:132-137. Ensure dispatch order matches the originals: uninit
       # values go to :omitted, not :empty.
       expect(
-        attribute(:string).apply_value_map(uninit, { empty: :nil, omitted: :empty }),
+        attribute(:string).apply_value_map(uninit,
+                                           { empty: :nil, omitted: :empty }),
       ).to eq("")
     end
   end
 
   describe "Boolean bare-form (Boolean attribute type required)" do
     it "returns false directly for Boolean attribute, value_map[:empty] = false" do
-      expect(attribute(:boolean).apply_value_map("", { empty: false })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { empty: false })).to be(false)
     end
 
     it "returns true directly for Boolean attribute, value_map[:omitted] = true" do
-      expect(attribute(:boolean).apply_value_map(uninit, { omitted: true })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { omitted: true })).to be(true)
     end
 
     it "does NOT apply bare-boolean form to a non-Boolean attribute (documented tightening)" do
@@ -106,15 +116,18 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "Boolean nested-form (value_map[:from][:empty] / [:omitted])" do
     it "returns false from value_map[:from][:empty] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { from: { empty: false } })).to be(false)
     end
 
     it "returns true from value_map[:from][:omitted] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map(uninit, { from: { omitted: true } })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { from: { omitted: true } })).to be(true)
     end
 
     it "returns false from nested form even for non-Boolean attribute (no type gate)" do
-      expect(attribute(:string).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:string).apply_value_map("",
+                                                { from: { empty: false } })).to be(false)
     end
   end
 

data/spec/lutaml/model/attribute_spec.rb

@@ -358,7 +358,8 @@ RSpec.describe Lutaml::Model::Attribute do
       it "executes the proc in the instance context (reads instance attribute)" do
         instance = model_class.new(name: "Alice")
         attribute = model_class.attributes[:greeting]
-        expect(attribute.default_value(register, instance)).to eq("Hello, Alice")
+        expect(attribute.default_value(register,
+                                       instance)).to eq("Hello, Alice")
       end
     end
   end
@@ -413,7 +414,9 @@ RSpec.describe Lutaml::Model::Attribute do
         end
         instance = model_class.new(prefix: "Dr")
         attr = model_class.attributes[:name]
-        expect { attr.validate_value!(nil, register, instance_object: instance) }
+        expect do
+          attr.validate_value!(nil, register, instance_object: instance)
+        end
           .to raise_error(Lutaml::Model::InvalidValueError) do |error|
             # The error carries the value that was used for validation.
             # If instance_exec ran, value is "Dr_default"; if not, error
@@ -427,7 +430,9 @@ RSpec.describe Lutaml::Model::Attribute do
       it "short-circuits without raising" do
         uninit = Lutaml::Model::UninitializedClass.instance
         attr = described_class.new("name", :string)
-        expect { attr.validate_value!(uninit, register, instance_object: model) }
+        expect do
+          attr.validate_value!(uninit, register, instance_object: model)
+        end
           .not_to raise_error
       end
     end

data/spec/lutaml/model/collection_spec.rb

@@ -644,7 +644,7 @@ RSpec.describe Lutaml::Model::Collection do
       collection = title_collection_class.from_json(json_data)
 
       # JSON.parse should only be called once on the main array, not on individual strings
-      expect(JSON).to have_received(:parse).once.with(json_data, anything)
+      expect(JSON).to have_received(:parse).once.with(json_data)
       expect(collection.titles.map(&:content)).to eq(["Title One", "Title Two",
                                                       "Title Three"])
     end

data/spec/lutaml/model/collection_state_nesting_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A Collection overrides #to_format and merges `collection: true` into the
+# options BEFORE the base implementation runs. JSON::State#merge is #configure,
+# which rejects unknown keys on json 3.0, so the state has to be wrapped first.
+RSpec.describe "a collection nested inside JSON.generate" do
+  before do
+    stub_const("NestedItem", Class.new(Lutaml::Model::Serializable) do
+      attribute :n, :string
+    end)
+    stub_const("NestedItems", Class.new(Lutaml::Model::Collection) do
+      instances :items, NestedItem
+    end)
+  end
+
+  let(:collection) { NestedItems.new([NestedItem.new(n: "a")]) }
+
+  it "serializes inside a Hash" do
+    expect(JSON.generate({ "c" => collection })).to eq('{"c":[{"n":"a"}]}')
+  end
+
+  it "inherits the outer indent inside a pretty Hash" do
+    expect(JSON.pretty_generate({ "c" => collection }))
+      .to eq(%({\n  "c": [\n    {\n      "n": "a"\n    }\n  ]\n}))
+  end
+
+  # The class-level entry point normalises separately from the instance one,
+  # and deleting that normaliser leaves every instance example green.
+  it "normalises a state passed to the class-level entry point" do
+    # array_nl is what puts the newlines in an array; without it the state
+    # is not a pretty state at all and the example proves nothing.
+    state = JSON::State.new(indent: "  ", object_nl: "\n", array_nl: "\n",
+                            space: " ")
+
+    expect(NestedItems.to_json(collection, state))
+      .to eq(%([\n  {\n    "n": "a"\n  }\n]))
+  end
+
+  it "still serializes directly" do
+    expect(collection.to_json).to eq('[{"n":"a"}]')
+  end
+end

data/spec/lutaml/model/custom_bibtex_adapter_spec.rb

@@ -298,9 +298,9 @@ module CustomBibtexAdapterSpec
       add_mapping(name, to, field_type: :field, render_nil: render_nil)
     end
 
-    def add_mapping(name, to, **)
+    def add_mapping(name, to, **options)
       # validate!(name, to, {})
-      @mappings << BibtexMappingRule.new(name, to: to, **)
+      @mappings << BibtexMappingRule.new(name, to: to, **options)
     end
 
     def mapping_for_field(field)

data/spec/lutaml/model/custom_from_empty_values_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model#746: an empty value ("", [], {}) is a PRESENT value per
+# docs/_guides/missing-values-handling.adoc and must reach custom `from`
+# methods. Only nil (non-existent) and an omitted key (undefined) skip them.
+module CustomFromEmptyValuesSpec
+  class Tagged < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "tags", to: :received, with: { to: :tags_to, from: :tags_from }
+    end
+
+    def tags_to(model, doc)
+      doc["tags"] = model.received
+    end
+
+    def tags_from(model, value)
+      model.received = value.inspect
+    end
+  end
+
+  class Mapped < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "fields", to: :received, with: { to: :fields_to, from: :fields_from }
+    end
+
+    def fields_to(model, doc)
+      doc["fields"] = model.received
+    end
+
+    def fields_from(model, value)
+      model.received = value.inspect
+    end
+  end
+end
+
+RSpec.describe "custom from methods and empty values" do
+  it "receives an empty collection" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags: []").received)
+      .to eq("[]")
+  end
+
+  it "receives an empty string" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml('tags: ""').received)
+      .to eq("\"\"")
+  end
+
+  it "receives an empty mapping" do
+    expect(CustomFromEmptyValuesSpec::Mapped.from_yaml("fields: {}").received)
+      .to eq("{}")
+  end
+
+  it "receives empty values from JSON too" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": []})).received)
+      .to eq("[]")
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": ""})).received)
+      .to eq("\"\"")
+  end
+
+  it "still skips the method for a nil value" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags:").received)
+      .to be_nil
+  end
+
+  it "still skips the method for an omitted key" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("{}").received)
+      .to be_nil
+  end
+end

data/spec/lutaml/model/custom_vobject_adapter_spec.rb

@@ -201,8 +201,8 @@ module CustomVobjectAdapterSpec
       @objects
     end
 
-    def map(&)
-      @objects.map(&)
+    def map(&block)
+      @objects.map(&block)
     end
 
     private
@@ -260,16 +260,16 @@ module CustomVobjectAdapterSpec
       @element_type = element_type
     end
 
-    def map_value(to:, **)
-      add_mapping(:value, to, type: :simple, **)
+    def map_value(to:, **options)
+      add_mapping(:value, to, type: :simple, **options)
     end
 
-    def map_property(name, to:, type: :simple, **)
-      add_mapping(name.downcase, to, type: type, **)
+    def map_property(name, to:, type: :simple, **options)
+      add_mapping(name.downcase, to, type: type, **options)
     end
 
-    def map_component(name, to:, **)
-      add_mapping(name.downcase, to, type: :component, **)
+    def map_component(name, to:, **options)
+      add_mapping(name.downcase, to, type: :component, **options)
     end
 
     def map_field_set(count:, item_type:, item_options: {})

data/spec/lutaml/model/defaults_spec.rb

@@ -146,6 +146,33 @@ module DefaultsSpec
 
   class InstanceAwareGrandChild < InstanceAwareChild
   end
+
+  # Class-method defaults must keep resolving as they did before 0.8.0
+  # (lutaml-model#745): default lambdas are evaluated against the instance,
+  # with the model class as fallback for methods the instance does not have.
+  class ClassMethodDefault < Lutaml::Model::Serializable
+    attribute :os, :string, default: -> { detect_os }
+
+    def self.detect_os
+      "from-class-method"
+    end
+  end
+
+  class ClassMethodDefaultWithArgs < Lutaml::Model::Serializable
+    attribute :label, :string, default: -> { build_label("x") }
+
+    def self.build_label(prefix)
+      "#{prefix}-label"
+    end
+  end
+
+  class InstanceMethodDefault < Lutaml::Model::Serializable
+    attribute :value, :string, default: -> { instance_helper }
+
+    def instance_helper
+      "from-instance-method"
+    end
+  end
 end
 
 RSpec.describe DefaultsSpec::Glaze do
@@ -346,3 +373,21 @@ RSpec.describe DefaultsSpec::Glaze do
     end
   end
 end
+
+RSpec.describe DefaultsSpec::ClassMethodDefault do
+  it "resolves class methods from default lambdas" do
+    expect(described_class.new.os).to eq("from-class-method")
+  end
+end
+
+RSpec.describe DefaultsSpec::ClassMethodDefaultWithArgs do
+  it "passes arguments through to class methods" do
+    expect(described_class.new.label).to eq("x-label")
+  end
+end
+
+RSpec.describe DefaultsSpec::InstanceMethodDefault do
+  it "still resolves instance methods in default lambdas" do
+    expect(described_class.new.value).to eq("from-instance-method")
+  end
+end

data/spec/lutaml/model/generator_defaults_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "oj"
+require "multi_json"
+
+# What a nested model should do with the outer generator's options differs per
+# ADAPTER, not per option. Reference values are unmodified main on json 2.21.2.
+#
+#   stdlib  honours script_safe / ascii_only / pretty  -> receives the state
+#   Oj      ignores them and uses its own escape_mode  -> receives none of them
+#
+# Four earlier attempts at this got it wrong by reasoning about option names
+# instead of measuring each adapter, so every row here is a measured cell.
+RSpec.describe "generator options reaching a nested model" do
+  before do
+    stub_const("EscapeProbe", Class.new(Lutaml::Model::Serializable) do
+      attribute :s, :string
+    end)
+  end
+
+  let(:model) { EscapeProbe.new(s: "</script>é") }
+
+  describe "the stdlib adapter" do
+    it "honours script_safe" do
+      expect(JSON.generate({ "m" => model }, script_safe: true))
+        .to eq('{"m":{"s":"<\\/script>é"}}')
+    end
+
+    it "honours ascii_only" do
+      expect(JSON.generate({ "m" => model }, ascii_only: true))
+        .to eq('{"m":{"s":"</script>\\u00e9"}}')
+    end
+
+    it "honours the outer indent" do
+      expect(JSON.pretty_generate({ "m" => model }))
+        .to eq(%({\n  "m": {\n    "s": "</script>é"\n  }\n}))
+    end
+  end
+
+  describe "the Oj adapter" do
+    around do |example|
+      previous = Oj.default_options
+      Oj.default_options = { escape_mode: :xss_safe }
+      example.run
+      Oj.default_options = previous
+    end
+
+    # Oj must keep its OWN escaping. Forwarding the generator's options -- all
+    # of them, only the caller-set ones, or just ascii_only -- each reset
+    # escape_mode and silently emitted a literal </script>.
+    it "keeps its configured escape_mode when no option is passed" do
+      result = Lutaml::Model::Config.with_adapter(json: :oj) do
+        JSON.generate({ "m" => model })
+      end
+
+      expect(result).to eq('{"m":{"s":"\\u003c\\/script\\u003e\\u00e9"}}')
+    end
+
+    it "keeps its configured escape_mode when ascii_only is passed" do
+      result = Lutaml::Model::Config.with_adapter(json: :oj) do
+        JSON.generate({ "m" => model }, ascii_only: true)
+      end
+
+      expect(result).to eq('{"m":{"s":"\\u003c\\/script\\u003e\\u00e9"}}')
+    end
+
+    it "keeps its configured escape_mode when script_safe is passed" do
+      result = Lutaml::Model::Config.with_adapter(json: :oj) do
+        JSON.generate({ "m" => model }, script_safe: true)
+      end
+
+      expect(result).to eq('{"m":{"s":"\\u003c\\/script\\u003e\\u00e9"}}')
+    end
+  end
+
+  # MultiJson's json_gem backend IS the stdlib generator, so unlike Oj it does
+  # honour these options and must still receive them. That BACKEND cannot run
+  # under json 3.0 -- it sends create_additions, which json removed -- so these
+  # are asserted on the versions where it works. multi_json itself is fine
+  # under json 3.0 on its Oj backend; only json_gem is affected.
+  describe "the MultiJson adapter", if: Gem::Version.new(JSON::VERSION) < Gem::Version.new("3.0.0") do
+    before { MultiJson.use(:json_gem) }
+
+    it "still receives script_safe" do
+      result = Lutaml::Model::Config.with_adapter(json: :multi_json) do
+        JSON.generate({ "m" => model }, script_safe: true)
+      end
+
+      expect(result).to eq('{"m":{"s":"<\\/script>é"}}')
+    end
+
+    it "still receives ascii_only" do
+      result = Lutaml::Model::Config.with_adapter(json: :multi_json) do
+        JSON.generate({ "m" => model }, ascii_only: true)
+      end
+
+      expect(result).to eq('{"m":{"s":"</script>\\u00e9"}}')
+    end
+  end
+end

data/spec/lutaml/model/json_spec.rb

@@ -8,9 +8,8 @@ RSpec.describe Lutaml::Model::Json do
     let(:lib_path) { File.expand_path("../../../lib", __dir__) }
 
     it "loads require 'lutaml/json' without preloading lutaml/model" do
-      # rubocop:disable Style/CommandLiteral
+      # rubocop:disable-next Style/CommandLiteral
       result = `#{RbConfig.ruby} -I#{lib_path} -e 'require "lutaml/json"; puts :ok' 2>&1`
-      # rubocop:enable Style/CommandLiteral
 
       expect($?.success?).to be(true), result
       expect(result).to include("ok")