lutaml-model 0.8.61 → 0.8.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60d029c4eab58efd3741553bd22cc4f689164143f6f1fed87d4c6956cf341cfd
-  data.tar.gz: aefb886903788a07439e416b2a92ec7a5fe295f231aa6c137b606e6e9621b048
+  metadata.gz: 93221695e02a0814183bb7935d242d416e7b5fc98fdae729ae7b7a548276fa1a
+  data.tar.gz: a8c6631206d1ed3dc635012999f11a2deb9f29409a441a4b85e8d47dd7f2fa9c
 SHA512:
-  metadata.gz: 82a30dcc2a930524ebb5d3d8cdcd9c9eb712f5425105b61101263501af2b66e93e5395e2455925e57d87e9a10689b8dbd1b816e9e0f302e4472ba68f084ed365
-  data.tar.gz: 76625bdefe2dde62258b0ec3da4ca257679fa16a9b669ca0a4453108097e9d670109e9b4f77f5b67c0cf76f95e18164edd2b477a885bb3ed5cc73c928174d6a8
+  metadata.gz: db7ee4ad6d440102cbf7c2c8452b20844c1ddb251a44f86d44f0655e14f359eb1e1fa17debc2f0857485c34b09c9199c6921c31a55b1910aa103ac0fd5e11ff8
+  data.tar.gz: c8a43921457c96865466b5cb0111ccd4e6aba04585bb6e398bc7ad6f808a2009f2bbffa48e8dc1348ba10937776c96c0707249ab54d0bc018d900c4799eb98e3

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.62"
   end
 end

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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.61
+  version: 0.8.62
 platform: ruby
 authors:
 - Ribose Inc.