lutaml-model 0.8.19 → 0.8.22

data/spec/lutaml/model/custom_from_empty_values_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model#746: an empty value ("", [], {}) is a PRESENT value per
+# docs/_guides/missing-values-handling.adoc and must reach custom `from`
+# methods. Only nil (non-existent) and an omitted key (undefined) skip them.
+module CustomFromEmptyValuesSpec
+  class Tagged < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "tags", to: :received, with: { to: :tags_to, from: :tags_from }
+    end
+
+    def tags_to(model, doc)
+      doc["tags"] = model.received
+    end
+
+    def tags_from(model, value)
+      model.received = value.inspect
+    end
+  end
+
+  class Mapped < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "fields", to: :received, with: { to: :fields_to, from: :fields_from }
+    end
+
+    def fields_to(model, doc)
+      doc["fields"] = model.received
+    end
+
+    def fields_from(model, value)
+      model.received = value.inspect
+    end
+  end
+end
+
+RSpec.describe "custom from methods and empty values" do
+  it "receives an empty collection" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags: []").received)
+      .to eq("[]")
+  end
+
+  it "receives an empty string" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml('tags: ""').received)
+      .to eq("\"\"")
+  end
+
+  it "receives an empty mapping" do
+    expect(CustomFromEmptyValuesSpec::Mapped.from_yaml("fields: {}").received)
+      .to eq("{}")
+  end
+
+  it "receives empty values from JSON too" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": []})).received)
+      .to eq("[]")
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": ""})).received)
+      .to eq("\"\"")
+  end
+
+  it "still skips the method for a nil value" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags:").received)
+      .to be_nil
+  end
+
+  it "still skips the method for an omitted key" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("{}").received)
+      .to be_nil
+  end
+end

data/spec/lutaml/model/custom_vobject_adapter_spec.rb

@@ -201,8 +201,8 @@ module CustomVobjectAdapterSpec
       @objects
     end
 
-    def map(&)
-      @objects.map(&)
+    def map(&block)
+      @objects.map(&block)
     end
 
     private
@@ -260,16 +260,16 @@ module CustomVobjectAdapterSpec
       @element_type = element_type
     end
 
-    def map_value(to:, **)
-      add_mapping(:value, to, type: :simple, **)
+    def map_value(to:, **options)
+      add_mapping(:value, to, type: :simple, **options)
     end
 
-    def map_property(name, to:, type: :simple, **)
-      add_mapping(name.downcase, to, type: type, **)
+    def map_property(name, to:, type: :simple, **options)
+      add_mapping(name.downcase, to, type: type, **options)
     end
 
-    def map_component(name, to:, **)
-      add_mapping(name.downcase, to, type: :component, **)
+    def map_component(name, to:, **options)
+      add_mapping(name.downcase, to, type: :component, **options)
     end
 
     def map_field_set(count:, item_type:, item_options: {})

data/spec/lutaml/model/defaults_spec.rb

@@ -146,6 +146,33 @@ module DefaultsSpec
 
   class InstanceAwareGrandChild < InstanceAwareChild
   end
+
+  # Class-method defaults must keep resolving as they did before 0.8.0
+  # (lutaml-model#745): default lambdas are evaluated against the instance,
+  # with the model class as fallback for methods the instance does not have.
+  class ClassMethodDefault < Lutaml::Model::Serializable
+    attribute :os, :string, default: -> { detect_os }
+
+    def self.detect_os
+      "from-class-method"
+    end
+  end
+
+  class ClassMethodDefaultWithArgs < Lutaml::Model::Serializable
+    attribute :label, :string, default: -> { build_label("x") }
+
+    def self.build_label(prefix)
+      "#{prefix}-label"
+    end
+  end
+
+  class InstanceMethodDefault < Lutaml::Model::Serializable
+    attribute :value, :string, default: -> { instance_helper }
+
+    def instance_helper
+      "from-instance-method"
+    end
+  end
 end
 
 RSpec.describe DefaultsSpec::Glaze do
@@ -346,3 +373,21 @@ RSpec.describe DefaultsSpec::Glaze do
     end
   end
 end
+
+RSpec.describe DefaultsSpec::ClassMethodDefault do
+  it "resolves class methods from default lambdas" do
+    expect(described_class.new.os).to eq("from-class-method")
+  end
+end
+
+RSpec.describe DefaultsSpec::ClassMethodDefaultWithArgs do
+  it "passes arguments through to class methods" do
+    expect(described_class.new.label).to eq("x-label")
+  end
+end
+
+RSpec.describe DefaultsSpec::InstanceMethodDefault do
+  it "still resolves instance methods in default lambdas" do
+    expect(described_class.new.value).to eq("from-instance-method")
+  end
+end

data/spec/lutaml/model/json_spec.rb

