lutaml-model 0.8.4 → 0.8.6

data/spec/lutaml/xml/clear_parse_state_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "#clear_xml_parse_state!" do
+  before do
+    Lutaml::Model::GlobalContext.clear_caches
+    Lutaml::Model::TransformationRegistry.instance.clear
+    Lutaml::Model::GlobalRegister.instance.reset
+  end
+
+  let(:ns_class) do
+    Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/items"
+      prefix_default "a"
+    end
+  end
+
+  let(:model_class) do
+    ns = ns_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :item, :string
+      attribute :count, :integer
+
+      xml do
+        root "root"
+        namespace ns
+        map_element "item", to: :item
+        map_attribute "count", to: :count
+      end
+    end
+  end
+
+  let(:xml_with_ns) do
+    <<~XML
+      <root xmlns:xyz="http://example.com/items" count="3">
+        <xyz:item>hello</xyz:item>
+      </root>
+    XML
+  end
+
+  describe "clearing parse state" do
+    it "clears import_declaration_plan set by :eager mode" do
+      model = model_class.from_xml(xml_with_ns, import_declaration_plan: :eager)
+      expect(model.import_declaration_plan).to be_a(Lutaml::Xml::DeclarationPlan)
+      model.clear_xml_parse_state!
+      expect(model.import_declaration_plan).to be_nil
+    end
+
+    it "clears pending_plan_root_element set by :lazy mode" do
+      model = model_class.from_xml(xml_with_ns)
+      expect(model.pending_plan_root_element).not_to be_nil
+      model.clear_xml_parse_state!
+      expect(model.pending_plan_root_element).to be_nil
+    end
+  end
+
+  describe "return value" do
+    it "returns self for chaining" do
+      model = model_class.from_xml(xml_with_ns)
+      expect(model.clear_xml_parse_state!).to equal(model)
+    end
+  end
+
+  describe "idempotency" do
+    it "is safe to call multiple times" do
+      model = model_class.from_xml(xml_with_ns)
+      expect { 3.times { model.clear_xml_parse_state! } }.not_to raise_error
+    end
+
+    it "is safe on freshly created instances with no parse state" do
+      model = model_class.new(item: "test", count: 1)
+      expect { model.clear_xml_parse_state! }.not_to raise_error
+    end
+  end
+
+  describe "user-facing attributes" do
+    it "does not clear element_order" do
+      model = model_class.from_xml(xml_with_ns)
+      original_order = model.element_order
+      model.clear_xml_parse_state!
+      expect(model.element_order).to eq(original_order)
+    end
+
+    it "does not clear encoding" do
+      model = model_class.from_xml(xml_with_ns, encoding: "UTF-8")
+      model.clear_xml_parse_state!
+      expect(model.encoding).to eq("UTF-8")
+    end
+
+    it "does not clear model attributes" do
+      model = model_class.from_xml(xml_with_ns)
+      expect(model.item).to eq("hello")
+      expect(model.count).to eq(3)
+      model.clear_xml_parse_state!
+      expect(model.item).to eq("hello")
+      expect(model.count).to eq(3)
+    end
+  end
+
+  describe "re-serialization after clearing" do
+    it "allows to_xml after clearing parse state" do
+      model = model_class.from_xml(xml_with_ns, import_declaration_plan: :eager)
+      model.clear_xml_parse_state!
+      result = model.to_xml
+      expect(result).to include("hello")
+    end
+
+    it "allows to_xml after clearing lazy parse state" do
+      model = model_class.from_xml(xml_with_ns)
+      model.clear_xml_parse_state!
+      result = model.to_xml
+      expect(result).to include("hello")
+    end
+
+    it "reflects model modifications after clearing" do
+      model = model_class.from_xml(xml_with_ns)
+      model.item = "modified"
+      model.clear_xml_parse_state!
+      result = model.to_xml
+      expect(result).to include("modified")
+    end
+  end
+
+  describe "Uniword parse-modify-clear-reserialize workflow" do
+    it "clears stale namespace state across multiple parts" do
+      part1 = model_class.from_xml(xml_with_ns, import_declaration_plan: :eager)
+      part2 = model_class.from_xml(xml_with_ns, import_declaration_plan: :eager)
+
+      part1.item = "reconciled"
+      part2.item = "also reconciled"
+
+      [part1, part2].each(&:clear_xml_parse_state!)
+
+      expect(part1.to_xml).to include("reconciled")
+      expect(part2.to_xml).to include("also reconciled")
+    end
+  end
+end

data/spec/lutaml/xml/doubly_defined_namespace_spec.rb

