lutaml-model 0.7.1 → 0.7.7

data/spec/lutaml/model/global_register_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::GlobalRegister do
+  describe "#initialize" do
+    it "initializes with a default register" do
+      expect(described_class.instance.instance_variable_get(:@registers)).to include(default: described_class.lookup(:default))
+    end
+  end
+
+  describe "#register" do
+    it "adds register to the internal hash" do
+      register = Lutaml::Model::Register.new(:test_register)
+      described_class.register(register)
+
+      registers = described_class.instance.instance_variable_get(:@registers)
+      expect(registers[:test_register]).to eq(register)
+    end
+  end
+
+  describe ".register" do
+    it "calls instance method to register" do
+      register = Lutaml::Model::Register.new(:temp_register)
+      expect { described_class.register(register) }.to(
+        change { described_class.instance.instance_variable_get(:@registers).count }.by(1),
+      )
+    end
+  end
+
+  describe "#lookup" do
+    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
+    let(:register_v_two) { Lutaml::Model::Register.new(:v2) }
+
+    before do
+      described_class.instance.register(register_v_one)
+      described_class.instance.register(register_v_two)
+    end
+
+    it "returns the correct register for a given id" do
+      expect(described_class.instance.lookup(:v1)).to eq(register_v_one)
+      expect(described_class.instance.lookup(:v2)).to eq(register_v_two)
+    end
+
+    it "returns nil for non-existent id" do
+      expect(described_class.instance.lookup(:non_existent)).to be_nil
+    end
+
+    it "converts string id to symbol" do
+      expect(described_class.instance.lookup("v1")).to eq(register_v_one)
+    end
+  end
+
+  describe ".lookup" do
+    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
+
+    it "calls instance method to lookup" do
+      allow(described_class.instance).to receive(:lookup).with(:v1).and_return(register_v_one)
+
+      expect(described_class.lookup(:v1)).to eq(register_v_one)
+    end
+  end
+
+  describe "singleton behavior" do
+    it "returns the same instance on multiple calls" do
+      instance1 = described_class.instance
+      instance2 = described_class.instance
+
+      expect(instance1).to be(instance2)
+    end
+
+    it "shares state between method calls" do
+      register = Lutaml::Model::Register.new(:shared_test)
+      described_class.register(register)
+      expect(described_class.lookup(:shared_test)).to eq(register)
+    end
+  end
+
+  describe "#remove" do
+    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
+    let(:register_v_two) { Lutaml::Model::Register.new(:v2) }
+
+    before do
+      described_class.register(register_v_one)
+      described_class.register(register_v_two)
+    end
+
+    it "removes the specified register" do
+      register = described_class.instance
+      expect(register.instance_variable_get(:@registers).values).to include(register_v_one)
+      expect { described_class.remove(:v1) }.to(
+        change { register.instance_variable_get(:@registers).values.count }.by(-1),
+      )
+      expect(register.instance_variable_get(:@registers).values).not_to include(register_v_one)
+    end
+
+    it "does not remove other registers" do
+      described_class.remove(:v1)
+      registers = described_class.instance.instance_variable_get(:@registers)
+      expect(registers.values).to include(register_v_two)
+    end
+
+    it "does nothing when the specified register does not exist" do
+      registers = described_class.instance.instance_variable_get(:@registers)
+      expect { described_class.remove(:non_existent) }.not_to(change { registers.values.count })
+    end
+  end
+end

data/spec/lutaml/model/group_spec.rb

@@ -60,12 +60,12 @@ module GroupSpec
       map_attribute "tag", to: :tag
       map_content to: :content
       map_element :group, to: :group
-      import_model_mappings GroupOfItems
+      import_model_mappings :group_of_items
     end
   end
 
   class SimpleType < Lutaml::Model::Serializable
-    import_model GroupOfItems
+    import_model :group_of_items
   end
 
   class GenericType < Lutaml::Model::Serializable
@@ -228,13 +228,24 @@ RSpec.describe "Group" do
       )
     end
 
-    it "raises error if root_less class used for deserializing" do
-      ceramic = GroupSpec::Ceramic.new(type: "Data", name: "Starc")
+    context "deserializing XML" do
+      let(:ceramic) { GroupSpec::Ceramic.new(type: "Data", name: "Starc") }
 
-      expect { ceramic.to_xml }.to raise_error(
-        Lutaml::Model::NoRootMappingError,
-        "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
-      )
+      it "raises error for root_less class" do
+        expect { ceramic.to_xml }.to raise_error(
+          Lutaml::Model::NoRootMappingError,
+          "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
+        )
+      end
+    end
+
+    context "deserializing key-value formats" do
+      let(:ceramic) { GroupSpec::Ceramic.new(type: "Data", name: "Starc") }
+
+      it "does not raises error for root_less class" do
+        expect { ceramic.to_yaml }
+          .not_to raise_error(Lutaml::Model::NoRootMappingError)
+      end
     end
 
     it "correctly get the element of root-less class" do
@@ -251,6 +262,12 @@ RSpec.describe "Group" do
   end
 
   context "with model" do
