lutaml-model 0.7.3 → 0.7.5

data/spec/lutaml/model/custom_model_spec.rb

@@ -1,11 +1,19 @@
 require "spec_helper"
 
 class CustomModelChild
-  attr_accessor :street, :city
+  attr_accessor :street, :city, :register
+
+  def initialize(register = nil)
+    @register = register
+  end
 end
 
 class CustomModelParent
-  attr_accessor :first_name, :middle_name, :last_name, :child_mapper, :math
+  attr_accessor :first_name, :middle_name, :last_name, :child_mapper, :math, :register
+
+  def initialize(register = nil)
+    @register = register
+  end
 
   def name
     "#{first_name} #{last_name}"
@@ -13,7 +21,11 @@ class CustomModelParent
 end
 
 class GenericFormulaClass
-  attr_accessor :value
+  attr_accessor :value, :register
+
+  def initialize(register = nil)
+    @register = register
+  end
 end
 
 class Mi < Lutaml::Model::Serializable

data/spec/lutaml/model/defaults_spec.rb

@@ -108,7 +108,11 @@ module DefaultsSpec
 
   # Class for testing render_default: true with custom model
   class Lang
-    attr_accessor :lang, :content
+    attr_accessor :lang, :content, :register
+
+    def initialize(register = nil)
+      @register = register
+    end
   end
 
   class CustomModelWithDefaultValue < Lutaml::Model::Serializable

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
@@ -262,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
@@ -339,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

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

data/spec/lutaml/model/jsonl_spec.rb

