lutaml-model 0.8.60 → 0.8.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b57929b74102c6555ab5cc9a03246dbb3ebd4b59952bf09b6add75b8c9f067f
-  data.tar.gz: c0e7e209ab27a89d83b63deeefa042f721c02d8077aff94f686b53550ef8ea8f
+  metadata.gz: 93221695e02a0814183bb7935d242d416e7b5fc98fdae729ae7b7a548276fa1a
+  data.tar.gz: a8c6631206d1ed3dc635012999f11a2deb9f29409a441a4b85e8d47dd7f2fa9c
 SHA512:
-  metadata.gz: 5198b96f62132b22ead982492ca82cbb5291956ca4d508242d779957f4f89a54eaeef44935fae3260c108abab0e90c03c51259e2dac9c18c5c8b98c0a82b4d65
-  data.tar.gz: cf919daaea830dea7b44a59cf36b9c8dfb28c67d750137d5130c072c9ac297d1a78c37cd6d6d9a29be85c1819c485f1290e0d730b0c79fdb8da762ea9a1508d4
+  metadata.gz: db7ee4ad6d440102cbf7c2c8452b20844c1ddb251a44f86d44f0655e14f359eb1e1fa17debc2f0857485c34b09c9199c6921c31a55b1910aa103ac0fd5e11ff8
+  data.tar.gz: c8a43921457c96865466b5cb0111ccd4e6aba04585bb6e398bc7ad6f808a2009f2bbffa48e8dc1348ba10937776c96c0707249ab54d0bc018d900c4799eb98e3

data/.github/workflows/downstream-performance.yml

@@ -18,14 +18,15 @@ jobs:
   benchmark:
     runs-on: ubuntu-latest
     timeout-minutes: 60
-    # Serializes the corpus legs: concurrent legs on shared runners
-    # produce contention measurements that misfire the absolute gates
-    # (lutaml-model#834: niso 0.921s vs a 0.25s main-passing gate).
-    concurrency:
-      group: downstream-benchmark
-      cancel-in-progress: false
     strategy:
       fail-fast: false
+      # Serializes the corpus legs: concurrent legs on shared runners
+      # produce contention measurements that misfire the absolute gates
+      # (lutaml-model#834: niso 0.921s vs a 0.25s main-passing gate).
+      # max-parallel, NOT a job-level concurrency group: with a
+      # matrix, every leg lands in the same group and GitHub cancels
+      # four of the five at start.
+      max-parallel: 1
       matrix:
         include:
           - downstream: xmi

data/.github/workflows/rake.yml

@@ -23,10 +23,13 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
         ruby: ["3.3", "3.4", "4.0"]
         experimental: [false]
-        include:
+        # ruby head runs on ubuntu/macos only: windows-head cannot build
+        # the released ruby-ll C extension (and the vendored forks exist
+        # for Opal), so that cell was permanently red with zero signal
+        # (#832 follow-up).
+        exclude:
           - os: windows-latest
             ruby: head
-            experimental: true
     steps:
       - uses: actions/checkout@v6
         with:

data/.github/workflows/release.yml

@@ -44,13 +44,27 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
+        # The release job commits the version bump to main while this job
+        # runs; a checkout of the dispatch-time HEAD reads the previous
+        # version and smoke-tests the wrong gem (0.8.60 was smoke-checked
+        # for the 0.8.61 release). Pull post-bump main before resolving.
+        with:
+          fetch-depth: 5
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: "3.4"
       - name: Resolve the released version
         id: version
