lutaml-model 0.6.7 → 0.7.2

data/spec/lutaml/model/xml/namespace_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+module NamespaceSpec
+  class NestedChild < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    xml do
+      root "NestedChild"
+
+      map_element :name, to: :name
+    end
+  end
+
+  class Child < Lutaml::Model::Serializable
+    attribute :nested_child, NestedChild
+
+    xml do
+      root "NestedChild"
+
+      map_element :NestedChild, to: :nested_child
+    end
+  end
+
+  class Parent < Lutaml::Model::Serializable
+    attribute :child, Child
+
+    xml do
+      root "Parent"
+      namespace "https://abc.com"
+
+      map_element :Child, to: :child
+    end
+  end
+end
+
+RSpec.describe "NamespaceSpec" do
+  let(:parsed) { NamespaceSpec::Parent.from_xml(xml) }
+  let(:xml) do
+    <<~XML
+      <Parent xmlns="https://abc.com">
+        <Child>
+          <NestedChild>
+            <name>Rogger moore</name>
+          </NestedChild>
+        </Child>
+      </Parent>
+    XML
+  end
+
+  it "parses nested child using root namespace" do
+    expect(parsed.child.nested_child.name).to eq("Rogger moore")
+  end
+
+  it "round-trips xml" do
+    expect(parsed.to_xml).to be_equivalent_to(xml)
+  end
+end

data/spec/lutaml/model/xml/xml_element_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XmlElement" do
+  describe "#text" do
+    context "when only text is present" do
+      let(:element) { create_element("name", text: "something") }
+
+      it "returns text" do
+        expect(element.text).to eq("something")
+      end
+    end
+
+    context "when single text node is present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("text", text: "John Doe"),
+          ],
+        )
+      end
+
+      it "returns single string" do
+        expect(element.text).to eq("John Doe")
+      end
+    end
+
+    context "when multiple text nodes are present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("text", text: "John"),
+            create_element("text", text: "\n"),
+            create_element("text", text: "Doe"),
+          ],
+        )
+      end
+
+      it "returns all text elements array" do
+        expect(element.text).to eq(["John", "\n", "Doe"])
+      end
+    end
+  end
+
+  describe "#cdata" do
+    context "when only cdata is present" do
+      let(:element) { create_element("name", text: "something") }
+
+      it "returns cdata" do
+        expect(element.cdata).to eq("something")
+      end
+    end
+
+    context "when single cdata node is present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("#cdata-section", text: "John Doe"),
+          ],
+        )
+      end
+
+      it "returns single string" do
+        expect(element.cdata).to eq("John Doe")
+      end
+    end
+
+    context "when multiple cdata nodes are present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("#cdata-section", text: "John"),
+            create_element("#cdata-section", text: "\n"),
+            create_element("#cdata-section", text: "Doe"),
+          ],
+        )
+      end
+
+      it "returns all cdata elements array" do
+        expect(element.cdata).to eq(["John", "\n", "Doe"])
+      end
+    end
+  end
+
+  def create_element(name, attributes: {}, children: [], text: "")
+    Lutaml::Model::Xml::XmlElement.new(name, attributes, children, text)
+  end
+end

data/spec/lutaml/model/xml_adapter/nokogiri_adapter_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 require "nokogiri"
-require_relative "../../../../lib/lutaml/model/xml_adapter/nokogiri_adapter"
+require_relative "../../../../lib/lutaml/model/xml/nokogiri_adapter"
 
-RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+RSpec.describe Lutaml::Model::Xml::NokogiriAdapter do
   let(:xml_string) do
     <<-XML
       <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">

data/spec/lutaml/model/xml_adapter/oga_adapter_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 require "oga"
-require_relative "../../../../lib/lutaml/model/xml_adapter/oga_adapter"
+require_relative "../../../../lib/lutaml/model/xml/oga_adapter"
 
-RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
+RSpec.describe Lutaml::Model::Xml::OgaAdapter do
   let(:xml_string) do
     <<~XML
       <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">

data/spec/lutaml/model/xml_adapter/ox_adapter_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 require "ox"
-require_relative "../../../../lib/lutaml/model/xml_adapter/ox_adapter"
+require_relative "../../../../lib/lutaml/model/xml/ox_adapter"
 
-RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
+RSpec.describe Lutaml::Model::Xml::OxAdapter do
   let(:xml_string) do
     <<-XML
       <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">