@@ -0,0 +1,229 @@
+require "spec_helper"
+
+module JsonlSpec
+  class Address < Lutaml::Model::Serializable
+    attribute :city, :string
+
+    json do
+      map "city", to: :city
+    end
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :address, Address
+
+    json do
+      map "full_name", to: :name
+      map "age", to: :age
+      map "address", to: :address
+    end
+  end
+
+  class Directory < Lutaml::Model::Collection
+    instances :persons, Person
+
+    jsonl do
+      map_instances to: :persons
+    end
+  end
+end
+
+RSpec.describe "Jsonl" do
+  let(:john) do
+    JsonlSpec::Person.new(
+      {
+        name: "John",
+        age: "30",
+        address: JsonlSpec::Address.new({ city: "New York" }),
+      },
+    )
+  end
+
+  let(:jane) do
+    JsonlSpec::Person.new(
+      {
+        name: "Jane",
+        age: "25",
+        address: JsonlSpec::Address.new({ city: "London" }),
+      },
+    )
+  end
+
+  let(:bob) do
+    JsonlSpec::Person.new(
+      {
+        name: "Bob",
+        age: "35",
+        address: JsonlSpec::Address.new({ city: "Paris" }),
+      },
+    )
+  end
+
+  let(:valid_jsonl) do
+    <<~JSONL.strip
+      {"full_name":"John","age":30,"address":{"city":"New York"}}
+      {"full_name":"Jane","age":25,"address":{"city":"London"}}
+      {"full_name":"Bob","age":35,"address":{"city":"Paris"}}
+    JSONL
+  end
+
+  let(:valid_jsonl_with_empty_lines) do
+    <<~JSONL
+      {"full_name":"John","age":30,"address":{"city":"New York"}}
+
+      {"full_name":"Jane","age":25,"address":{"city":"London"}}
+
+
+      {"full_name":"Bob","age":35,"address":{"city":"Paris"}}
+
+
+    JSONL
+  end
+
+  let(:invalid_jsonl_content) do
+    <<~JSONL
+      {"full_name": "John", "age": 30, "address": {"city": "New York"}}
+      invalid json
+      {"full_name": "Bob", "age": 35, "address": {"city": "Paris"}}
+    JSONL
+  end
+
+  let(:parsed) { JsonlSpec::Directory.from_jsonl(valid_jsonl) }
+
+  it "parses all the json lines" do
+    expect(parsed.persons).to eq([john, jane, bob])
+  end
+
+  it "handles empty lines" do
+    expect(
+      JsonlSpec::Directory.from_jsonl(valid_jsonl_with_empty_lines).persons,
+    ).to eq([john, jane, bob])
+  end
+
+  it "round trips valid jsonl correctly" do
+    expect(parsed.to_jsonl).to eq(valid_jsonl)
+  end
+
+  it "removes empty line when round triping valid jsonl" do
+    expect(
+      JsonlSpec::Directory.from_jsonl(valid_jsonl_with_empty_lines).to_jsonl,
+    ).to eq(valid_jsonl)
+  end
+
+  it "skips invalid lines and show warning" do
+    expect do
+      JsonlSpec::Directory.from_jsonl(invalid_jsonl_content)
+    end.to output(/Skipping invalid line: unexpected character: /).to_stderr
+  end
+
+  describe "parsing" do
+    it "handles empty lines" do
+      jsonl_with_empty_lines = <<~JSONL
+        {"name": "John", "age": 30, "address": {"city": "New York"}}
+
+        {"name": "Jane", "age": 25, "address": {"city": "London"}}
+      JSONL
+      result = JsonlSpec::Directory.from_jsonl(jsonl_with_empty_lines)
+      expect(result.persons).to be_an(Array)
+      expect(result.persons.length).to eq(2)
+    end
+  end
+
+  describe "roundtrip" do
+    it "maintains data integrity with special characters" do
+      special_chars_jsonl = <<~JSONL
+        {"full_name": "John Doe", "age": 30, "address": {"city": "New York"}}
+        {"full_name": "Jane \\"Smith\\"", "age": 25, "address": {"city": "London"}}
+      JSONL
+
+      # Parse the original JSONL
+      directory = JsonlSpec::Directory.from_jsonl(special_chars_jsonl)
+
+      # Serialize back to JSONL
+      serialized = directory.to_jsonl
+
+      # Parse the serialized data again
+      roundtrip_directory = JsonlSpec::Directory.from_jsonl(serialized)
+
+      # Compare the results
+      expect(roundtrip_directory.persons.length).to eq(directory.persons.length)
+      roundtrip_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+  end
+
+  describe "format conversion" do
+    let(:valid_jsonl_content) do
+      <<~JSONL.strip
+        {"full_name":"John","age":30,"address":{"city":"New York"}}
+        {"full_name":"Jane","age":25,"address":{"city":"London"}}
+        {"full_name":"Bob","age":35,"address":{"city":"Paris"}}
+      JSONL
+    end
+
+    it "converts between JSONL and JSON" do
+      # Parse JSONL to Directory
+      directory = JsonlSpec::Directory.from_jsonl(valid_jsonl_content)
+
+      # Convert to JSON
+      json_string = directory.to_json
+
+      # Parse JSON back to Directory
+      json_directory = JsonlSpec::Directory.from_json(json_string)
+
+      # Convert back to JSONL
+      jsonl_output = json_directory.to_jsonl
+
+      # Final parse to verify
+      final_directory = JsonlSpec::Directory.from_jsonl(jsonl_output)
+
+      # Compare the results
+      expect(final_directory.persons.length).to eq(directory.persons.length)
+      final_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+
+    it "handles collections of objects" do
+      # Create a directory with people
+      directory = JsonlSpec::Directory.new(
+        [
+          JsonlSpec::Person.new(
+            name: "John",
+            age: 30,
+            address: JsonlSpec::Address.new(city: "New York"),
+          ),
+          JsonlSpec::Person.new(
+            name: "Jane",
+            age: 25,
+            address: JsonlSpec::Address.new(city: "London"),
+          ),
+        ],
+      )
+
+      # Convert to JSONL
+      jsonl_output = directory.to_jsonl
+
+      # Parse back to verify
+      parsed_directory = JsonlSpec::Directory.from_jsonl(jsonl_output)
+
+      # Compare the results
+      expect(parsed_directory.persons.length).to eq(directory.persons.length)
+      parsed_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+  end
+end

data/spec/lutaml/model/multiple_mapping_spec.rb

@@ -126,7 +126,7 @@ module MultipleMapping
     end
 
     def size_from_xml(model, values)
-      model.size = (values.first.text.to_i || 0) - 10
+      model.size = values.first.text.to_i - 10
     end
 
     def desc_to_xml(model, parent, doc)