lutaml-model 0.7.1 → 0.7.7

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
@@ -164,15 +164,15 @@ RSpec.describe "XmlNamespace" do
     end
 
     context "with no prefix" do
-      include_examples "XML serialization with namespace",
-                       TestModelNoPrefix,
-                       '<test xmlns="http://example.com/test"><name>Test Name</name></test>'
+      it_behaves_like "XML serialization with namespace",
+                      TestModelNoPrefix,
+                      '<test xmlns="http://example.com/test"><name>Test Name</name></test>'
     end
 
     context "with prefix" do
-      include_examples "XML serialization with namespace",
-                       TestModelWithPrefix,
-                       '<test:test xmlns:test="http://example.com/test"><test:name>Test Name</test:name></test:test>'
+      it_behaves_like "XML serialization with namespace",
+                      TestModelWithPrefix,
+                      '<test:test xmlns:test="http://example.com/test"><test:name>Test Name</test:name></test:test>'
     end
 
     context "with prefixed namespace" 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
@@ -130,6 +130,30 @@ RSpec.describe "XmlAdapter" do
       end
     end
 
+    context "when xml has `lang` attribute" do
+      before do
+        title_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :lang, :string
+          attribute :content, :string
+
+          xml do
+            root "title"
+
+            map_attribute "lang", to: :lang
+            map_content to: :content
+          end
+        end
+
+        stub_const("Title", title_class)
+      end
+
+      let(:xml_input) { "<title lang='en'>Title</title>" }
+      let(:parsed) { Title.from_xml(xml_input) }
+
+      it { expect(parsed.lang).to eq("en") }
+      it { expect(parsed.content).to eq("Title") }
+    end
+
     it "serializes to XML" do
       expected_xml = <<~XML
         <SampleModel>
@@ -172,15 +196,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,7 +1,7 @@
 require "spec_helper"
 
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+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>$/, "")
@@ -12,19 +12,26 @@ 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")
+      it "returns `xml:lang` when prefix is set" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: "xml")
+        expect(mapping_rule.namespaced_name).to eq("xml:lang")
       end
 
-      it "returns `xml:lang`" do
-        expect(namespaced_name).to eq("xml:lang")
+      it "returns `lang` when prefix is empty string" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: "")
+        expect(mapping_rule.namespaced_name).to eq("lang")
+      end
+
+      it "returns `lang` when prefix is nil" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: nil)
+        expect(mapping_rule.namespaced_name).to eq("lang")
       end
     end
 

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+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
@@ -320,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
@@ -331,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
@@ -365,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
@@ -496,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
 
@@ -508,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
 
@@ -732,7 +732,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
 
         it "prints warning if defined explicitly in class" do
-          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explecitly define at `xml_mapping_spec.rb:\d+`/
+          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explicitly define at `xml_mapping_spec.rb:\d+`/
 
           expect do
             mapping.map_attribute("schemaLocation", to: :schema_location)
@@ -845,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,7 +1248,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
     end
 
     describe "validation errors" do
-      let(:mapping) { Lutaml::Model::XmlMapping.new }
+      let(:mapping) { Lutaml::Model::Xml::Mapping.new }
 
       it "raises error when neither :to nor :with provided" do
         expect do
@@ -1268,6 +1268,12 @@ RSpec.describe Lutaml::Model::XmlMapping do
         )
       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
@@ -1277,6 +1283,12 @@ RSpec.describe Lutaml::Model::XmlMapping do
             ":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
@@ -1292,15 +1304,15 @@ RSpec.describe Lutaml::Model::XmlMapping do
     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("Oga") if Object.const_defined?(:Oga)