-        run: echo "version=$(git describe --tags --abbrev=0 | sed 's/^v//')" >> "$GITHUB_OUTPUT"
+        # From the version file, not git describe: the default checkout
+        # is shallow with no tags, so git describe failed and the empty
+        # version produced `gem install "lutaml-model:"`.
+        run: |
+          git pull --ff-only origin main
+          echo "version=$(ruby -e 'print File.read(%q{lib/lutaml/model/version.rb})[/VERSION\s*=\s*"([^"]+)"/, 1]')" >> "$GITHUB_OUTPUT"
       - name: Install and smoke the released gem
         run: |
           gem install "lutaml-model:${{ steps.version.outputs.version }}" --no-document
+          # The round-trip script exercises all five formats; the TOML
+          # legs require an adapter gem to be present.
+          gem install tomlib toml-rb --no-document
           ruby .github/scripts/test_installed_gem.rb

data/lib/lutaml/model/adapter_resolver.rb

@@ -250,8 +250,9 @@ module Lutaml
                                      adapter, type)
                          end
           require adapter_path
-        rescue LoadError
-          raise UnknownAdapterTypeError.new(adapter, type), cause: nil
+        rescue LoadError => e
+          # Chain the cause so a missing engine gem is named, not masked.
+          raise UnknownAdapterTypeError.new(adapter, type), cause: e
         end
 
         # Load the Moxml adapter for XML and similar formats.

data/lib/lutaml/model/schema/generator/definition.rb

@@ -23,9 +23,23 @@ module Lutaml
               },
             }
 
-            # Add choice validation if present
+            # Choice validation follows the serializer's contract: unset
+            # or empty members are omitted from output, and instances that
+            # leave a whole group empty are accepted (#869). Members are
+            # therefore never `required`; a max:1 group contributes an
+            # at-most-one constraint over its members, and independent
+            # groups combine conjunctively under allOf. Groups whose range
+            # admits several members impose no serialization constraint.
             if type.choice_attributes.any?
-              @schema[name]["oneOf"] = generate_choice_attributes(type)
+              groups = type.choice_attributes
+                .select { |choice| choice.max == 1 }
+                .map { |choice| { "oneOf" => exclusive_branches(choice) } }
+
+              if groups.one?
+                @schema[name].merge!(groups.first)
+              elsif groups.any?
+                @schema[name]["allOf"] = groups
+              end
             end
 
             @schema
@@ -33,15 +47,45 @@ module Lutaml
 
           private
 
-          def generate_choice_attributes(type)
-            type.choice_attributes.map do |choice|
+          # Leaves of the group (nested choices collapse into it), as
+          # [name, attribute] pairs.
+          def choice_leaves(choice)
+            choice.attributes.flat_map do |member|
+              if member.is_a?(Lutaml::Model::Choice)
+                choice_leaves(member)
+              else
+                [[member.name.to_s, member]]
+              end
+            end
+          end
+
+          # Exactly-one-present construction over the leaves: no leaf, or
+          # exactly one leaf present without the others. Accepts the
+          # all-empty document the serializer emits; rejects documents
+          # with two members of the group at once (max:1).
+          def exclusive_branches(choice)
+            leaves = choice_leaves(choice)
+            names = leaves.map(&:first)
+            none = {
+              "not" => {
+                "anyOf" => names.map { |n| { "required" => [n] } },
+              },
+            }
+            singles = leaves.map do |name, attribute|
+              others = names - [name]
               {
-                "type" => "object",
-                "properties" => PropertiesCollection.from_attributes(
-                  choice.attributes, extract_register_from(type)
-                ).to_schema,
+                "allOf" => (
+                  [{
+                    "type" => "object",
+                    "properties" => PropertiesCollection.from_attributes(
+                      [attribute], extract_register_from(type)
+                    ).to_schema,
+                    "required" => [name],
+                  }] + others.map { |o| { "not" => { "required" => [o] } } }
+                ),
               }
             end
+            [none] + singles
           end
 
           def properties_to_schema(type)

data/lib/lutaml/model/schema/generator/definitions_collection.rb

@@ -9,20 +9,18 @@ module Lutaml
             include SharedMethods
 
             def from_class(klass)
