lutaml-model 0.8.142 → 0.8.144

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ddbdf9b831babcd7fd6bd41314ea8b4f2352503f0302b2420942d9d144dc0bb
-  data.tar.gz: 4704a4bac05aef07a9a0a0a939180cd10d15ad4a8ab086dc218b126c68f97d2f
+  metadata.gz: ff4c24c792fe315c6798bf64b67dbc4924fc919fc447e4a0264467d169a80315
+  data.tar.gz: 15621c39ad1d06dddbca3c9b0ef809b1a87d13222ef850c0cdb557da3317ca1d
 SHA512:
-  metadata.gz: 817089bc912e7a85d912ecdffc09e8d894cadb3ca416450f6b5cab6d3b2463e4d9210ccf8ca0af1710a4de088562ef5628ec5896ff9585dc0ad6798444897a77
-  data.tar.gz: b1196728958dfc2e8be4ed6da1a70c4b5e09079c7c1d3940398e4c1c97adbd5bfa34d74a829ae51c9ad8a85d09ddcad5028050eca1de432f897b98fbdce5ff60
+  metadata.gz: 21de2545ba67ce8357cd0216e70a085648ea24153cff022a805005b677d7d90ab51af50869cfc6335d6aad5404f4bb4fde30ed9f6389a31ff9b7ac51580646b4
+  data.tar.gz: d46faf8a708c88622abb2d560bf2f533da86815553c81049b8d432f71d60cfad67a65e567858454a7ecad721b2d2e02c2c3d6bd8bc173416903dc5d4faab7065

data/lib/lutaml/model/serialize/initialization.rb

@@ -184,12 +184,16 @@ module Lutaml
           end
         end
 
-        private
-
         # Replace a shared structure with a class-owned copy. The copy
         # becomes the snapshot for every existing subclass, which is what
         # keeps post-fork mutations invisible to them (the eager-copy
         # semantics).
+        #
+        # Public on purpose: code that mutates `mappings`, `attributes`,
+        # `choices` or `registers` outside the DSL — sibling classes pruning
+        # inherited elements (relaton's Item-header prunes) or importing
+        # models — must fork the structure first, or the mutation lands on
+        # the object shared with the superclass and every sibling class.
         def lutaml_cow_fork!(structure)
           return if lutaml_cow_status(structure) == 1
 
@@ -220,8 +224,6 @@ module Lutaml
           lutaml_cow_set_status!(structure, 1)
         end
 
-        public
-
         # Return the mapping object a format DSL may mutate. Forking
         # the mappings structure copies every entry, so the object
         # returned here is this class's own.

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.142"
+    VERSION = "0.8.144"
   end
 end

data/lib/lutaml/xml/schema/xsd/all.rb

@@ -17,8 +17,8 @@ module Lutaml
             namespace Lutaml::Xml::Schema::XsdNamespace
 
             map_attribute :id, to: :id
-            map_attribute :max_occurs, to: :max_occurs
-            map_attribute :min_occurs, to: :min_occurs
+            map_attribute :maxOccurs, to: :max_occurs
+            map_attribute :minOccurs, to: :min_occurs
             map_element :annotation, to: :annotation
             map_element :element, to: :element
           end