@@ -8,9 +8,8 @@ RSpec.describe Lutaml::Model::Json do
     let(:lib_path) { File.expand_path("../../../lib", __dir__) }
 
     it "loads require 'lutaml/json' without preloading lutaml/model" do
-      # rubocop:disable Style/CommandLiteral
+      # rubocop:disable-next Style/CommandLiteral
       result = `#{RbConfig.ruby} -I#{lib_path} -e 'require "lutaml/json"; puts :ok' 2>&1`
-      # rubocop:enable Style/CommandLiteral
 
       expect($?.success?).to be(true), result
       expect(result).to include("ok")

data/spec/lutaml/model/serialize/builder_spec.rb

@@ -112,7 +112,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
           <items>c</items>
         </container>
       XML
-      expect(obj.element_order.map(&:name)).to eq(%w[singular items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items
+                                                     items])
     end
 
     it "all direct setters: emits in call order" do
@@ -298,7 +299,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
       # so both assignments are recorded. The serializer emits the current
       # value of the attribute via element_order in recorded order; the
       # safety net guarantees no data loss.
-      expect(obj.element_order.map(&:name)).to eq(%w[items items items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[items items items items
+                                                     items])
       xml = obj.to_xml
       # The serialized output must contain all current items
       expect(xml).to include("<items>c</items>")
@@ -317,7 +319,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
         xml = obj.to_xml
 
         if !obj.singular.nil? && !obj.singular.to_s.empty?
-          expect(xml).to include("<singular>"), "singular was dropped from output"
+          expect(xml).to include("<singular>"),
+                         "singular was dropped from output"
         end
         return if obj.items.nil? || obj.items.empty?
 

data/spec/lutaml/model/store_spec.rb

@@ -43,7 +43,9 @@ RSpec.describe Lutaml::Model::Store do
 
   describe "indexed lookup" do
     it "builds index lazily on first resolve" do
-      5.times { |i| model_class.new(id: "obj-#{i}") }
+      # Hold strong references: Store keeps WeakRefs, so unreferenced
+      # objects can be collected before resolve runs.
+      _objects = Array.new(5) { |i| model_class.new(id: "obj-#{i}") }
 
       result = described_class.resolve(model_class, :id, "obj-3")
       expect(result.id).to eq("obj-3")

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
     end
 
     it "passes initialized values through unchanged" do
-      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+      expect(transform.apply_value_map("hello", default_vmap,
+                                       nil)).to eq("hello")
     end
   end
 
@@ -50,11 +51,13 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
   # custom method runs), and resolved :nil/:empty consistently for empty inputs.
   describe "non-:nil options with nil attr" do
     it "maps a nil value to uninitialized via nil: :omitted" do
-      expect(transform.apply_value_map(nil, { nil: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map(nil, { nil: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to uninitialized via empty: :omitted" do
-      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map("", { empty: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to nil via empty: :nil" do

data/spec/lutaml/model/union_attribute_spec.rb

@@ -311,7 +311,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     it "serializes a model member built in plain Ruby identically to a deserialized one" do
       built = UnionAttributeSpec::Ceramic.new(
         firing_temperature:
-          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0, unit: "C"),
+          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0,
+                                                      unit: "C"),
       )
       round = UnionAttributeSpec::Ceramic.from_yaml(built.to_yaml)
       expect(round.firing_temperature)
@@ -424,7 +425,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     end
 
     it "rejects unsupported scalar member types at definition time" do
-      %i[hash symbol time time_without_date date date_time].each do |unsupported|
+      %i[hash symbol time time_without_date date
+         date_time].each do |unsupported|
         expect do
           Class.new(Lutaml::Model::Serializable) do
             attribute :bad, [unsupported, :string]

data/spec/lutaml/model/value_policy_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module ValuePolicySpec
+  # A value type whose whole purpose is to wrap any literal:
+  # scalar, list, or map (issue #752).
+  class LiteralValue < Lutaml::Model::Type::Value
+  end
+
+  class LiteralDoc < Lutaml::Model::Serializable
+    attribute :v, LiteralValue
+    key_value do
+      map "v", to: :v
+    end
+  end
+
+  class StringsDoc < Lutaml::Model::Serializable
+    attribute :v, :string
+    key_value do
+      map "v", to: :v
+    end
+  end
+
+  class CollectionDoc < Lutaml::Model::Serializable
+    attribute :v, :string, collection: true
+    key_value do
+      map "v", to: :v
+    end
+  end
+end
+
+RSpec.describe "ValuePolicy shaping of non-collection attributes" do
+  describe "user-defined Type::Value subclass" do
+    it "receives the whole array from key-value data" do
+      expect(ValuePolicySpec::LiteralDoc.from_yaml("v: [a, b]").v)
+        .to eq(["a", "b"])
+    end
+
+    it "receives an empty array from key-value data" do
+      expect(ValuePolicySpec::LiteralDoc.from_yaml("v: []").v).to eq([])
+    end
+
+    it "receives the whole hash from key-value data" do
+      v = ValuePolicySpec::LiteralDoc.from_yaml("v: {a: 1}").v
+      expect(v.value).to eq("a" => 1)
+    end
+
+    it "keeps scalar behavior" do
+      doc = ValuePolicySpec::LiteralDoc.from_yaml(<<~YAML)
+        v: hello
+      YAML
+      expect(doc.v).to eq("hello")
+    end
+
+    it "round-trips an array value through YAML" do
+      doc = ValuePolicySpec::LiteralDoc.from_yaml("v: [a, b]")
+      expect(ValuePolicySpec::LiteralDoc.from_yaml(doc.to_yaml).v)
+        .to eq(["a", "b"])
+    end
+
+    it "accepts an array assigned after construction" do
+      doc = ValuePolicySpec::LiteralDoc.new(v: "seed")
+      doc.v = ["a", "b"]
+      expect(doc.v).to eq(["a", "b"])
+    end
+  end
+
+  describe "built-in scalar types" do
+    it "keep the collection: true guidance error" do
+      expect { ValuePolicySpec::StringsDoc.from_yaml("v: [a]") }
+        .to raise_error(Lutaml::Model::CollectionTrueMissingError)
+    end
+  end
+
+  describe "collection attributes" do
+    it "keep element-wise casting" do
+      expect(ValuePolicySpec::CollectionDoc.from_yaml("v: [a, b]").v)
+        .to eq(["a", "b"])
+    end
+  end
+end

data/spec/lutaml/require_load_order_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model: every public format entrypoint and `require "lutaml/model"`
+# itself must not produce "circular require considered harmful" warnings
+# under ruby -w (regression guard after the public-wrapper/internal-format
+# restructuring).
+RSpec.describe "require load order" do
+  it "loads lutaml/model with no circular-require warnings under -w" do
+    output = `bundle exec ruby -w -e 'require "lutaml/model"' 2>&1`
+    circular = output.lines.count { |l| l.include?("circular require considered harmful") }
+    expect(circular).to eq(0),
+      "Expected no circular-require warnings, got #{circular}:\n#{output}"
+  end
+
+  %w[json key_value yaml toml hash_format jsonl yamls xml].each do |format|
+    it "loads lutaml/#{format} standalone without circular-require warnings" do
+      output = `bundle exec ruby -w -e 'require "lutaml/#{format}"' 2>&1`
+      circular = output.lines.count { |l| l.include?("circular require considered harmful") }
+      expect(circular).to eq(0),
+        "Expected no circular-require warnings loading lutaml/#{format}, got #{circular}:\n#{output}"
+    end
+  end
+end

data/spec/lutaml/xml/attribute_element_namespace_disjoint_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string: true
+
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+# lutaml-model#758: a plain (unnamespaced) map_attribute rule on an
+# element-namespaced class must not absorb a namespaced sibling attribute
+# (and vice versa), and a type-level `namespace :blank` must not crash.
+module ElementNsDisjointSpec
+  class XmiNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/xmi"
+    prefix_default "xmi"
+  end
+
+  class ElemNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/elem"
+    prefix_default "e"
+  end
+
+  class XmiTypeAttr < Lutaml::Model::Type::String
+    xml do
+      namespace XmiNs
+    end
+  end
+
+  class DocBase < Lutaml::Model::Serializable
+    attribute :xmi_type, XmiTypeAttr
+
+    xml do
+      namespace ElemNs
+      map_attribute "type", to: :xmi_type
+    end
+  end
+
+  class Doc < DocBase
+    attribute :plain_type, Lutaml::Model::Type::String
+
+    xml do
+      root "doc"
+      map_attribute "type", to: :plain_type
+    end
+  end
+
+  class BlankType < Lutaml::Model::Type::String
+    xml do
+      namespace :blank
+    end
+  end
+
+  class BlankDoc < Lutaml::Model::Serializable
+    attribute :v, BlankType
+    xml do
+      root "bd"
+      map_attribute "v", to: :v
+    end
+  end
+end
+
+RSpec.describe "attribute namespace-disjointness on element-namespaced classes (#758)" do
+  it "routes xmi:type to the namespaced slot and leaves plain_type nil" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(
+      %(<doc xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>),
+    )
+    expect(doc.xmi_type).to eq("uml:Parameter")
+    expect(doc.plain_type).to be_nil
+  end
+
+  it "routes an unprefixed type to plain_type, leaves xmi_type nil" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(%(<doc type="EAnone_void"/>))
+    expect(doc.plain_type).to eq("EAnone_void")
+    expect(doc.xmi_type).to be_nil
+  end
+
+  it "round-trips both spellings without emitting a spurious duplicate" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(
+      %(<doc xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>),
+    )
+    out = doc.to_xml.strip
+    expect(out).to include('xmi:type="uml:Parameter"')
+    expect(out).not_to match(/\stype="uml:Parameter"/)
+  end
+
+  it "survives type-level namespace :blank without crashing" do
+    expect do
+      ElementNsDisjointSpec::BlankDoc.from_xml(%(<bd v="x"/>))
+    end.not_to raise_error
+  end
+end

data/spec/lutaml/xml/attribute_namespace_disjointness_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Two map_attribute rules that share a local name but are distinguished by
+# their type classes' bound namespaces must parse disjointly, mirroring
+# serialization (lutaml-model#744).
+#
+# The coexisting-spelling cases under nokogiri/rexml additionally require the
+# moxml adapter fixes (lutaml/moxml#94, lutaml/moxml#95); oga and ox already
+# preserve same-local-name attributes across namespaces.
+module AttributeNamespaceDisjointnessSpec
+  class XmiNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/xmi"
+    prefix_default "xmi"
+  end
+
+  class XmiNsType < Lutaml::Model::Type::String
+    xml do
+      namespace XmiNs
+    end
+  end
+
+  class Probe < Lutaml::Model::Serializable
+    attribute :xmi_type, XmiNsType
+    attribute :plain_type, Lutaml::Model::Type::String
+
+    xml do
+      element "probe"
+      map_attribute "type", to: :xmi_type
+      map_attribute "type", to: :plain_type
+    end
+  end
+
+  def self.parse(xml, adapter)
+    Lutaml::Model::Config.with_adapter(xml: adapter) { Probe.from_xml(xml) }
+  end
+end
+
+RSpec.describe "Attribute namespace-disjoint parsing" do
+  let(:namespaced_xmi) do
+    %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>)
+  end
+
+  let(:namespaced_foo) do
+    %(<probe xmlns:foo="http://www.example.com/xmi" foo:type="uml:Parameter"/>)
+  end
+
+  let(:plain) { %(<probe type="EAnone_void"/>) }
+
+  let(:both_spellings) do
+    %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter" type="EAnone_void"/>)
+  end
+
+  let(:both_spellings_plain_first) do
+    %(<probe type="EAnone_void" xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>)
+  end
+
+  %i[oga ox nokogiri].each do |adapter|
+    context "with the #{adapter} adapter" do
+      it "routes a namespaced rule to the attribute bound to its URI" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(namespaced_xmi,
+                                                         adapter)
+
+        expect(probe.xmi_type).to eq("uml:Parameter")
+        expect(probe.plain_type).to be_nil
+      end
+
+      it "accepts any prefix bound to the namespace URI" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(namespaced_foo,
+                                                         adapter)
+
+        expect(probe.xmi_type).to eq("uml:Parameter")
+        expect(probe.plain_type).to be_nil
+      end
+
+      it "does not let a namespace-less attribute satisfy the namespaced rule" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(plain, adapter)
+
+        expect(probe.xmi_type).to be_nil
+        expect(probe.plain_type).to eq("EAnone_void")
+      end
+    end
+  end
+
+  # Same-local-name attributes coexisting on one element require the moxml
+  # fixes (lutaml/moxml#94 drops one under nokogiri; lutaml/moxml#95 crashes
+  # under rexml), so these cases run on the adapters that preserve both.
+  %i[oga ox].each do |adapter|
+    context "with the #{adapter} adapter" do
+      it "keeps both spellings disjoint regardless of document order" do
+        [both_spellings, both_spellings_plain_first].each do |xml|
+          probe = AttributeNamespaceDisjointnessSpec.parse(xml, adapter)
+
+          expect(probe.xmi_type).to eq("uml:Parameter")
+          expect(probe.plain_type).to eq("EAnone_void")
+        end
+      end
+    end
+  end
+
+  describe "serialization" do
+    it "writes each rule in its own namespace" do
+      probe = AttributeNamespaceDisjointnessSpec::Probe.new(
+        xmi_type: "uml:Parameter",
+        plain_type: "EAnone_void",
+      )
+
+      expect(probe.to_xml.strip).to be_xml_equivalent_to(
+        %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter" type="EAnone_void"/>),
+      )
+    end
+
+    it "round-trips both spellings through parsing" do
+      probe = AttributeNamespaceDisjointnessSpec::Probe.new(
+        xmi_type: "uml:Parameter",
+        plain_type: "EAnone_void",
+      )
+      reparsed = AttributeNamespaceDisjointnessSpec.parse(probe.to_xml, :oga)
+
+      expect(reparsed.xmi_type).to eq("uml:Parameter")
+      expect(reparsed.plain_type).to eq("EAnone_void")
+    end
+  end
+end