lutaml-model 0.8.18 → 0.8.22

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

data/spec/lutaml/xml/out_of_namespace_parsing_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#754: parsing a document whose elements live in a namespace
+# different from the model's bound namespace must not silently drop
+# element content. The document's own namespace is adopted as an implicit
+# alias of the model's namespace for the duration of the parse, so
+# lenient (out-of-namespace) parsing is lossless for element content the
+# way in-namespace parsing is.
+module OutOfNamespaceParsingSpec
+  class Gml32 < Lutaml::Xml::Namespace
+    uri "http://www.opengis.net/gml/3.2"
+    prefix_default "gml"
+  end
+
+  class Code < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      root "name"
+      namespace Gml32
+      map_content to: :value
+    end
+  end
+
+  class EntryDefinition < Lutaml::Model::Serializable
+    attribute :description, :string
+    attribute :name, Code, collection: true
+
+    xml do
+      element "Definition"
+      namespace Gml32
+      map_element "description", to: :description
+      map_element "name", to: :name
+    end
+  end
+
+  class DictionaryEntry < Lutaml::Model::Serializable
+    attribute :definition, EntryDefinition
+
+    xml do
+      element "dictionaryEntry"
+      namespace Gml32
+      map_element "Definition", to: :definition
+    end
+  end
+
+  class Dictionary < Lutaml::Model::Serializable
+    attribute :name, Code, collection: true
+    attribute :dictionary_entry, DictionaryEntry, collection: true
+
+    xml do
+      element "Dictionary"
+      namespace Gml32
+      map_element "name", to: :name
+      map_element "dictionaryEntry", to: :dictionary_entry
+    end
+  end
+
+  def self.gml_doc(uri)
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <gml:Dictionary xmlns:gml="#{uri}">
+        <gml:name>codes</gml:name>
+        <gml:dictionaryEntry>
+          <gml:Definition>
+            <gml:description>first</gml:description>
+            <gml:name>ONE</gml:name>
+          </gml:Definition>
+        </gml:dictionaryEntry>
+      </gml:Dictionary>
+    XML
+  end
+end
+
+RSpec.describe "out-of-namespace document parsing" do
+  let(:in_namespace_xml) { OutOfNamespaceParsingSpec.gml_doc("http://www.opengis.net/gml/3.2") }
+  let(:out_of_namespace_xml) { OutOfNamespaceParsingSpec.gml_doc("http://www.opengis.net/gml") }
+
+  it "parses simple-type element content from a document in the bound namespace" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(in_namespace_xml).dictionary_entry.first.definition
+    expect(definition.description).to eq("first")
+  end
+
+  it "keeps simple-type element content when the document namespace differs (#754)" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(out_of_namespace_xml).dictionary_entry.first.definition
+    expect(definition.description).to eq("first")
+  end
+
+  it "keeps serializable-typed element content when the document namespace differs" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(out_of_namespace_xml).dictionary_entry.first.definition
+    expect(definition.name.map(&:value)).to eq(["ONE"])
+  end
+
+  it "keeps simple-type content at the document root level" do
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(out_of_namespace_xml)
+    expect(dictionary.name.map(&:value)).to eq(["codes"])
+  end
+
+  it "does not adopt an unrelated child namespace" do
+    xml = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <gml:Dictionary xmlns:gml="http://www.opengis.net/gml"
+                      xmlns:city="http://www.opengis.net/citygml/2.0">
+        <city:name>not mine</city:name>
+      </gml:Dictionary>
+    XML
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(xml)
+    expect(dictionary.name).to be_empty
+  end
+
+  it "round-trips out-of-namespace content without losing the description" do
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(out_of_namespace_xml)
+    output = dictionary.to_xml(prefix: true)
+    expect(output).to include("first")
+    reparsed = OutOfNamespaceParsingSpec::Dictionary.from_xml(output)
+    expect(reparsed.dictionary_entry.first.definition.description).to eq("first")
+  end
+end

data/spec/lutaml/xml/schema/rnc_compiler_spec.rb

@@ -14,7 +14,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
 
   describe ".to_models" do
     context "with an RNC schema using named patterns and start |=" do
-      let(:schema) { File.read("spec/fixtures/xml/schema/rnc/address_book.rnc") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rnc/address_book.rnc")
+      end
       let(:sources) { described_class.to_models(schema) }
 
       it "compiles RNC through the RNG compiler" do
@@ -65,7 +67,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
 
     context "with create_files output" do
       let(:dir) { Dir.mktmpdir }
-      let(:schema) { File.read("spec/fixtures/xml/schema/rnc/address_book.rnc") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rnc/address_book.rnc")
+      end
 
       before do
         stub_const("RncAddressBookSpec", Module.new)
@@ -206,7 +210,8 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
           "spec/fixtures/xml/schema/rnc/includes/circular_a.rnc"
 
         expect do
-          described_class.to_models(File.read(circular_path), location: circular_path)
+          described_class.to_models(File.read(circular_path),
+                                    location: circular_path)
         end.to raise_error(/circular_a\.rnc/)
       end
     end
@@ -308,7 +313,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
         # The inline restricted type is subclassed (not mutated) so a fresh
         # namespaced type inherits its constraints and carries the namespace.
         expect(sources["CodeType"]).not_to match(/namespace \w+Namespace/)
-        subclass = sources.keys.find { |k| sources[k].match?(/class \w+ < CodeType/) }
+        subclass = sources.keys.find do |k|
+          sources[k].match?(/class \w+ < CodeType/)
+        end
         expect(subclass).not_to be_nil
         expect(sources[subclass]).to match(/namespace \w+Namespace/)
       end
@@ -323,7 +330,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
         namespaces = sources.select { |_, v| v.include?("Lutaml::Xml::W3c::XmlNamespace") }
         expect(namespaces.size).to eq(2)
         uris = namespaces.values.map { |v| v[/uri "([^"]+)"/, 1] }
-        prefixes = namespaces.values.map { |v| v[/prefix_default "([^"]+)"/, 1] }
+        prefixes = namespaces.values.map do |v|
+          v[/prefix_default "([^"]+)"/, 1]
+        end
         expect(uris).to contain_exactly("urn:a", "urn:b")
         expect(prefixes.uniq.size).to eq(2)
       end
@@ -341,7 +350,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
           }
         RNC
 