-              new.tap do |collection|
-                collection << Definition.new(klass)
-
-                process_attributes(collection, klass)
-              end
+              collection = new
+              register_definition(collection, klass)
+              collection
             end
 
-            def process_attributes(collection, klass)
+            def process_attributes(collection, klass, seen = {})
               register = extract_register_from(klass)
               klass.attributes.each_value do |attribute|
                 if attribute.union?
-                  process_union_members(collection, attribute)
+                  process_union_members(collection, attribute, seen)
                 elsif attribute.serializable?(register)
-                  process_attribute(collection, attribute, register)
+                  process_attribute(collection, attribute, register, seen)
                 end
               end
             end
@@ -30,31 +28,44 @@ module Lutaml
             # A union attribute's type is Type::Union, not a model, so collect
             # definitions for each of its Serializable members directly (a
             # union schema emits a $ref per model member).
-            def process_union_members(collection, attribute)
+            def process_union_members(collection, attribute, seen = {})
               attribute.union_member_types.each do |member|
                 next unless member.is_a?(::Class) &&
                   member.include?(Lutaml::Model::Serialize)
 
-                collection.merge(DefinitionsCollection.from_class(member))
+                register_definition(collection, member, seen)
               end
             end
 
-            def process_attribute(collection, attribute, register)
+            def process_attribute(collection, attribute, register, seen = {})
               attr_type = Lutaml::Model::GlobalContext.resolve_type(
                 attribute.type, register
               )
-              collection.merge(DefinitionsCollection.from_class(attr_type))
+              register_definition(collection, attr_type, seen)
 
-              process_polymorphic_types(collection, attribute)
+              process_polymorphic_types(collection, attribute, seen)
             end
 
-            def process_polymorphic_types(collection, attribute)
+            def process_polymorphic_types(collection, attribute, seen = {})
               return unless attribute.options&.[](:polymorphic)
 
               attribute.options[:polymorphic].each do |child|
-                collection.merge(DefinitionsCollection.from_class(child))
+                register_definition(collection, child, seen)
               end
             end
+
+            # Recursive models (Node#child → Node, or longer include
+            # cycles) are valid; the seen-set registers each class once
+            # and lets property references point at the shared $defs
+            # entry instead of recursing (#863).
+            def register_definition(collection, klass, seen = {})
+              return collection if seen[klass]
+
+              seen[klass] = true
+              collection << Definition.new(klass)
+              process_attributes(collection, klass, seen)
+              collection
+            end
           end
 
           attr_reader :definitions

data/lib/lutaml/model/schema.rb

@@ -52,11 +52,13 @@ module Lutaml
       end
 
       def self.to_json(klass, options = {})
-        JsonSchema.generate(klass, options)
+        # The generator signatures are keyword-only; splat so callers may
+        # pass an options hash positionally (#866).
+        JsonSchema.generate(klass, **options)
       end
 
       def self.to_yaml(klass, options = {})
-        YamlSchema.generate(klass, options)
+        YamlSchema.generate(klass, **options)
       end
 
       # XML-specific methods (to_xsd, to_relaxng, from_xml) are registered

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.60"
+    VERSION = "0.8.62"
   end
 end

data/lib/lutaml/xml/adapter_loader.rb

@@ -19,9 +19,12 @@ module Lutaml
                          File.join(File.dirname(__FILE__), "adapter", type)
                        end
         require adapter_path
-      rescue LoadError
+      rescue LoadError => e
+        # Chain the cause: a known adapter whose underlying engine gem is
+        # missing (e.g. no nokogiri in the Gemfile) must not present as a
+        # bare unknown-type error — the LoadError names the real gap.
         raise Lutaml::Model::UnknownAdapterTypeError.new("xml", type),
-              cause: nil
+              cause: e
       end
 
       # Load the Moxml adapter for XML

data/lib/lutaml/xml/plan_hydrator.rb

@@ -200,7 +200,15 @@ module Lutaml
             case kind
             when :content_deferred
               runs = content_runs(value)