+    before do
+      Lutaml::Model::GlobalRegister
+        .lookup(Lutaml::Model::Config.default_register)
+        .register_model(GroupSpec::GroupOfItems, id: :group_of_items)
+    end
+
     shared_examples "imports attributes from" do |source_class, target_class|
       it "#{source_class.name} correctly" do
         source_attributes = source_class.attributes
@@ -328,7 +345,7 @@ RSpec.describe "Group" do
     context "when update the imported attribute" do
       it "updates the attribute `mstyle` only in `Mrow`" do
         GroupSpec::Mrow.attributes[:mstyle].instance_variable_set(:@type, :integer)
-        expect(GroupSpec::Mrow.attributes[:mstyle].type).to eq(:integer)
+        expect(GroupSpec::Mrow.attributes[:mstyle].type).to eq(Lutaml::Model::Type::Integer)
       end
 
       it "maintains original type for the attribute `mstyle` in `Mfrac`" do
@@ -412,7 +429,7 @@ RSpec.describe "Group" do
       context "with sequence elements" do
         it "updates sequence elements only in `Mrow`" do
           sequence = GroupSpec::Mrow.mappings_for(:xml).element_sequence.first
-          sequence.attributes << Lutaml::Model::XmlMappingRule.new(
+          sequence.attributes << Lutaml::Model::Xml::MappingRule.new(
             "new_element",
             to: :new_element,
             namespace: "http://example.com",

data/spec/lutaml/model/hash/adapter_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+
+RSpec.describe "HashAdapter" do
+  before do
+    stub_const("HashMappingSpec", Module.new)
+
+    simple_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :active, :boolean
+
+      hsh do
+        map "name", to: :name
+        map "age", to: :age
+        map "is_active", to: :active
+      end
+    end
+
+    stub_const("HashMappingSpec::SimpleClass", simple_class)
+
+    nested_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :title, :string
+      attribute :simple, HashMappingSpec::SimpleClass
+      attribute :items, :string, collection: true
+
+      hsh do
+        map "title", to: :title
+        map "simple", to: :simple
+        map "items", to: :items
+      end
+    end
+
+    stub_const("HashMappingSpec::NestedClass", nested_class)
+
+    collection_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :simples, HashMappingSpec::SimpleClass, collection: true
+
+      hsh do
+        map "name", to: :name
+        map "simples", to: :simples
+      end
+    end
+
+    stub_const("HashMappingSpec::CollectionClass", collection_class)
+  end
+
+  describe "from_hash" do
+    context "with simple attributes" do
+      let(:parsed) do
+        HashMappingSpec::SimpleClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "name" => "John Doe",
+          "age" => 30,
+          "is_active" => true,
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::SimpleClass.new(
+          name: "John Doe",
+          age: 30,
+          active: true,
+        )
+      end
+
+      it "deserializes hash to object" do
+        expect(parsed).to eq(expected)
+      end
+    end
+
+    context "with nested objects" do
+      let(:parsed) do
+        HashMappingSpec::NestedClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "title" => "Test Title",
+          "simple" => {
+            "name" => "Jane Doe",
+            "age" => 25,
+            "is_active" => false,
+          },
+          "items" => ["item1", "item2", "item3"],
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::NestedClass.new(
+          title: "Test Title",
+          simple: HashMappingSpec::SimpleClass.new(
+            name: "Jane Doe",
+            age: 25,
+            active: false,
+          ),
+          items: ["item1", "item2", "item3"],
+        )
+      end
+
+      it "deserializes nested objects" do
+        expect(parsed).to eq(expected)
+      end
+    end
+
+    context "with collections of objects" do
+      let(:parsed) do
+        HashMappingSpec::CollectionClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "name" => "Collection",
+          "simples" => [
+            { "name" => "First", "age" => 10, "is_active" => true },
+            { "name" => "Second", "age" => 20, "is_active" => false },
+          ],
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::CollectionClass.new(
+          name: "Collection",
+          simples: [
+            HashMappingSpec::SimpleClass.new(
+              name: "First",
+              age: 10,
+              active: true,
+            ),
+            HashMappingSpec::SimpleClass.new(
+              name: "Second",
+              age: 20,
+              active: false,
+            ),
+          ],
+        )
+      end
+
+      it "deserializes collections of objects" do
+        expect(parsed).to eq(expected)
+      end
+    end
+  end
+
+  describe "to_hash" do
+    context "with simple attributes" do
+      let(:instance) do
+        HashMappingSpec::SimpleClass.new(
+          name: "John Doe",
+          age: 30,
+          active: true,
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "name" => "John Doe",
+          "age" => 30,
+          "is_active" => true,
+        }
+      end
+
+      it "serializes object to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+
+    context "with nested objects" do
+      let(:simple) do
+        HashMappingSpec::SimpleClass.new(
+          name: "Jane Doe",
+          age: 25,
+          active: false,
+        )
+      end
+
+      let(:instance) do
+        HashMappingSpec::NestedClass.new(
+          title: "Test Title",
+          simple: simple,
+          items: ["item1", "item2", "item3"],
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "title" => "Test Title",
+          "simple" => {
+            "name" => "Jane Doe",
+            "age" => 25,
+            "is_active" => false,
+          },
+          "items" => ["item1", "item2", "item3"],
+        }
+      end
+
+      it "serializes nested objects to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+
+    context "with collections of objects" do
+      let(:simples) do
+        [
+          HashMappingSpec::SimpleClass.new(name: "First", age: 10, active: true),
+          HashMappingSpec::SimpleClass.new(name: "Second", age: 20, active: false),
+        ]
+      end
+
+      let(:instance) do
+        HashMappingSpec::CollectionClass.new(
+          name: "Collection",
+          simples: simples,
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "name" => "Collection",
+          "simples" => [
+            { "name" => "First", "age" => 10, "is_active" => true },
+            { "name" => "Second", "age" => 20, "is_active" => false },
+          ],
+        }
+      end
+
+      it "serializes collections of objects to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+  end
+
+  describe "round-trip serialization" do
+    let(:original_hash) do
+      {
+        "name" => "Collection",
+        "simples" => [
+          { "name" => "First", "age" => 10, "is_active" => true },
+          { "name" => "Second", "age" => 20, "is_active" => false },
+        ],
+      }
+    end
+
+    let(:parsed) do
+      HashMappingSpec::CollectionClass.from_hash(original_hash)
+    end
+
+    it "maintains data integrity through serialization and deserialization" do
+      expect(parsed.to_hash).to eq(original_hash)
+    end
+  end
+end

data/spec/lutaml/model/json_adapter_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
-require "lutaml/model/json_adapter/standard_json_adapter"
-require "lutaml/model/json_adapter/multi_json_adapter"
+require "lutaml/model/json/standard_adapter"
+require "lutaml/model/json/multi_json_adapter"
 require_relative "../../fixtures/sample_model"
 
 RSpec.describe "JsonAdapter" do
@@ -9,9 +9,9 @@ RSpec.describe "JsonAdapter" do
     let(:model) { SampleModel.new(attributes) }
 
     let(:expected_json) do
-      if adapter_class == Lutaml::Model::JsonAdapter::StandardJsonAdapter
+      if adapter_class == Lutaml::Model::Json::StandardAdapter
         JSON.generate(attributes)
-      elsif adapter_class == Lutaml::Model::JsonAdapter::MultiJsonAdapter
+      elsif adapter_class == Lutaml::Model::Json::MultiJsonAdapter
         MultiJson.dump(attributes)
       end
     end
@@ -29,11 +29,11 @@ RSpec.describe "JsonAdapter" do
     end
   end
 
-  describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+  describe Lutaml::Model::Json::StandardAdapter do
     it_behaves_like "a JSON adapter", described_class
   end
 
-  describe Lutaml::Model::JsonAdapter::MultiJsonAdapter do
+  describe Lutaml::Model::Json::MultiJsonAdapter do
     it_behaves_like "a JSON adapter", described_class
   end
 end

data/spec/lutaml/model/jsonl/standard_adapter_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Jsonl::StandardAdapter do
+  let(:valid_jsonl_content) do
+    <<~JSONL
+      {"name": "John", "age": 30}
+      {"name": "Jane", "age": 25}
+      {"name": "Bob", "age": 35}
+    JSONL
+  end
+
+  let(:invalid_jsonl_content) do
+    <<~JSONL
+      {"name": "John", "age": 30}
+      invalid json
+      {"name": "Bob", "age": 35}
+    JSONL
+  end
+
+  describe ".parse" do
+    context "with valid JSONL content" do
+      it "parses each line as a JSON object" do
+        results = described_class.parse(valid_jsonl_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 JSONL content" do
+      it "skips invalid lines and continues parsing" do
+        results = described_class.parse(invalid_jsonl_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 lines" do
+      let(:jsonl_with_empty_lines) do
+        <<~JSONL
+          {"name": "John"}
+
+          {"name": "Jane"}
+        JSONL
+      end
+
+      it "skips empty lines" do
+        results = described_class.parse(jsonl_with_empty_lines)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+      end
+    end
+  end
+
+  describe "#to_jsonl" do
+    let(:adapter) { described_class.new([{ "name" => "John", "age" => 30 }]) }
+
+    it "generates JSONL format" do
+      expect(adapter.to_jsonl).to eq('{"name":"John","age":30}')
+    end
+
+    context "with multiple objects" do
+      let(:adapter) do
+        described_class.new([
+                              { "name" => "John", "age" => 30 },
+                              { "name" => "Jane", "age" => 25 },
+                            ])
+      end
+
+      let(:expected_jsonl) do
+        <<~JSONL.strip
+          {"name":"John","age":30}
+          {"name":"Jane","age":25}
+        JSONL
+      end
+
+      it "generates multiple lines" do
+        expect(adapter.to_jsonl).to eq(expected_jsonl)
+      end
+    end
+  end
+
+  describe "FORMAT_SYMBOL" do
+    it "returns :jsonl" do
+      expect(described_class::FORMAT_SYMBOL).to eq(:jsonl)
+    end
+  end
+end