@@ -375,7 +375,6 @@ RSpec.describe "Doubly-defined namespace prefixes" do
       it "builds plan immediately during parsing" do
         model = model_class.from_xml(prefixed_xml,
                                      import_declaration_plan: :eager)
-        expect(model.pending_namespace_data).to be_nil
         expect(model.import_declaration_plan).to be_a(Lutaml::Xml::DeclarationPlan)
       end
     end
@@ -384,7 +383,6 @@ RSpec.describe "Doubly-defined namespace prefixes" do
       it "never builds plan" do
         model = model_class.from_xml(prefixed_xml,
                                      import_declaration_plan: :skip)
-        expect(model.pending_namespace_data).to be_nil
         expect(model.import_declaration_plan).to be_nil
       end
     end

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

@@ -51,18 +51,14 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       context "with valid xml schema, it generates the models" do
         before do
           described_class.to_models(schema, output_dir: dir,
-                                            create_files: true, module_namespace: nil)
-          Dir.each_child(dir) do |child|
-            require_relative File.expand_path("#{dir}/#{child}")
-          end
+                                            create_files: true, module_namespace: "MathTestSpec")
+          require File.join(dir, "mathtestspec_registry.rb")
+          MathTestSpec.register_all
         end
 
         after do
           FileUtils.rm_rf(dir)
-          # Clean up dynamically generated classes to prevent test pollution
-          Object.send(:remove_const, :CTMathTest) if defined?(CTMathTest)
-          Object.send(:remove_const, :StInteger255) if defined?(StInteger255)
-          Object.send(:remove_const, :Long) if defined?(Long)
+          Object.send(:remove_const, :MathTestSpec) if defined?(MathTestSpec)
         end
 
         let(:dir) { Dir.mktmpdir }
@@ -87,40 +83,30 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           INVALID_XML_EXAMPLE
         end
 
-        it "validates if the files exist in the directory" do
-          expect(File).to exist("#{dir}/ct_math_test.rb")
-          expect(File).to exist("#{dir}/st_integer255.rb")
-          expect(File).to exist("#{dir}/long.rb")
+        it "validates if the files exist in the module directory" do
+          module_dir = File.join(dir, "mathtestspec")
+          expect(File).to exist("#{module_dir}/ct_math_test.rb")
+          expect(File).to exist("#{module_dir}/st_integer255.rb")
+          expect(File).to exist("#{module_dir}/long.rb")
         end
 
         it "validates if the CTMathTest class is loaded" do
-          expect(defined?(CTMathTest)).to eq("constant")
+          expect(defined?(MathTestSpec::CTMathTest)).to eq("constant")
         end
 
         it "creates the model files, requires them, and tests them with valid and invalid xml" do
-          expect(CTMathTest.from_xml(valid_value_xml_example).to_xml).to be_xml_equivalent_to(valid_value_xml_example)
+          expect(MathTestSpec::CTMathTest.from_xml(valid_value_xml_example).to_xml).to be_xml_equivalent_to(valid_value_xml_example)
         end
 
         it "raises error when processing invalid example" do
           expect do
-            CTMathTest.from_xml(invalid_value_xml_example)
+            MathTestSpec::CTMathTest.from_xml(invalid_value_xml_example)
           end.to raise_error(Lutaml::Model::Type::MinBoundError)
         end
       end
 
       context "when processing examples from classes/files generated by valid xml schema" do
-        before do
-          Dir.mktmpdir do |dir|
-            described_class.to_models(
-              File.read("spec/fixtures/xml/math_document_schema.xsd"),
-              output_dir: dir,
-              create_files: true,
-              module_namespace: nil,
-            )
-            require_relative "#{dir}/math_document"
-          end
-        end
-
+        let!(:math_doc_dir) { Dir.mktmpdir }
         let(:valid_example) do
           File.read("spec/fixtures/xml/valid_math_document.xml")
         end
@@ -128,42 +114,39 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           File.read("spec/fixtures/xml/invalid_math_document.xml")
         end
 
+        before do
+          described_class.to_models(
+            File.read("spec/fixtures/xml/math_document_schema.xsd"),
+            output_dir: math_doc_dir,
+            create_files: true,
+            module_namespace: "MathDocSpec",
+          )
+          require File.join(math_doc_dir, "mathdocspec_registry.rb")
+          MathDocSpec.register_all
+        end
+
+        after do
+          FileUtils.rm_rf(math_doc_dir)
+          Object.send(:remove_const, :MathDocSpec) if defined?(MathDocSpec)
+        end
+
         it "does not raise error with valid example and creates files" do