data/spec/lutaml/model/xml_adapter/xml_namespace_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model/xml/nokogiri_adapter"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 require "lutaml/model"
 
 RSpec.describe "XmlNamespace" do
@@ -354,15 +354,15 @@ RSpec.describe "XmlNamespace" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "an XML namespace parser", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "an XML namespace parser", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+  describe Lutaml::Model::Xml::OgaAdapter do
     it_behaves_like "an XML namespace parser", described_class
   end
 end

data/spec/lutaml/model/xml_adapter_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model/xml/nokogiri_adapter"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 require_relative "../../fixtures/sample_model"
 
 module XmlAdapterSpec
@@ -172,15 +172,15 @@ RSpec.describe "XmlAdapter" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "an XML adapter", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "an XML adapter", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+  describe Lutaml::Model::Xml::OgaAdapter do
     it_behaves_like "an XML adapter", described_class
   end
 end

data/spec/lutaml/model/xml_mapping_rule_spec.rb

@@ -1,9 +1,7 @@
 require "spec_helper"
 
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
-
-require_relative "../../../lib/lutaml/model/xml_mapping_rule"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 
 def content_to_xml(model, parent, doc)
   content = model.all_content.sub(/^<div>/, "").sub(/<\/div>$/, "")
@@ -14,7 +12,109 @@ def content_from_xml(model, value)
   model.all_content = "<div>#{value}</div>"
 end
 
-RSpec.describe Lutaml::Model::XmlMappingRule do
+RSpec.describe Lutaml::Model::Xml::MappingRule do
+  describe "#namespaced_name" do
+    let(:namespaced_name) do
+      mapping_rule.namespaced_name
+    end
+
+    context "when attribute name is string 'lang'" do
+      let(:mapping_rule) do
+        described_class.new("lang", to: :lang, prefix: "xml")
+      end
+
+      it "returns `xml:lang`" do
+        expect(namespaced_name).to eq("xml:lang")
+      end
+    end
+
+    context "when attribute name is symbol ':lang'" do
+      let(:mapping_rule) do
+        described_class.new(:lang, to: :lang, prefix: "xml")
+      end
+
+      it "returns `xml:lang`" do
+        expect(namespaced_name).to eq("xml:lang")
+      end
+    end
+
+    context "when namespace is explicitly set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "explicit_namespace",
+          to: :explicit_namespace,
+          namespace: "http://test",
+          namespace_set: true,
+        )
+      end
+
+      it "returns `http://test:explicit_namespace`" do
+        expect(namespaced_name).to eq("http://test:explicit_namespace")
+      end
+    end
+
+    context "when namespace is explicitly set to nil" do
+      let(:mapping_rule) do
+        described_class.new(
+          "explicit_namespace",
+          to: :explicit_namespace,
+          namespace: nil,
+          namespace_set: true,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns name without namespace" do
+        expect(namespaced_name).to eq("explicit_namespace")
+      end
+    end
+
+    context "when attribute has namespace set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "attribute",
+          to: :attribute,
+          attribute: true,
+          namespace: "http://test",
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns `http://test:attribute`" do
+        expect(namespaced_name).to eq("http://test:attribute")
+      end
+    end
+
+    context "when attribute has no namespace set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "attribute",
+          to: :attribute,
+          attribute: true,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "does not use default namespace" do
+        expect(namespaced_name).to eq("attribute")
+      end
+    end
+
+    context "when default_namespace is set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "default_namespace",
+          to: :default_namespace,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns `default_namespace:name` if not an attribute" do
+        expect(namespaced_name).to eq("http://default:default_namespace")
+      end
+    end
+  end
+
   context "with Xml Mapping Rule" do
     let(:orig_mapping_rule) do
       described_class.new(

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -1,10 +1,7 @@
 require "spec_helper"
 
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
-
-require_relative "../../../lib/lutaml/model/xml_mapping"
-require_relative "../../../lib/lutaml/model/xml_mapping_rule"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 
 # Define a sample class for testing map_content
 class Italic < Lutaml::Model::Serializable
@@ -323,7 +320,7 @@ module XmlMapping
   end
 end
 
-RSpec.describe Lutaml::Model::XmlMapping do
+RSpec.describe Lutaml::Model::Xml::Mapping do
   shared_examples "having XML Mappings" do |adapter_class|
     around do |example|
       old_adapter = Lutaml::Model::Config.xml_adapter
@@ -334,7 +331,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
       Lutaml::Model::Config.xml_adapter = old_adapter
     end
 
-    let(:mapping) { Lutaml::Model::XmlMapping.new }
+    let(:mapping) { Lutaml::Model::Xml::Mapping.new }
 
     context "with attribute having namespace" do
       input_xml = <<~XML
@@ -368,7 +365,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
     end
 
     # Skipping for OX because it does not handle namespaces
-    context "when overriding child namespace prefix", skip: adapter_class == Lutaml::Model::XmlAdapter::OxAdapter do
+    context "when overriding child namespace prefix", skip: adapter_class == Lutaml::Model::Xml::OxAdapter do
       let(:input_xml) do
         <<~XML
           <OverrideDefaultNamespacePrefix
@@ -445,6 +442,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       it "parse and serialize model correctly" do
         parsed = XmlMapping::OwnedComment.from_xml(xml_with_attribute)
+
         serialized = parsed.to_xml
 
         expect(serialized).to be_equivalent_to(xml_with_attribute)
@@ -498,9 +496,9 @@ RSpec.describe Lutaml::Model::XmlMapping do
                                                 ])
 
         {
-          Lutaml::Model::XmlAdapter::NokogiriAdapter => nokogiri_pattern,
-          Lutaml::Model::XmlAdapter::OxAdapter => oga_ox_pattern,
-          Lutaml::Model::XmlAdapter::OgaAdapter => oga_ox_pattern,
+          Lutaml::Model::Xml::NokogiriAdapter => nokogiri_pattern,
+          Lutaml::Model::Xml::OxAdapter => oga_ox_pattern,
+          Lutaml::Model::Xml::OgaAdapter => oga_ox_pattern,
         }
       end
 