+    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 Oga is available" do
+      before do
+        stub_const("Oga", Module.new)
+      end
+
+      it "returns :oga" do
+        expect(described_class.detect_xml_adapter).to eq(:oga)
+      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("Oga", 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/lutaml/model/yamls/standard_adapter_spec.rb

@@ -0,0 +1,183 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Yamls::StandardAdapter do
+  let(:valid_yamls_content) do
+    <<~YAMLS
+      name: John
+      age: 30
+      ---
+      name: Jane
+      age: 25
+      ---
+      name: Bob
+      age: 35
+    YAMLS
+  end
+
+  let(:invalid_yamls_content) do
+    <<~YAMLS
+      name: John
+      age: 30
+      ---
+      invalid yaml: [
+      ---
+      name: Bob
+      age: 35
+    YAMLS
+  end
+
+  describe ".parse" do
+    context "with valid YAMLS content" do
+      it "parses each YAML document as a separate object" do
+        results = described_class.parse(valid_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(3)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+        expect(results.last).to eq({ "name" => "Bob", "age" => 35 })
+      end
+    end
+
+    context "with invalid YAMLS content" do
+      it "skips invalid YAML documents and continues parsing" do
+        results = described_class.parse(invalid_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+        expect(results.last).to eq({ "name" => "Bob", "age" => 35 })
+      end
+    end
+
+    context "with empty documents" do
+      let(:yamls_with_empty_docs) do
+        <<~YAMLS
+          name: John
+          ---
+
+          ---
+          name: Jane
+        YAMLS
+      end
+
+      it "skips empty documents" do
+        results = described_class.parse(yamls_with_empty_docs)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+      end
+    end
+
+    context "with single document" do
+      let(:single_yaml_doc) do
+        <<~YAMLS
+          name: John
+          age: 30
+        YAMLS
+      end
+
+      it "parses single document correctly" do
+        results = described_class.parse(single_yaml_doc)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(1)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+      end
+    end
+
+    context "with complex YAML structures" do
+      let(:complex_yamls_content) do
+        <<~YAMLS
+          name: John
+          address:
+            street: 123 Main St
+            city: New York
+          hobbies:
+            - reading
+            - swimming
+          ---
+          name: Jane
+          address:
+            street: 456 Oak Ave
+            city: Los Angeles
+          hobbies:
+            - hiking
+            - cooking
+        YAMLS
+      end
+
+      it "parses complex YAML structures" do
+        results = described_class.parse(complex_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+
+        expect(results.first).to eq({
+                                      "name" => "John",
+                                      "address" => {
+                                        "street" => "123 Main St",
+                                        "city" => "New York",
+                                      },
+                                      "hobbies" => ["reading", "swimming"],
+                                    })
+
+        expect(results.last).to eq({
+                                     "name" => "Jane",
+                                     "address" => {
+                                       "street" => "456 Oak Ave",
+                                       "city" => "Los Angeles",
+                                     },
+                                     "hobbies" => ["hiking", "cooking"],
+                                   })
+      end
+    end
+  end
+
+  describe "#to_yamls" do
+    let(:john) { { "name" => "John", "age" => 30 } }
+    let(:adapter) { described_class.new([john]) }
+
+    it "generates YAMLS format" do
+      expect(adapter.to_yamls.strip).to eq(john.to_yaml.strip)
+    end
+
+    context "with multiple objects" do
+      let(:jane) { { "name" => "Jane", "age" => 25 } }
+      let(:adapter) { described_class.new([john, jane]) }
+
+      let(:expected_yamls) do
+        <<~YAMLS.strip
+          #{john.to_yaml.strip}
+          #{jane.to_yaml.strip}
+        YAMLS
+      end
+
+      it "generates multiple YAML documents" do
+        expect(adapter.to_yamls.strip).to eq(expected_yamls.strip)
+      end
+    end
+
+    context "with complex data structures" do
+      let(:adapter) do
+        described_class.new([
+                              {
+                                "name" => "John",
+                                "address" => {
+                                  "street" => "123 Main St",
+                                  "city" => "New York",
+                                },
+                                "hobbies" => ["reading", "swimming"],
+                              },
+                            ])
+      end
+
+      it "generates complex YAML structures" do
+        result = adapter.to_yamls
+        expect(result).to include("name")
+        expect(result).to include("address")
+        expect(result).to include("hobbies")
+      end
+    end
+  end
+
+  describe "FORMAT_SYMBOL" do
+    it "returns :yaml" do
+      expect(described_class::FORMAT_SYMBOL).to eq(:yaml)
+    end
+  end
+end