lutaml-model 0.8.61 → 0.8.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60d029c4eab58efd3741553bd22cc4f689164143f6f1fed87d4c6956cf341cfd
-  data.tar.gz: aefb886903788a07439e416b2a92ec7a5fe295f231aa6c137b606e6e9621b048
+  metadata.gz: e60ce4a1bedec13a3b778b0afea4c9be5c4779f721916bfafeb151e3bd8f8c1e
+  data.tar.gz: b6f519fabe6c9dc9c0c5edeb871d6afcc23d6439eff433b15b74b532b1a633d7
 SHA512:
-  metadata.gz: 82a30dcc2a930524ebb5d3d8cdcd9c9eb712f5425105b61101263501af2b66e93e5395e2455925e57d87e9a10689b8dbd1b816e9e0f302e4472ba68f084ed365
-  data.tar.gz: 76625bdefe2dde62258b0ec3da4ca257679fa16a9b669ca0a4453108097e9d670109e9b4f77f5b67c0cf76f95e18164edd2b477a885bb3ed5cc73c928174d6a8
+  metadata.gz: 646c4cfdfb4dc395f5f339332eb214b0d4cba7bf31710884357e5d8519db8825e0a8e937824f268bac8642ea5d23a7fee75686988b9d3a54923f508e50aaa3c0
+  data.tar.gz: d738e9c618790d6575691acc7349991f1b4f28986947e75a3dc40a883978cbc3ce7f6ef28021b7c85f822037c6c63137ed22f1930fe6aba36dd0b266f84a451b

data/.github/workflows/release.yml

@@ -44,6 +44,12 @@ 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"
@@ -52,8 +58,13 @@ jobs:
         # 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"
+        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/schema/generator/definition.rb

@@ -23,19 +23,22 @@ module Lutaml
               },
             }
 
-            # 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).
+            # 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?
-              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
+              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
 
@@ -44,30 +47,47 @@ module Lutaml
 
           private
 
-          # 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|
+          # 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_schema(member)
+                choice_leaves(member)
               else
-                {
-                  "type" => "object",
-                  "properties" => PropertiesCollection.from_attributes(
-                    [member], extract_register_from(type)
-                  ).to_schema,
-                  "required" => [member.name.to_s],
-                }
+                [[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]
+              {
+                "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)
             PropertiesCollection.from_class(type).to_schema
           end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.61"
+    VERSION = "0.8.63"
   end
 end

data/lib/lutaml/xml/adapter/xml_parser.rb

@@ -20,6 +20,7 @@ module Lutaml
           raw_xml = xml
           xml = normalize_xml_for_parse(xml)
           parsed = parse_with_moxml(xml, parse_encoding)
+          assert_no_truncated_recovered_parse!(parsed)
           root_element = parsed.root
 
           raise_empty_document_error if root_element.nil?
@@ -30,6 +31,25 @@ module Lutaml
           new(root, parse_encoding, **parse_document_options(raw_xml))
         end
 
+        # Recover-mode parsing must never masquerade input truncation as
+        # success.
+        #
+        # libxml2 (the Nokogiri backend) caps its input buffer at 10 MB;
+        # longer documents trip a fatal "Resource limit exceeded: Buffer
+        # size limit exceeded, try XML_PARSE_HUGE" error mid-input. In
+        # recover mode Nokogiri records that error on the document and
+        # returns the partial tree, so every node past the limit silently
+        # vanishes (lutaml-model#871). A resource-limit fatal means the
+        # engine stopped early with input left — refuse to deserialize the
+        # partial document instead of dropping trailing content without a
+        # trace.
+        #
+        # Other recover-mode fatals (e.g. an XML declaration after leading
+        # whitespace) do not drop content and keep the long-standing
+        # recover behavior; only the resource-limit family is truncating.
+        TRUNCATION_FATAL_MARKER =
+          /Resource limit exceeded|Buffer size limit exceeded/
+
         private
 
         def normalize_xml_for_parse(xml)
@@ -62,6 +82,23 @@ module Lutaml
           end
         end
 
+        def assert_no_truncated_recovered_parse!(parsed)
+          errors = parsed.parse_errors
+          return if errors.nil? || errors.empty?
+
+          fatal = errors.find do |message|
+            message.match?(TRUNCATION_FATAL_MARKER)
+          end
+          return if fatal.nil?
+
+          raise Lutaml::Model::InvalidFormatError.new(
+            :xml,
+            "the XML engine reported a fatal resource limit and recovered " \
+            "with a truncated document; refusing to deserialize " \
+            "partial input (#{fatal})",
+          )
+        end
+
         def parse_document_options(xml)
           {
             doctype: extract_doctype_from_xml(xml),

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

@@ -70,25 +70,60 @@ RSpec.describe "JSON/YAML schema generation regressions (#863, #864, #865, #866)
   end
 
   describe "#864: nested choice blocks" do
-    it "renders the nested group as its own oneOf" 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"]
-      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])
+      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 groups with discriminating required keys" 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")
-        group["oneOf"].each { |branch| expect(branch["required"]).to be_truthy }
+        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

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