data/spec/lutaml/model/cow_fork_public_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Copy-on-write inheritance shares a subclass's structures with its
+# superclass until the class's own DSL forks them. External mutators — a
+# library pruning an inherited attribute on one subclass (relaton's
+# Item-header prunes) — need a supported way to claim ownership first, or
+# the mutation erases the attribute for every sibling class.
+RSpec.describe "Lutaml::Model::Serializable#lutaml_cow_fork!" do
+  let(:parent_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :shared, :string
+
+      xml do
+        root "parent"
+        map_attribute "id", to: :id
+        map_element "shared", to: :shared
+      end
+    end
+  end
+
+  let(:child_class) do
+    Class.new(parent_class)
+  end
+
+  it "is callable from outside the DSL" do
+    expect(child_class).to respond_to(:lutaml_cow_fork!)
+  end
+
+  it "gives the class a private copy without touching the superclass" do
+    parent_attributes = parent_class.class_attributes
+    child_class.lutaml_cow_fork!(:attributes)
+
+    expect(child_class.class_attributes).not_to equal(parent_attributes)
+    expect(parent_class.class_attributes).to equal(parent_attributes)
+  end
+
+  it "keeps post-fork mutations private to the forking class" do
+    child_class.lutaml_cow_fork!(:attributes)
+    child_class.lutaml_cow_fork!(:mappings)
+    child_class.class_attributes.delete(:id)
+    xml_attrs = child_class.mappings[:xml].instance_variable_get(:@attributes)
+    xml_attrs.delete("id")
+
+    expect(parent_class.class_attributes).to be_key(:id)
+    expect(parent_class.mappings[:xml]
+      .instance_variable_get(:@attributes)).to be_key("id")
+    expect(child_class.class_attributes).not_to be_key(:id)
+  end
+
+  it "does not fork an already-owned structure into a new object" do
+    child_class.lutaml_cow_fork!(:attributes)
+    owned = child_class.class_attributes
+    child_class.lutaml_cow_fork!(:attributes)
+
+    expect(child_class.class_attributes).to equal(owned)
+  end
+end

data/spec/lutaml/xml/schema/xsd/all_occurrence_attributes_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../../../../spec_helper"
+require "lutaml/xml/schema/xsd"
+
+# #1046: xs:all carried its occurrence bounds mapped by their Ruby names
+# (min_occurs/max_occurs), so minOccurs="0" was silently dropped at parse
+# and never re-emitted. Sequence, choice and group already map the XML
+# names; all now does too.
+RSpec.describe "Xsd::All occurrence attributes" do
+  let(:xsd) do
+    <<~XSD
+      <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+        <xsd:element name="elt1">
+          <xsd:complexType>
+            <xsd:all minOccurs="0" maxOccurs="1">
+              <xsd:element name="elt2"/>
+            </xsd:all>
+          </xsd:complexType>
+        </xsd:element>
+      </xsd:schema>
+    XSD
+  end
+
+  it "reads the occurrence bounds" do
+    doc = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    all = doc.element.first.complex_type.all
+
+    expect(all.min_occurs).to eq("0")
+    expect(all.max_occurs).to eq("1")
+  end
+
+  it "round-trips them as the XML attribute names" do
+    xml = Lutaml::Xml::Schema::Xsd.parse(xsd).to_xml
+
+    expect(xml).to include('minOccurs="0"')
+    expect(xml).to include('maxOccurs="1"')
+    expect(xml).not_to include("min_occurs")
+    expect(xml).not_to include("max_occurs")
+  end
+
+  it "keeps an xs:all without bounds boundless" do
+    doc = Lutaml::Xml::Schema::Xsd.parse(
+      <<~XSD,
+        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+          <xsd:element name="elt1">
+            <xsd:complexType>
+              <xsd:all><xsd:element name="elt2"/></xsd:all>
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:schema>
+      XSD
+    )
+
+    all = doc.element.first.complex_type.all
+
+    expect(all.min_occurs).to be_nil
+    expect(all.max_occurs).to be_nil
+  end
+end

data/spec/lutaml/xml/schema/xsd/mapping_integrity_spec.rb

@@ -14,6 +14,15 @@ require "lutaml/xml/schema/xsd"
 # registered model's element and attribute rules to declared attributes
 # so the whole typo family fails here, at spec time.
 RSpec.describe "XSD schema model mapping integrity" do
+  # The registry fills at class-definition time and Xsd.parse is what
+  # force-loads the classes; without this hook the sweeps below see an
+  # empty register whenever they run before any parsing spec.
+  before do
+    Lutaml::Xml::Schema::Xsd::XSD_AUTOLOAD_CLASSES.each do |name|
+      Lutaml::Xml::Schema::Xsd.const_get(name) unless name == :VERSION
+    end
+  end
+
   it "maps every element rule of every registered model to a declared attribute" do
     broken = []
 
@@ -60,6 +69,34 @@ RSpec.describe "XSD schema model mapping integrity" do
     MSG
   end
 
+  # #1046 family: xs:all mapped its occurrence bounds by their Ruby names
+  # (min_occurs/max_occurs), so minOccurs="0" was dropped at parse. The
+  # XSD vocabulary has no snake_case attribute names — every multi-word
+  # XML attribute is camelCase — so a snake_case rule name is always a
+  # Ruby name that leaked into the wire.
+  it "spells every multi-word XML attribute name in camelCase" do
+    broken = []
+
+    Lutaml::Xml::Schema::Xsd.register.models.each_value do |klass|
+      next unless klass.is_a?(Class) && klass.include?(Lutaml::Model::Serialize)
+
+      mapping = klass.mappings_for(:xml)
+      mapping.mapping_attributes_hash.each_value do |rule_or_array|
+        Array(rule_or_array).each do |rule|
+          next unless rule.name.to_s.include?("_")
+
+          broken << "#{klass.name}: map_attribute #{rule.name.inspect} -> " \
+                    "#{rule.to.inspect}"
+        end
+      end
+    end
+
+    expect(broken).to be_empty, <<~MSG
+      attribute rules spelled with snake_case wire names:
+      #{broken.join("\n")}
+    MSG
+  end
+
   # #1025: the regression that motivated the sweep — a redefine with a
   # group child parses, and each redefined member kind lands on its
   # declared attribute.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.142
+  version: 0.8.144
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1753,6 +1753,7 @@ files:
 - spec/lutaml/model/consolidation_spec.rb
 - spec/lutaml/model/context_registry_spec.rb
 - spec/lutaml/model/conversion_caching_spec.rb
+- spec/lutaml/model/cow_fork_public_spec.rb
 - spec/lutaml/model/custom_bibtex_adapter_spec.rb
 - spec/lutaml/model/custom_collection_spec.rb
 - spec/lutaml/model/custom_from_empty_values_spec.rb
@@ -2047,6 +2048,7 @@ files:
 - spec/lutaml/xml/schema/facet_round_trip_spec.rb
 - spec/lutaml/xml/schema/rnc_compiler_spec.rb
 - spec/lutaml/xml/schema/rng_compiler_spec.rb
+- spec/lutaml/xml/schema/xsd/all_occurrence_attributes_spec.rb
 - spec/lutaml/xml/schema/xsd/any_attribute_spec.rb
 - spec/lutaml/xml/schema/xsd/errors/error_context_spec.rb
 - spec/lutaml/xml/schema/xsd/errors/suggestion_spec.rb