-        wrapper = sources.keys.find { |k| sources[k].match?(/namespace \w+Namespace/) && !k.include?("Namespace") }
+        wrapper = sources.keys.find do |k|
+          sources[k].match?(/namespace \w+Namespace/) && !k.include?("Namespace")
+        end
         expect(sources[wrapper]).to include("< Lutaml::Model::Type::DateTime")
       end
     end

data/spec/lutaml/xml/schema/rng_compiler_spec.rb

@@ -33,7 +33,9 @@ RSpec.describe Lutaml::Model::Schema::RngCompiler do
       end
 
       let(:dir) { Dir.mktmpdir }
-      let(:schema) { File.read("spec/fixtures/xml/schema/rng/address_book.rng") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rng/address_book.rng")
+      end
 
       let(:valid_xml) do
         <<~XML
@@ -220,10 +222,13 @@ RSpec.describe Lutaml::Model::Schema::RngCompiler do
       end
 
       let(:dir) { Dir.mktmpdir }
-      let(:schema) { File.read("spec/fixtures/xml/schema/rng/integer_range.rng") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rng/integer_range.rng")
+      end
 
       it "generates a SimpleType subclass for <data> with restrictions" do
-        src = File.read(File.join(dir, "rngrestrictionspec", "st_integer_range.rb"))
+        src = File.read(File.join(dir, "rngrestrictionspec",
+                                  "st_integer_range.rb"))
         expect(src).to include("class StIntegerRange < Lutaml::Model::Type::Integer")
         expect(src).to include("options[:min] = 1")
         expect(src).to include("options[:max] = 255")
@@ -507,7 +512,9 @@ RSpec.describe Lutaml::Model::Schema::RngCompiler do
         expect(classes_hash.keys).to contain_exactly(
           "AddressBook", "Card", "CardContent"
         )
-        classes_hash.each_value { |src| expect(src).to start_with("# frozen_string_literal: true") }
+        classes_hash.each_value do |src|
+          expect(src).to start_with("# frozen_string_literal: true")
+        end
       end
     end
 
@@ -821,7 +828,8 @@ RSpec.describe Lutaml::Model::Schema::RngCompiler do
 
       it "returns generated source per class" do
         expect(result).to be_a(Hash)
-        expect(result.keys).to contain_exactly("AddressBook", "Card", "CardContent")
+        expect(result.keys).to contain_exactly("AddressBook", "Card",
+                                               "CardContent")
       end
 
       it "loads the namespaced module and registers classes" do
@@ -886,7 +894,8 @@ RSpec.describe Lutaml::Model::Schema::RngCompiler do
           File.read("spec/fixtures/xml/schema/rng/address_book.rng"),
         )
         expect(result).to be_a(Hash)
-        expect(result.keys).to contain_exactly("AddressBook", "Card", "CardContent")
+        expect(result.keys).to contain_exactly("AddressBook", "Card",
+                                               "CardContent")
       end
     end
   end

data/spec/lutaml/xml/w3c_types_spec.rb

@@ -307,9 +307,8 @@ RSpec.describe Lutaml::Xml::W3c do
         RUBY
         temp_script.close
 
-        # rubocop:disable Style/CommandLiteral
+        # rubocop:disable-next Style/CommandLiteral
         result = `#{RbConfig.ruby} -I#{lib_path} #{temp_script.path} 2>&1`
-        # rubocop:enable Style/CommandLiteral
 
         expect($?.success?).to be(true),
                                "W3C types not registered after require 'lutaml/xml'. " \
@@ -335,9 +334,8 @@ RSpec.describe Lutaml::Xml::W3c do
         RUBY
         temp_script.close
 
-        # rubocop:disable Style/CommandLiteral
+        # rubocop:disable-next Style/CommandLiteral
         result = `#{RbConfig.ruby} -I#{lib_path} #{temp_script.path} 2>&1`
-        # rubocop:enable Style/CommandLiteral
 
         expect($?.success?).to be(true),
                                "Type.lookup failed for W3C symbols after require 'lutaml/xml'. " \
@@ -361,9 +359,8 @@ RSpec.describe Lutaml::Xml::W3c do
         RUBY
         temp_script.close
 
-        # rubocop:disable Style/CommandLiteral
+        # rubocop:disable-next Style/CommandLiteral
         result = `#{RbConfig.ruby} -I#{lib_path} #{temp_script.path} 2>&1`
-        # rubocop:enable Style/CommandLiteral
 
         expect($?.success?).to be(true),
                                "Symbol-based attribute definition failed after require 'lutaml/xml'. " \