-              next if runs.empty?
+              if runs.empty?
+                # The interpretive pipeline marks every applied rule's
+                # attribute set (model_transform apply). Skipping the
+                # mark leaves using_default? true, so the serializer's
+                # render gate suppresses a mapped reader that derives
+                # content from other attributes (#856).
+                instance.value_set_for(attr.name)
+                next
+              end
 
               # Non-collection content attrs hold the joined text
               # (the interpretive path assigns element text, the runs

data/spec/lutaml/model/schema/generation_regressions_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+require "spec_helper"
+
+RSpec.describe "JSON/YAML schema generation regressions (#863, #864, #865, #866)" do
+  before do
+    stub_const("SchemaRepro::Node", node_class)
+    stub_const("SchemaRepro::Outer", outer_class)
+    stub_const("SchemaRepro::Relation", relation_class)
+    stub_const("SchemaRepro::Simple", simple_class)
+  end
+
+  let(:node_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      xml { element "Node" }
+    end
+    klass.attribute :child, klass
+    klass
+  end
+
+  let(:outer_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      choice(min: 1, max: 1) do
+        choice(min: 1, max: 1) do
+          attribute :from, :string
+          attribute :to, :string
+        end
+        attribute :at, :string
+      end
+      xml { element "Outer" }
+    end
+  end
+
+  let(:relation_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :type, :string
+      choice(min: 1, max: 1) do
+        attribute :locality, :string, collection: true, initialize_empty: true
+        attribute :locality_stack, :string, collection: true, initialize_empty: true
+      end
+      choice(min: 1, max: 1) do
+        attribute :source_locality, :string, collection: true, initialize_empty: true
+        attribute :source_locality_stack, :string, collection: true, initialize_empty: true
+      end
+      xml { element "Relation" }
+    end
+  end
+
+  let(:simple_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :x, :string
+      xml { element "Simple" }
+    end
+  end
+
+  describe "#863: recursive models" do
+    it "terminates and emits one definition per class" do
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Node))
+      expect(schema["$defs"].keys).to contain_exactly("SchemaRepro_Node")
+    end
+
+    it "generates through the YAML path" do
+      yaml = Lutaml::Model::Schema.to_yaml(SchemaRepro::Node)
+      expect(YAML.safe_load(yaml)).to include("$defs")
+    end
+  end
+
+  describe "#864: nested choice blocks" do
+    it "collapses the nested group into the outer at-most-one set" do
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Outer))
+      one_of = schema["$defs"]["SchemaRepro_Outer"]["oneOf"]
+      requireds = one_of.map { |b| b["allOf"].to_a.filter_map { |s| s["required"]&.first } }
+      expect(requireds).to contain_exactly([], %w[from], %w[to], %w[at])
+    end
+  end
+
+  describe "#865: independent choices combine conjunctively" do
+    it "renders an allOf of oneOf at-most-one groups" do
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Relation))
+      all_of = schema["$defs"]["SchemaRepro_Relation"]["allOf"]
+      expect(all_of.length).to eq(2)
+      all_of.each do |group|
+        expect(group).to have_key("oneOf")
+        expect(group["oneOf"].length).to eq(3)
+      end
+    end
+  end
+
+  describe "#869: the serializer's own output validates" do
+    it "emits no required keys for initialize_empty choice members" do
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Relation))
+      definition = schema["$defs"]["SchemaRepro_Relation"]
+      groups = definition["allOf"] || [definition]
+      groups.each do |group|
+        group["oneOf"].each do |branch|
+          Array(branch["allOf"]).each do |sub|
+            expect(sub).not_to have_key("required") if sub.key?("not")
+          end
+        end
+      end
+    end
+
+    it "accepts the document the default instance serializes to" do
+      inst = SchemaRepro::Relation.new(type: "includes")
+      doc = inst.to_hash
+      expect(doc).to eq("type" => "includes")
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Relation))
+      definition = schema["$defs"]["SchemaRepro_Relation"]
+      groups = definition["allOf"] || [definition]
+      groups.each do |group|
+        satisfied = group["oneOf"].count do |branch|
+          Array(branch["allOf"]).all? do |sub|
+            if sub.key?("not")
+              Array(sub["not"]["anyOf"]).none? do |req|
+                doc.key?(req["required"].first)
+              end
+            else
+              doc.key?(sub["required"].first)
+            end
+          end
+        end
+        expect(satisfied).to eq(1)
+      end
+    end
+  end
+
+  describe "#866: Schema.to_json / to_yaml delegation" do
+    it "accepts a positional options hash" do
+      expect { Lutaml::Model::Schema.to_json(SchemaRepro::Simple) }
+        .not_to raise_error
+      expect { Lutaml::Model::Schema.to_yaml(SchemaRepro::Simple) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/lutaml/model/schema/json_schema_spec.rb

@@ -161,19 +161,7 @@ RSpec.describe Lutaml::Model::Schema::JsonSchema do
                   "type" => ["string", "null"],
                 },
               },