@@ -510,7 +508,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       def create_pattern_mapping(array)
         array.map do |type, text|
-          Lutaml::Model::XmlAdapter::Element.new(type, text)
+          Lutaml::Model::Xml::Element.new(type, text)
         end
       end
 
@@ -847,7 +845,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
 
       let(:expected_street) do
-        if Lutaml::Model::Config.xml_adapter == Lutaml::Model::XmlAdapter::NokogiriAdapter
+        if Lutaml::Model::Config.xml_adapter == Lutaml::Model::Xml::NokogiriAdapter
           "\n      <a>N</a>\n      <p>adf</p>\n    "
         else
           "<a>N</a><p>adf</p>"
@@ -1248,17 +1246,73 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
       end
     end
+
+    describe "validation errors" do
+      let(:mapping) { Lutaml::Model::Xml::Mapping.new }
+
+      it "raises error when neither :to nor :with provided" do
+        expect do
+          mapping.map_element("test")
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":to or :with argument is required for mapping 'test'",
+        )
+      end
+
+      it "raises error when :with is missing :to or :from keys" do
+        expect do
+          mapping.map_element("test", with: { to: "value" })
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":with argument for mapping 'test' requires :to and :from keys",
+        )
+      end
+
+      it "does not raise error when :to is provided" do
+        expect do
+          mapping.map_element("test", to: :test, with: { from: "value" })
+        end.not_to raise_error
+      end
+
+      describe "map_attribute validations" do
+        it "raises error for invalid :with argument" do
+          expect do
+            mapping.map_attribute("test", with: { from: "value" })
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":with argument for mapping 'test' requires :to and :from keys",
+          )
+        end
+
+        it "does not raise error if to is provided" do
+          expect do
+            mapping.map_attribute("test", to: :test, with: { from: "value" })
+          end.not_to raise_error
+        end
+      end
+
+      describe "map_content validations" do
+        it "raises error when no :to provided" do
+          expect do
+            mapping.map_content
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":to or :with argument is required for mapping 'content'",
+          )
+        end
+      end
+    end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "having XML Mappings", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "having XML Mappings", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+  describe Lutaml::Model::Xml::OgaAdapter do
     it_behaves_like "having XML Mappings", described_class
   end
 end