-          expect(defined?(MathDocument)).to eq("constant")
-          parsed = MathDocument.from_xml(valid_example)
+          expect(defined?(MathDocSpec::MathDocument)).to eq("constant")
+          parsed = MathDocSpec::MathDocument.from_xml(valid_example)
           expect(parsed.title).to eql("Example Title")
           expect(parsed.ipv4_address).to eql("192.168.1.1")
           expect(parsed.to_xml).to be_xml_equivalent_to(valid_example)
         end
 
         it "raises PatternNotMatchedError" do
-          expect(defined?(MathDocument)).to eq("constant")
-          expect { MathDocument.from_xml(invalid_example) }
+          expect(defined?(MathDocSpec::MathDocument)).to eq("constant")
+          expect { MathDocSpec::MathDocument.from_xml(invalid_example) }
             .to raise_error(Lutaml::Model::Type::PatternNotMatchedError)
         end
       end
 
       context "when processing example from lutaml-model#260" do
-        before do
-          # Remove any existing Address constant to prevent test pollution
-          Object.send(:remove_const, :Address) if defined?(Address)
-
-          Dir.mktmpdir do |dir|
-            described_class.to_models(
-              File.read("spec/fixtures/xml/address_example_260.xsd"),
-              output_dir: dir,
-              create_files: true,
-              module_namespace: nil,
-            )
-            load "#{dir}/address.rb"
-          end
-        end
-
-        after do
-          # Clean up the Address constant to prevent test pollution
-          Object.send(:remove_const, :Address) if defined?(Address)
-        end
-
+        let!(:address_dir) { Dir.mktmpdir }
         let(:address) do
           <<~ADD
             <Address>
@@ -174,43 +157,66 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           ADD
         end
 
-        it "matches parsed xml with input" do
-          expect(defined?(Address)).to eq("constant")
-          expect(Address.from_xml(address).to_xml).to be_xml_equivalent_to(address)
+        before do
+          described_class.to_models(
+            File.read("spec/fixtures/xml/address_example_260.xsd"),
+            output_dir: address_dir,
+            create_files: true,
+            module_namespace: "CompilerSpec260",
+          )
+          require File.join(address_dir, "compilerspec260_registry.rb")
+          CompilerSpec260.register_all
         end
-      end
 
-      context "when processing example from files generated by schema -> product_catalog.xsd" do
-        before do
-          Dir.mktmpdir do |dir|
-            described_class.to_models(
-              File.read("spec/fixtures/xml/product_catalog.xsd"),
-              output_dir: dir,
-              create_files: true,
-              module_namespace: nil,
-            )
-            require_relative "#{dir}/product_catalog"
+        after do
+          FileUtils.rm_rf(address_dir)
+          if defined?(CompilerSpec260)
+            Object.send(:remove_const,
+                        :CompilerSpec260)
           end
         end
 
+        it "matches parsed xml with input" do
+          expect(defined?(CompilerSpec260::Address)).to eq("constant")
+          expect(CompilerSpec260::Address.from_xml(address).to_xml).to be_xml_equivalent_to(address)
+        end
+      end
+
+      context "when processing example from files generated by schema -> product_catalog.xsd" do
+        let!(:catalog_dir) { Dir.mktmpdir }
         let(:product_catalog) do
           File.read("spec/fixtures/xml/examples/valid_catalog.xml")
         end
-
         let(:nested_category) do
           File.read("spec/fixtures/xml/examples/nested_categories.xml")
         end
 
+        before do
+          described_class.to_models(
+            File.read("spec/fixtures/xml/product_catalog.xsd"),
+            output_dir: catalog_dir,
+            create_files: true,
+            module_namespace: "CatalogSpec",
+          )
+          require File.join(catalog_dir, "catalogspec_registry.rb")
+          CatalogSpec.register_all
+        end
+
+        after do
+          FileUtils.rm_rf(catalog_dir)
+          Object.send(:remove_const, :CatalogSpec) if defined?(CatalogSpec)
+        end
+
         it "confirms the ProductCatalog class is required" do
-          expect(defined?(ProductCatalog)).to eq("constant")
+          expect(defined?(CatalogSpec::ProductCatalog)).to eq("constant")
         end
 
         it "confirms that the from_xml and to_xml methods successfully handles xml for valid_catalog.xml" do
-          expect(ProductCatalog.from_xml(product_catalog).to_xml).to be_a(String)
+          expect(CatalogSpec::ProductCatalog.from_xml(product_catalog).to_xml).to be_a(String)
         end
 
         it "confirms that the from_xml and to_xml methods successfully handles xml for nested_categories.xml" do
-          expect(ProductCatalog.from_xml(nested_category).to_xml).to be_a(String)
+          expect(CatalogSpec::ProductCatalog.from_xml(nested_category).to_xml).to be_a(String)
         end
       end
 