-              "oneOf" => [
-                {
-                  "type" => "object",
-                  "properties" => {
-                    "email" => {
-                      "type" => ["string", "null"],
-                    },
-                    "phone" => {
-                      "type" => ["string", "null"],
-                    },
-                  },
-                },
-              ],
+
             },
           },
         }

data/spec/lutaml/model/schema/yaml_schema_spec.rb

@@ -136,17 +136,6 @@ RSpec.describe Lutaml::Model::Schema::YamlSchema do
                   type:
                   - string
                   - 'null'
-              oneOf:
-              - type: object
-                properties:
-                  email:
-                    type:
-                    - string
-                    - 'null'
-                  phone:
-                    type:
-                    - string
-                    - 'null'
         YAML
       end
 

data/spec/lutaml/xml/adapter_loader_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Xml::AdapterLoader do
+  it "chains the LoadError cause instead of masking it" do
+    expect do
+      described_class.load_adapter_file("xml", "bogus_adapter")
+    end.to raise_error(Lutaml::Model::UnknownAdapterTypeError) do |error|
+      expect(error.cause).to be_a(LoadError)
+      expect(error.cause.message).to include("bogus_adapter")
+    end
+  end
+end

data/spec/lutaml/xml/leptris_string_encoding_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#858: leptris hydrates :string values as ASCII-8BIT
+# (FFI's :string return tag) while nokogiri returns UTF-8. Values are
+# character data; both adapters must agree on the encoding.
+RSpec.describe "leptris string encoding parity with nokogiri",
+               if: defined?(Leptris::XML::Document) do
+  let(:xml) do
+    <<~XML
+      <Relationship Id="rId5" Target="http://example.com/x"/>
+    XML
+  end
+
+  let(:klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :target, :string
+
+      xml do
+        element "Relationship"
+        map_attribute "Id", to: :id
+        map_attribute "Target", to: :target
+      end
+    end
+  end
+
+  before do
+    stub_const("LeptrisEncoding::Rel", klass)
+  end
+
+  it "hydrates attribute values as UTF-8" do
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      parsed = klass.from_xml(xml)
+      expect(parsed.id.encoding).to eq(Encoding::UTF_8)
+      expect(parsed.target.encoding).to eq(Encoding::UTF_8)
+    end
+
+    Lutaml::Model::Config.with_adapter(xml: :leptris) do
+      parsed = klass.from_xml(xml)
+      expect(parsed.id.encoding).to eq(Encoding::UTF_8)
+      expect(parsed.target.encoding).to eq(Encoding::UTF_8)
+    end
+  end
+
+  it "hydrates element text as UTF-8" do
+    doc = "<Note>café – naïve</Note>"
+    text_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :text, :string
+
+      xml do
+        element "Note"
+        map_content to: :text
+      end
+    end
+    stub_const("LeptrisEncoding::Note", text_class)
+
+    Lutaml::Model::Config.with_adapter(xml: :leptris) do
+      parsed = text_class.from_xml(doc)
+      expect(parsed.text.encoding).to eq(Encoding::UTF_8)
+      expect(parsed.text).to eq("café – naïve")
+    end
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -740,4 +740,53 @@ RSpec.describe "XML plan fast path" do
       %(<b xmlns="http://example.com/w" val="false"/>),
     ).value).to be(false)
   end