data/spec/lutaml/model/xml_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/xml"
+
+RSpec.describe Lutaml::Model::Xml do
+  describe ".detect_xml_adapter" do
+    before do
+      # Hide any existing constants first
+      hide_const("Nokogiri") if Object.const_defined?(:Nokogiri)
+      hide_const("Ox") if Object.const_defined?(:Ox)
+      hide_const("Opal") if Object.const_defined?(:Opal)
+    end
+
+    context "when Nokogiri is available" do
+      before do
+        stub_const("Nokogiri", Module.new)
+      end
+
+      it "returns :nokogiri" do
+        expect(described_class.detect_xml_adapter).to eq(:nokogiri)
+      end
+    end
+
+    context "when Ox is available" do
+      before do
+        stub_const("Ox", Module.new)
+      end
+
+      it "returns :ox" do
+        expect(described_class.detect_xml_adapter).to eq(:ox)
+      end
+    end
+
+    context "when Opal is available" do
+      before do
+        stub_const("Opal", Module.new)
+      end
+
+      it "returns :opal" do
+        expect(described_class.detect_xml_adapter).to eq(:opal)
+      end
+    end
+
+    context "when no adapters are available" do
+      it "returns nil" do
+        expect(described_class.detect_xml_adapter).to be_nil
+      end
+    end
+
+    context "when multiple adapters are available" do
+      before do
+        stub_const("Nokogiri", Module.new)
+        stub_const("Ox", Module.new)
+        stub_const("Opal", Module.new)
+      end
+
+      it "prefers Nokogiri" do
+        expect(described_class.detect_xml_adapter).to eq(:nokogiri)
+      end
+    end
+  end
+end

data/spec/lutaml/model/yaml_adapter_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require "lutaml/model/yaml_adapter"
 require_relative "../../fixtures/sample_model"
 
 RSpec.shared_examples "a YAML adapter" do |adapter_class|
@@ -7,7 +6,7 @@ RSpec.shared_examples "a YAML adapter" do |adapter_class|
   let(:model) { SampleModel.new(attributes) }
 
   let(:expected_yaml) do
-    if adapter_class == Lutaml::Model::YamlAdapter::StandardYamlAdapter
+    if adapter_class == Lutaml::Model::Yaml::StandardAdapter
       attributes.to_yaml
     end
   end
@@ -20,11 +19,10 @@ RSpec.shared_examples "a YAML adapter" do |adapter_class|
 
   it "deserializes from YAML" do
     new_model = adapter_class.parse(expected_yaml)
-    expect(new_model["name"]).to eq("John Doe")
-    expect(new_model["age"]).to eq(30)
+    expect(new_model).to eq(attributes)
   end
 end
 
-RSpec.describe Lutaml::Model::YamlAdapter::StandardYamlAdapter do
+RSpec.describe Lutaml::Model::Yaml::StandardAdapter do
   it_behaves_like "a YAML adapter", described_class
 end

data/spec/sample_model_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require_relative "fixtures/sample_model"
 
 RSpec.describe SampleModel do
-  let(:model) { described_class.new(attributes) }
+  let(:model) { described_class.new(attributes, { omitted: :omitted }) }
   let(:attributes_yaml) do
     {
       "name" => "John Doe",
@@ -37,7 +37,7 @@ RSpec.describe SampleModel do
   end
 
   describe "default values" do
-    let(:model) { described_class.new }
+    let(:model) { described_class.new({}, { omitted: :omitted }) }
 
     it "sets default name" do
       expect(model.name).to eq("Anonymous")
@@ -52,7 +52,7 @@ RSpec.describe SampleModel do
     end
 
     it "sets default tags" do
-      expect(model.tags).to eq([])
+      expect(model.tags).to be_uninitialized
     end
 
     it "sets default preferences" do

data/spec/spec_helper.rb

@@ -22,9 +22,9 @@ end
 
 # configuration example
 require_relative "../lib/lutaml/model"
-require_relative "../lib/lutaml/model/xml_adapter/nokogiri_adapter"
-require_relative "../lib/lutaml/model/xml_adapter/ox_adapter"
-require_relative "../lib/lutaml/model/toml_adapter/toml_rb_adapter"
+# require_relative "../lib/lutaml/model/xml/nokogiri_adapter"
+# require_relative "../lib/lutaml/model/xml/ox_adapter"
+# require_relative "../lib/lutaml/model/toml_adapter/toml_rb_adapter"
 
 Lutaml::Model::Config.configure do |config|
   config.xml_adapter_type = :nokogiri