data/spec/lutaml/xml/transformation/custom_method_wrapper_spec.rb

@@ -4,30 +4,229 @@ require "spec_helper"
 require "lutaml/xml"
 
 RSpec.describe Lutaml::Xml::CustomMethodWrapper do
-  describe "#add_element" do
-    it "parses XML fragments through Moxml when Opal is active" do
-      parent = Lutaml::Xml::DataModel::XmlElement.new("parent")
-      wrapper = described_class.new(parent, nil)
+  let(:parent) { Lutaml::Xml::DataModel::XmlElement.new("parent") }
+  let(:wrapper) { described_class.new(parent) }
+
+  describe "#create_element" do
+    it "returns a new XmlElement with the given name" do
+      el = wrapper.create_element("foo")
+      expect(el).to be_a(Lutaml::Xml::DataModel::XmlElement)
+      expect(el.name).to eq("foo")
+    end
+
+    it "does not add the element to any parent" do
+      wrapper.create_element("orphan")
+      expect(parent.children).to be_empty
+    end
+  end
 
-      allow(Lutaml::Model::RuntimeCompatibility).to receive(:opal?)
-        .and_return(true)
+  describe "#add_element" do
+    it "adds an XmlElement child with single-argument form" do
+      child = Lutaml::Xml::DataModel::XmlElement.new("child")
+      result = wrapper.add_element(child)
+      expect(result).to eq(child)
+      expect(parent.children).to eq([child])
+    end
 
-      wrapper.add_element(
-        parent,
-        "<a title=\"copyright\">one</a><b>two</b>",
-      )
+    it "adds an XmlElement child with two-argument form" do
+      child = Lutaml::Xml::DataModel::XmlElement.new("child")
+      wrapper.add_element(parent, child)
+      expect(parent.children).to eq([child])
+    end
 
-      expect(parent.raw_content).to be_nil
+    it "parses XML string fragments via Moxml" do
+      wrapper.add_element(parent, "<a title=\"copyright\">one</a><b>two</b>")
       expect(parent.children.map(&:name)).to eq(%w[a b])
       expect(parent.children[0].attributes.first.value).to eq("copyright")
       expect(parent.children[0].text_content).to eq("one")
       expect(parent.children[1].text_content).to eq("two")
     end