@@ -161,26 +161,7 @@ RSpec.describe Lutaml::Model::Schema::JsonSchema do
                   "type" => ["string", "null"],
                 },
               },
-              "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,23 +136,6 @@ RSpec.describe Lutaml::Model::Schema::YamlSchema do
                   type:
                   - string
                   - 'null'
-              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/recovered_fatal_parse_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "nokogiri"
+require "lutaml/model"
+require "lutaml/xml"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# Regression tests for lutaml-model#871.
+#
+# libxml2 (the Nokogiri backend) caps its input buffer at 10 MB. Parsing a
+# longer document in recover mode records a FATAL "Resource limit exceeded:
+# Buffer size limit exceeded, try XML_PARSE_HUGE" error on the document and
+# returns the partial tree, so every node past the cap silently vanishes.
+# XmlParser now refuses documents whose parse_errors carry a fatal error
+# instead of deserializing the truncated input.
+RSpec.describe "recovered fatal parse errors" do
+  let(:annex_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+
+      xml do
+        element "annex"
+        map_attribute "id", to: :id
+      end
+    end
+  end
+
+  let(:root_class) do
+    annex = annex_class
+
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :annexes, annex, collection: true
+
+      xml do
+        element "metanorma"
+        map_element "annex", to: :annexes
+      end
+    end
+  end
+
+  def build_document(chunk_count:, chunk_size:, with_tail: false)
+    filler = "A" * chunk_size
+    document = +"<metanorma>"
+    chunk_count.times do |index|
+      document << %(<annex id="annex#{index}" data="#{filler}"/>)
+    end
+    document << %(<annex id="annex-tail-marker"/>) if with_tail
+    document << "</metanorma>"
+    document
+  end
+
+  # Six 1.7 MB attribute values push the cumulative input past libxml2's
+  # 10 MB buffer cap mid-document, mirroring the issue's failing manifest.
+  def over_cap_document
+    build_document(chunk_count: 6, chunk_size: 1_700_000, with_tail: true)
+  end
+
+  it "hits the libxml2 buffer cap in recover mode past 10 MB" do
+    errors = Nokogiri::XML(over_cap_document) { |config| config.recover.nonet }.errors
+
+    expect(errors.map(&:message).join("\n")).to match(/\bFATAL:/)
+  end
+
+  it "raises instead of silently truncating on the nokogiri path" do
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      expect { root_class.from_xml(over_cap_document) }
+        .to raise_error(Lutaml::Model::InvalidFormatError, /resource limit.*truncated/m)
+    end
+  end
+
+  it "raises from the adapter layer directly" do
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      expect { Lutaml::Xml::Adapter::NokogiriAdapter.parse(over_cap_document) }
+        .to raise_error(Lutaml::Model::InvalidFormatError, /XML_PARSE_HUGE/)
+    end
+  end
+
+  it "keeps parsing documents whose fatals do not drop content" do
+    xml = "  <?xml version=\"1.0\"?>\n<metanorma><annex id=\"a\"/></metanorma>"
+
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      model = root_class.from_xml(xml)
+
+      expect(model.annexes.map(&:id)).to eq(["a"])
+    end
+  end
+
+  it "still parses smaller documents without any fatal-error handling" do
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      model = root_class.from_xml(
+        build_document(chunk_count: 2, chunk_size: 500_000, with_tail: true),
+      )
+
+      expect(model.annexes.map(&:id))
+        .to eq(["annex0", "annex1", "annex-tail-marker"])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.61
+  version: 0.8.63
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1902,6 +1902,7 @@ files:
 - spec/lutaml/xml/adapter/oga_adapter_spec.rb
 - spec/lutaml/xml/adapter/order_spec.rb
 - spec/lutaml/xml/adapter/ox_adapter_spec.rb
+- spec/lutaml/xml/adapter/recovered_fatal_parse_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