+
+  # lutaml-model#856: a deferred content row with no captured runs
+  # must still mark its attribute set — the interpretive pipeline
+  # marks every applied rule (model_transform apply). Without the
+  # mark, the serializer's default-suppression drops a mapped reader
+  # that derives content from other attributes.
+  it "renders derived content readers when no text was captured" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+      attribute :revision_date, :string
+      attribute :draft, :string
+
+      xml do
+        element "version"
+        map_content to: :content
+        map_element "revision-date", to: :revision_date
+        map_element "draft", to: :draft
+      end
+
+      define_method(:content) do
+        return @content if @content && !@content.empty?
+
+        parts = [@draft, @revision_date].compact
+        case parts.size
+        when 2 then "#{@draft} (#{@revision_date})"
+        when 1 then parts.first
+        end
+      end
+    end
+    stub_const("PlanFastPath::DerivedContent856", klass)
+
+    parsed = nil
+    Lutaml::Model::Config.with_adapter(xml: :leptris) do
+      parsed = klass.from_xml(
+        "<version><revision-date>1994-01-01</revision-date><draft>PD</draft></version>",
+      )
+      expect(parsed.using_default?(:content)).to be(false)
+      expect(parsed.to_xml).to eq(
+        "<version><revision-date>1994-01-01</revision-date>" \
+        "<draft>PD</draft>PD (1994-01-01)</version>",
+      )
+    end
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      expect(parsed.to_xml).to eq(
+        "<version><revision-date>1994-01-01</revision-date>" \
+        "<draft>PD</draft>PD (1994-01-01)</version>",
+      )
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.60
+  version: 0.8.62
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1789,6 +1789,7 @@ files:
 - spec/lutaml/model/root_mappings_spec.rb
 - spec/lutaml/model/rule_value_extractor_spec.rb
 - spec/lutaml/model/runtime_compatibility_spec.rb
+- spec/lutaml/model/schema/generation_regressions_spec.rb
 - spec/lutaml/model/schema/generator/definitions_collection_spec.rb
 - spec/lutaml/model/schema/json_schema_spec.rb
 - spec/lutaml/model/schema/json_schema_to_models_spec.rb
@@ -1903,6 +1904,7 @@ files:
 - spec/lutaml/xml/adapter/ox_adapter_spec.rb
 - spec/lutaml/xml/adapter/rexml_adapter_spec.rb
 - spec/lutaml/xml/adapter/xml_namespace_spec.rb
+- spec/lutaml/xml/adapter_loader_spec.rb
 - spec/lutaml/xml/attribute_ambiguity_surface_spec.rb
 - spec/lutaml/xml/attribute_element_namespace_disjoint_spec.rb
 - spec/lutaml/xml/attribute_namespace_disjointness_spec.rb
@@ -1932,6 +1934,7 @@ files:
 - spec/lutaml/xml/general_namespace_spec.rb
 - spec/lutaml/xml/html_entities_spec.rb
 - spec/lutaml/xml/indent_spec.rb
+- spec/lutaml/xml/leptris_string_encoding_spec.rb
 - spec/lutaml/xml/line_ending_spec.rb
 - spec/lutaml/xml/mapping_finalization_guard_spec.rb
 - spec/lutaml/xml/mapping_rule_spec.rb