+
+    it "raises TypeError for unsupported types" do
+      foreign = instance_double(Object)
+      expect do
+        wrapper.add_element(parent, foreign)
+      end.to raise_error(TypeError,
+                         /add_element expects a String or XmlElement/)
+    end
+
+    it "parses nested XML elements recursively" do
+      wrapper.add_element(parent, "<outer><inner>text</inner></outer>")
+      outer = parent.children.first
+      expect(outer.name).to eq("outer")
+      expect(outer.children.first.name).to eq("inner")
+      expect(outer.children.first.text_content).to eq("text")
+    end
+  end
+
+  describe "#add_text" do
+    it "sets text_content on the given element" do
+      el = Lutaml::Xml::DataModel::XmlElement.new("p")
+      wrapper.add_text(el, "hello")
+      expect(el.text_content).to eq("hello")
+    end
+
+    it "sets text on current context when element is nil" do
+      wrapper.add_text(nil, "fallback")
+      expect(parent.text_content).to eq("fallback")
+    end
+
+    it "sets text on current context when wrapper itself is passed" do
+      wrapper.add_text(wrapper, "via-doc")
+      expect(parent.text_content).to eq("via-doc")
+    end
+  end
+
+  describe "#add_attribute" do
+    it "adds an attribute to the element" do
+      el = Lutaml::Xml::DataModel::XmlElement.new("node")
+      wrapper.add_attribute(el, "id", "42")
+      expect(el.attributes.size).to eq(1)
+      expect(el.attributes.first.name).to eq("id")
+      expect(el.attributes.first.value).to eq("42")
+    end
+
+    it "coerces name and value to strings" do
+      el = Lutaml::Xml::DataModel::XmlElement.new("node")
+      wrapper.add_attribute(el, :key, 123)
+      expect(el.attributes.first.name).to eq("key")
+      expect(el.attributes.first.value).to eq("123")
+    end
+  end
+
+  describe "#create_and_add_element" do
+    it "creates and adds element to current context" do
+      el = wrapper.create_and_add_element("item")
+      expect(el.name).to eq("item")
+      expect(parent.children).to eq([el])
+    end
+
+    it "creates element with attributes" do
+      el = wrapper.create_and_add_element("item", attributes: { id: "1" })
+      expect(el.attributes.first.name).to eq("id")
+      expect(el.attributes.first.value).to eq("1")
+    end
+
+    it "yields ElementWrapper in block form" do
+      wrapper.create_and_add_element("outer") do |w|
+        w.add_text(w, "content")
+      end
+      outer = parent.children.first
+      expect(outer.text_content).to eq("content")
+    end
+
+    it "supports nested create_and_add_element in block" do
+      wrapper.create_and_add_element("outer") do |w|
+        w.create_and_add_element("inner") do |iw|
+          iw.add_text(iw, "deep")
+        end
+      end
+      outer = parent.children.first
+      inner = outer.children.first
+      expect(inner.name).to eq("inner")
+      expect(inner.text_content).to eq("deep")
+    end
+
+    it "restores context after block exits" do
+      wrapper.create_and_add_element("outer") do |_w|
+        # context is now "outer"
+      end
+      # context should be back to parent
+      el = wrapper.create_and_add_element("after")
+      expect(parent.children).to include(el)
+    end
+  end
+
+  describe "#push_context / #pop_context" do
+    it "manages a stack of context elements" do
+      child = Lutaml::Xml::DataModel::XmlElement.new("child")
+      wrapper.push_context(child)
+      expect(wrapper.current_context).to eq(child)
+      wrapper.pop_context
+      expect(wrapper.current_context).to eq(parent)
+    end
+
+    it "does not pop below the root context" do
+      wrapper.pop_context
+      expect(wrapper.current_context).to eq(parent)
+    end
+  end
+
+  describe ".build_element" do
+    it "creates an element with attributes" do
+      el = described_class.build_element("tag", { a: "1", b: "2" })
+      expect(el.name).to eq("tag")
+      expect(el.attributes.map(&:name)).to eq(%w[a b])
+    end
+
+    it "handles nil attributes hash" do
+      el = described_class.build_element("tag", nil)
+      expect(el.attributes).to be_empty
+    end
+  end
+
+  describe Lutaml::Xml::CustomMethodWrapper::ElementWrapper do
+    let(:element) { Lutaml::Xml::DataModel::XmlElement.new("el") }
+    let(:ew) { described_class.new(element) }
+
+    describe "#add_text" do
+      it "sets text and cdata flag" do
+        ew.add_text(ew, "data", cdata: true)
+        expect(element.text_content).to eq("data")
+        expect(element.cdata).to be true
+      end
+
+      it "handles cdata as hash format" do
+        ew.add_text(ew, "data", cdata: { cdata: true })
+        expect(element.cdata).to be true
+      end
+
+      it "defaults cdata to false" do
+        ew.add_text(ew, "data")
+        expect(element.cdata).to be false
+      end
+    end
+
+    describe "#create_and_add_element" do
+      it "adds child to wrapped element" do
+        child = ew.create_and_add_element("sub")
+        expect(element.children).to eq([child])
+      end
+
+      it "yields nested wrapper in block form" do
+        ew.create_and_add_element("sub") do |sub|
+          sub.add_text(sub, "text")
+        end
+        expect(element.children.first.text_content).to eq("text")
+      end
+    end
+  end
+
+  describe "XmlElement#add_child type guard" do
+    it "accepts XmlElement" do
+      child = Lutaml::Xml::DataModel::XmlElement.new("ok")
+      expect { parent.add_child(child) }.not_to raise_error
+    end
+
+    it "accepts String" do
+      expect { parent.add_child("text") }.not_to raise_error
+    end
+
+    it "accepts XmlComment" do
+      comment = Lutaml::Xml::DataModel::XmlComment.new("a comment")
+      expect { parent.add_child(comment) }.not_to raise_error
+    end
+
+    it "rejects foreign types" do
+      expect do
+        parent.add_child(42)
+      end.to raise_error(TypeError, /XmlElement#add_child expects/)
+    end
   end
 
   describe "RuleApplier integration" do
     it "loads the wrapper through the public XML autoload path" do
-      parent = Lutaml::Xml::DataModel::XmlElement.new("parent")
+      parent_el = Lutaml::Xml::DataModel::XmlElement.new("parent")
       model_class = Class.new do
         def custom_to_xml(_model, parent, wrapper)
           wrapper.add_text(parent, "ok")
@@ -40,9 +239,9 @@ RSpec.describe Lutaml::Xml::CustomMethodWrapper do
         public :apply_custom_method
       end.new
 
-      applier.apply_custom_method(parent, rule, model_class, Object.new)
+      applier.apply_custom_method(parent_el, rule, model_class, Object.new)
 
-      expect(parent.text_content).to eq("ok")
+      expect(parent_el.text_content).to eq("ok")
     end
   end
 end