lutaml-model 0.8.56 → 0.8.106

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module GenerateManySpec
+  class Source < Lutaml::Model::Serializable
+    attribute :name, :string
+  end
+
+  class Other < Lutaml::Model::Serializable
+    attribute :label, :string
+  end
+
+  class Consumer < Lutaml::Model::Serializable
+    attribute :inner, Source
+  end
+end
+
+RSpec.describe Lutaml::Model::Schema::BaseSchema do
+  describe ".generate_many" do
+    it "covers every root in one document without a top-level $ref" do
+      parsed = JSON.parse(
+        Lutaml::Model::Schema::JsonSchema.generate_many(
+          [GenerateManySpec::Source, GenerateManySpec::Other],
+        ),
+      )
+
+      expect(parsed).not_to have_key("$ref")
+      expect(parsed["$defs"]).to have_key("GenerateManySpec_Source")
+      expect(parsed["$defs"]).to have_key("GenerateManySpec_Other")
+    end
+
+    it "registers a class shared by several roots once" do
+      parsed = JSON.parse(
+        Lutaml::Model::Schema::JsonSchema.generate_many(
+          [GenerateManySpec::Source, GenerateManySpec::Consumer],
+        ),
+      )
+
+      expect(parsed["$defs"].keys.size).to eq(2)
+      expect(parsed["$defs"]).to have_key("GenerateManySpec_Consumer")
+    end
+
+    it "formats YAML output" do
+      yaml = Lutaml::Model::Schema::YamlSchema.generate_many(
+        [GenerateManySpec::Source, GenerateManySpec::Other],
+      )
+
+      expect(yaml).to start_with("%YAML")
+    end
+  end
+
+  describe "Generator::DefinitionsCollection.from_classes" do
+    it "builds one collection covering all roots" do
+      collection = Lutaml::Model::Schema::Generator::DefinitionsCollection
+        .from_classes([GenerateManySpec::Source, GenerateManySpec::Consumer])
+
+      expect(collection.to_schema.keys.size).to eq(2)
+    end
+  end
+end

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/model/serialize/attribute_definition_block_form_spec.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../../../lib/lutaml/model"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# Runtimes without a source compiler (Opal) define the attribute
+# accessors and the state-defaults seed from blocks instead of a String
+# class_eval. These specs force that block form on MRI and check it
+# behaves exactly like the compiled form.
+module AttributeDefinitionBlockFormSpec
+  module_function
+
+  def define_model(klass)
+    klass.class_eval do
+      attribute :name, :string
+      attribute :count, :integer
+      attribute :tags, :string, collection: true
+      # "char" is an enum shorthand, so the second :char definition
+      # redefines the setter but keeps the first Attribute's accessor.
+      attribute :align, :string, values: %w[char left]
+      attribute :char, :integer
+      attribute :char, :string
+      # String names, mutated once defined: the accessors must keep
+      # reading the ivar named at definition time.
+      label = +"label"
+      notes = +"notes"
+      attribute label, :integer
+      attribute notes, :string, collection: true
+      label << "x"
+      notes << "x"
+
+      # A model may define its own #send; the setters must not dispatch
+      # through it.
+      define_method(:send) { |*| "domain-method" }
+
+      xml do
+        element "item"
+        ordered
+        map_attribute "name", to: :name
+        map_element "count", to: :count
+        map_element "tag", to: :tags
+        map_element "char", to: :char
+      end
+
+      key_value do
+        map "name", to: :name
+        map "count", to: :count
+        map "tags", to: :tags
+        map "char", to: :char
+      end
+    end
+    klass
+  end
+
+  # A model overriding the core methods the block form might dispatch
+  # through: the accessors must behave as the compiled ones do.
+  def override_model(klass)
+    klass.class_eval do
+      attribute :count, :integer
+      attribute :tags, :string, collection: true
+      %i[__send__ instance_variable_get instance_variable_set].each do |m|
+        define_method(m) { |*| :overridden }
+      end
+    end
+    m = klass.new
+    m.count = "5"
+    m.tags = %w[a]
+    m.tags("b")
+    # The collection getter itself reads through the overridden method,
+    # so check what was stored.
+    stored = ::Kernel.instance_method(:instance_variable_get)
+    [stored.bind_call(m, :@count), stored.bind_call(m, :@tags)]
+  end
+
+  # A model whose scope defines its own Array: appends must resolve the
+  # constant where the compiled getter does.
+  # Checked on the defining class and on a subclass that shadows Array,
+  # with the defining class overriding const_get.
+  def array_scope_model(klass)
+    klass.const_set(:Array, Class.new(::Array))
+    klass.class_eval { attribute :tags, :string, collection: true }
+    klass.define_singleton_method(:const_get) { |*| raise "const_get called" }
+    sub = Class.new(klass)
+    sub.const_set(:Array, ::Array)
+    [klass, sub].map do |k|
+      m = k.new
+      m.tags = %w[a]
+      m.tags("b")
+      ::Kernel.instance_method(:instance_variable_get).bind_call(m, :@tags)
+    end
+  end
+
+  # Raw-state readers after the state defaults compiled for a smaller
+  # attribute set: an attribute imported later, and one declared later,
+  # must both get a reader (#933).
+  def late_raw_readers(klass)
+    klass.class_eval { attribute :name, :string }
+    klass.new
+    imported = Class.new(Lutaml::Model::Serializable) do
+      attribute :br, :string
+    end
+    klass.import_model_attributes(imported)
+    klass.class_eval { attribute :late, :string, collection: true }
+    m = klass.new
+    m.br = "b"
+    readers = %i[name br late].map do |a|
+      raw = m.public_send(:"__lutaml_raw_#{a}")
+      [a, Lutaml::Model::Utils.uninitialized?(raw), raw.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION) || raw]
+    end
+    readers << register_choice_raw_reader
+  end
+
+  # A choice import into a non-default register merges attribute records
+  # without define_attribute_methods: only the state-defaults
+  # compilation gives the imported name its raw reader.
+  def register_choice_raw_reader
+    register = Lutaml::Model::Register.new(:raw_reader_block_form_spec)
+    Lutaml::Model::GlobalRegister.register(register)
+    imported = Class.new(Lutaml::Model::Serializable) do
+      attribute :br, :string, collection: true
+    end
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      choice { import_model_attributes(imported, :raw_reader_block_form_spec) }
+    end
+    klass.allocate_for_deserialization(:raw_reader_block_form_spec).__lutaml_raw_br
+      .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+  ensure
+    Lutaml::Model::GlobalRegister.unregister(:raw_reader_block_form_spec)
+  end
+
+  def build_model
+    define_model(Class.new(Lutaml::Model::Serializable))
+  end
+
+  def element_order(model)
+    model.element_order.map { |e| [e.type, e.name, e.text_content] }
+  end
+
+  def arity_error(model, name)
+    model.public_send(name, "1", "2")
+    nil
+  rescue ArgumentError => e
+    e.message
+  end
+
+  def observe(klass)
+    fresh = klass.new
+    set = klass.new
+    set.name = "a"
+    set.count = "5"
+    set.tags("x")
+    set.tags("y")
+    set.char = "7"
+    # A parsed instance with no tags still holds the lazy sentinel.
+    emptied = klass.from_xml('<item name="z"/>')
+    sentinel_before_nil = emptied.instance_variable_get(:@tags)
+      .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+    emptied.tags = nil
+    xml = set.to_xml
+    parsed = klass.from_xml(xml)
+
+    seed = klass.__send__(:compiled_state_defaults_name!, :default)
+    seeded = klass.new.__send__(seed)
+
+    {
+      seed_return: [seeded.class, seeded.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)],
+      fresh_scalar_uninitialized: Lutaml::Model::Utils.uninitialized?(
+        fresh.instance_variable_get(:@name),
+      ),
+      fresh_collection_sentinel: fresh.instance_variable_get(:@tags)
+        .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION),
+      fresh_readers: [fresh.name, fresh.count, fresh.tags],
+      set_readers: [set.name, set.count, set.tags, set.char],
+      set_using_default: %i[name count tags].map { |a| set.using_default?(a) },
+      sentinel_before_nil: sentinel_before_nil,
+      nil_keeps_sentinel: emptied.instance_variable_get(:@tags)
+        .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION),
+      getter_with_arg: klass.new.tap { |m| m.count("3") }.count,
+      assign_parsed_skips_cast: klass.new.tap { |m| m.__assign_parsed_count = "3" }.count,
+      built_order: element_order(klass.new do |m|
+        m.count = "1"
+        m.tags = %w[p q]
+        m.tags("r")
+      end),
+      string_names: klass.new.tap do |m|
+        m.label = "4"
+        m.notes("n")
+      end.then { |m| [m.label, m.notes, m.instance_variables.grep(/label|notes/).sort] },
+      two_args: %i[count tags label notes].map { |a| arity_error(klass.new, a) },
+      xml: xml,
+      json: set.to_json,
+      parsed: [parsed.name, parsed.count, parsed.tags, parsed.char],
+      parsed_equal: parsed == set,
+    }
+  end
+end
+
+RSpec.describe Lutaml::Model::Serialize::AttributeDefinition do
+  let(:compiled) { AttributeDefinitionBlockFormSpec.observe(AttributeDefinitionBlockFormSpec.build_model) }
+
+  it "compiles accessors from source by default on MRI" do
+    expect(described_class.source_compilation?).to be(true)
+  end
+
+  it "defines the block form without String class_eval and matches the compiled form" do
+    expected = compiled
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    klass = Class.new(Lutaml::Model::Serializable)
+    allow(klass).to receive(:class_eval).and_wrap_original do |original, *args, &block|
+      raise "String class_eval used: #{args.first}" if args.first.is_a?(String)
+
+      original.call(*args, &block)
+    end
+    AttributeDefinitionBlockFormSpec.define_model(klass)
+
+    expect(AttributeDefinitionBlockFormSpec.observe(klass)).to eq(expected)
+  end
+
+  it "does not dispatch through a model's own core methods" do
+    expected = AttributeDefinitionBlockFormSpec.override_model(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.override_model(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+
+  it "resolves Array in the model's scope when appending" do
+    expected = AttributeDefinitionBlockFormSpec.array_scope_model(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.array_scope_model(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+
+  it "defines raw-state readers for imported and late attributes as the compiled form does" do
+    expected = AttributeDefinitionBlockFormSpec.late_raw_readers(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.late_raw_readers(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -86,14 +86,18 @@ RSpec.describe Lutaml::Model::Store do
     end
 
     it "does not mix indices across different classes" do
-      model_class.new(id: "a")
-      other_class.new(id: "a")
+      # Hold strong references: Store keeps WeakRefs, so unreferenced
+      # instances can be collected between registration and resolve,
+      # making this example fail only under in-suite GC pressure.
+      a = model_class.new(id: "a")
+      b = other_class.new(id: "a")
 
       result = described_class.resolve(model_class, :id, "a")
       expect(result).to be_a(model_class)
 
       result2 = described_class.resolve(other_class, :id, "a")
       expect(result2).to be_a(other_class)
+      expect([a, b]).to all(be_a(Lutaml::Model::Serializable))
     end
 
     it "registering class B does not iterate class A's indices" do

data/spec/lutaml/model/unregistered_context_resolution_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Register ids and type-context ids are two namespaces that
+# GlobalContext#resolve_type bridges implicitly: an id present only in the
+# Register namespace (a flavor's `lutaml_default_register`) resolves to a
+# nil type context, and every resolution shape must treat that as a
+# legitimate "no namespace" input instead of crashing (metanorma-jis#531).
+RSpec.describe "type resolution through a register id with no registered type context" do
+  let(:collection_class) do
+    Class.new(Lutaml::Model::Collection) do
+      instances :entries, :string
+    end
+  end
+
+  it "resolves collection instance types under a nil context" do
+    collection = collection_class.new(["a"], lutaml_register: :jis_document)
+
+    expect(collection.entries).to eq(["a"])
+  end
+
+  it "resolves built-in symbol names under a nil context" do
+    resolved = Lutaml::Model::GlobalContext.resolve_type(:string, :jis_document)
+
+    expect(resolved).to eq(Lutaml::Model::Type::String)
+  end
+
+  it "raises UnknownTypeError for unknown names under a nil context" do
+    expect do
+      Lutaml::Model::GlobalContext.resolve_type(:no_such_type, :jis_document)
+    end.to raise_error(Lutaml::Model::UnknownTypeError)
+  end
+end

data/spec/lutaml/model/writer_assigned_attribute_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module WriterAssigned
+  class Plain < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+
+  class Defaulted < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string, default: -> { "" }
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+end
+
+# lutaml-model#922: a custom writer that assigns a *different* attribute
+# mid-parse (relaton's Relaton::Bib::ICS populates <text> from the Isoics
+# dataset inside code=) must survive the deserializer's unmatched-rule
+# handling: the default seeding in Initialization#instantiate and the
+# unmatched-rule replay must never overwrite a value a writer assigned.
+RSpec.describe "attributes assigned inside another attribute's writer" do
+  %i[Plain Defaulted].each do |klass_name|
+    describe "with #{klass_name.to_s.downcase} text attribute" do
+      let(:klass) { WriterAssigned.const_get(klass_name) }
+
+      it "keeps the derived value through from_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.text).to eq("derived-67.060")
+      end
+
+      it "renders the derived value on to_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.to_xml).to include("<text>derived-67.060</text>")
+      end
+    end
+  end
+end