lutaml-model 0.8.60 → 0.8.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b57929b74102c6555ab5cc9a03246dbb3ebd4b59952bf09b6add75b8c9f067f
-  data.tar.gz: c0e7e209ab27a89d83b63deeefa042f721c02d8077aff94f686b53550ef8ea8f
+  metadata.gz: 60d029c4eab58efd3741553bd22cc4f689164143f6f1fed87d4c6956cf341cfd
+  data.tar.gz: aefb886903788a07439e416b2a92ec7a5fe295f231aa6c137b606e6e9621b048
 SHA512:
-  metadata.gz: 5198b96f62132b22ead982492ca82cbb5291956ca4d508242d779957f4f89a54eaeef44935fae3260c108abab0e90c03c51259e2dac9c18c5c8b98c0a82b4d65
-  data.tar.gz: cf919daaea830dea7b44a59cf36b9c8dfb28c67d750137d5130c072c9ac297d1a78c37cd6d6d9a29be85c1819c485f1290e0d730b0c79fdb8da762ea9a1508d4
+  metadata.gz: 82a30dcc2a930524ebb5d3d8cdcd9c9eb712f5425105b61101263501af2b66e93e5395e2455925e57d87e9a10689b8dbd1b816e9e0f302e4472ba68f084ed365
+  data.tar.gz: 76625bdefe2dde62258b0ec3da4ca257679fa16a9b669ca0a4453108097e9d670109e9b4f77f5b67c0cf76f95e18164edd2b477a885bb3ed5cc73c928174d6a8

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

@@ -49,7 +49,10 @@ jobs:
           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: 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

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,20 @@ module Lutaml
               },
             }
 
-            # Add choice validation if present
+            # Choice validation: each choice is its own group. Independent
+            # choices combine conjunctively (allOf), so a document may
+            # satisfy every group at once; a single choice renders its
+            # group directly. Nested choices render as a nested group
+            # schema, which a document satisfies through its own
+            # oneOf/anyOf (#864, #865).
             if type.choice_attributes.any?
-              @schema[name]["oneOf"] = generate_choice_attributes(type)
+              if type.choice_attributes.one?
+                @schema[name].merge!(choice_schema(type.choice_attributes.first))
+              else
+                @schema[name]["allOf"] = type.choice_attributes.map do |choice|
+                  choice_schema(choice)
+                end
+              end
             end
 
             @schema
@@ -33,14 +44,27 @@ module Lutaml
 
           private
 
-          def generate_choice_attributes(type)
-            type.choice_attributes.map do |choice|
-              {
-                "type" => "object",
-                "properties" => PropertiesCollection.from_attributes(
-                  choice.attributes, extract_register_from(type)
-                ).to_schema,
-              }
+          # min == max == 1 makes the members mutually exclusive (oneOf);
+          # any other range admits several members together (anyOf with
+          # per-member requirement).
+          def choice_schema(choice)
+            key = choice.min == 1 && choice.max == 1 ? "oneOf" : "anyOf"
+            { key => choice_branches(choice) }
+          end
+
+          def choice_branches(choice)
+            choice.attributes.map do |member|
+              if member.is_a?(Lutaml::Model::Choice)
+                choice_schema(member)
+              else
+                {
+                  "type" => "object",
+                  "properties" => PropertiesCollection.from_attributes(
+                    [member], extract_register_from(type)
+                  ).to_schema,
+                  "required" => [member.name.to_s],
+                }
+              end
             end
           end
 

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.61"
   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,104 @@
+# 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 "renders the nested group as its own oneOf" do
+      schema = JSON.parse(Lutaml::Model::Schema.to_json(SchemaRepro::Outer))
+      one_of = schema["$defs"]["SchemaRepro_Outer"]["oneOf"]
+      at_branch = one_of.find { |b| b["required"] == %w[at] }
+      inner = one_of.find { |b| b["oneOf"] }
+      expect(at_branch).to be_truthy
+      expect(inner["oneOf"].map { |b| b["required"] })
+        .to contain_exactly(%w[from], %w[to])
+    end
+  end
+
+  describe "#865: independent choices combine conjunctively" do
+    it "renders an allOf of oneOf groups with discriminating required keys" 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")
+        group["oneOf"].each { |branch| expect(branch["required"]).to be_truthy }
+      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,17 +161,24 @@ RSpec.describe Lutaml::Model::Schema::JsonSchema do
                   "type" => ["string", "null"],
                 },
               },
-              "oneOf" => [
+              "anyOf" => [
                 {
                   "type" => "object",
                   "properties" => {
                     "email" => {
                       "type" => ["string", "null"],
                     },
+                  },
+                  "required" => ["email"],
+                },
+                {
+                  "type" => "object",
+                  "properties" => {
                     "phone" => {
                       "type" => ["string", "null"],
                     },
                   },
+                  "required" => ["phone"],
                 },
               ],
             },

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

@@ -136,17 +136,23 @@ RSpec.describe Lutaml::Model::Schema::YamlSchema do
                   type:
                   - string
                   - 'null'
-              oneOf:
+              anyOf:
               - type: object
                 properties:
                   email:
                     type:
                     - string
                     - 'null'
+                required:
+                - email
+              - type: object
+                properties:
                   phone:
                     type:
                     - string
                     - 'null'
+                required:
+                - phone
         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.61
 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