lutaml-model 0.7.3 → 0.7.5

data/spec/lutaml/model/register/key_value_spec.rb

@@ -0,0 +1,275 @@
+require "spec_helper"
+
+module RegisterKeyValueSpec
+  class GeoCoordinate < Lutaml::Model::Serializable
+    attribute :latitude, :float
+    attribute :longitude, :float
+
+    json do
+      map :lat, to: :latitude
+      map :lng, to: :longitude
+    end
+  end
+
+  class Address < Lutaml::Model::Serializable
+    attribute :street, :string
+    attribute :city, :string
+    attribute :location, GeoCoordinate
+
+    json do
+      map :street, to: :street
+      map :city, to: :city
+      map :geo, to: :location
+    end
+  end
+
+  class ContactInfo < Lutaml::Model::Serializable
+    attribute :phone, :string
+    attribute :email, :string
+
+    json do
+      map :phoneNumber, to: :phone
+      map :email, to: :email
+    end
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :address, :address
+    attribute :contact, :contact_info
+    attribute :tags, :string, collection: true
+
+    json do
+      map :name, to: :name
+      map :age, to: :age
+      map :address, to: :address
+      map :contactInfo, to: :contact
+      map :tags, to: :tags
+    end
+  end
+
+  class EnhancedContactInfo < Lutaml::Model::Serializable
+    attribute :phone, :string
+    attribute :email, :string
+    attribute :preferred, :boolean
+
+    json do
+      map :phoneNumber, to: :phone
+      map :email, to: :email
+      map :isPrimary, to: :preferred
+    end
+  end
+end
+
+RSpec.describe "RegisterKeyValueSpec" do
+  let(:register) { Lutaml::Model::Register.new(:json_test_register) }
+  let(:person) { RegisterKeyValueSpec::Person.from_json(json, register: register) }
+
+  before do
+    # Register the registers in the global registry
+    Lutaml::Model::GlobalRegister.register(register)
+
+    # Register all the V1 model classes in the register
+    register.register_model_tree(RegisterKeyValueSpec::Person)
+    register.register_model(RegisterKeyValueSpec::Address)
+    register.register_model(RegisterKeyValueSpec::GeoCoordinate)
+    register.register_model(RegisterKeyValueSpec::ContactInfo)
+  end
+
+  describe "parsing JSON" do
+    let(:json) do
+      <<~JSON
+        {
+          "name": "John Doe",
+          "age": 30,
+          "address": {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "geo": {
+              "lat": 40.7128,
+              "lng": -74.0060
+            }
+          },
+          "contactInfo": {
+            "phoneNumber": "555-1234",
+            "email": "john@example.com"
+          },
+          "tags": ["developer", "musician"]
+        }
+      JSON
+    end
+
+    it "parses JSON into model objects" do
+      expect(person).to be_a(RegisterKeyValueSpec::Person)
+      expect(person.name).to eq("John Doe")
+      expect(person.age).to eq(30)
+      expect(person.address).to be_a(RegisterKeyValueSpec::Address)
+      expect(person.address.street).to eq("123 Main St")
+      expect(person.address.city).to eq("Anytown")
+      expect(person.address.location).to be_a(RegisterKeyValueSpec::GeoCoordinate)
+      expect(person.address.location.latitude).to eq(40.7128)
+      expect(person.address.location.longitude).to eq(-74.0060)
+      expect(person.contact).to be_a(RegisterKeyValueSpec::ContactInfo)
+      expect(person.contact.phone).to eq("555-1234")
+      expect(person.contact.email).to eq("john@example.com")
+      expect(person.tags).to eq(["developer", "musician"])
+    end
+
+    it "serializes model objects back to JSON" do
+      json_output = person.to_json
+      parsed_json = JSON.parse(json_output)
+
+      expect(parsed_json["name"]).to eq("John Doe")
+      expect(parsed_json["age"]).to eq(30)
+      expect(parsed_json["address"]["street"]).to eq("123 Main St")
+      expect(parsed_json["address"]["city"]).to eq("Anytown")
+      expect(parsed_json["address"]["geo"]["lat"]).to eq(40.7128)
+      expect(parsed_json["address"]["geo"]["lng"]).to eq(-74.0060)
+      expect(parsed_json["contactInfo"]["phoneNumber"]).to eq("555-1234")
+      expect(parsed_json["contactInfo"]["email"]).to eq("john@example.com")
+      expect(parsed_json["tags"]).to eq(["developer", "musician"])
+    end
+  end
+
+  describe "using global type substitution with JSON" do
+    let(:register_substitution) do
+      register.register_global_type_substitution(
+        from_type: RegisterKeyValueSpec::ContactInfo,
+        to_type: RegisterKeyValueSpec::EnhancedContactInfo,
+      )
+    end
+
+    let(:json) do
+      <<~JSON
+        {
+          "name": "Jane Smith",
+          "age": 28,
+          "address": {
+            "street": "456 Oak Ave",
+            "city": "Somewhere",
+            "geo": {
+              "lat": 37.7749,
+              "lng": -122.4194
+            }
+          },
+          "contactInfo": {
+            "phoneNumber": "555-5678",
+            "email": "jane@example.com",
+            "isPrimary": true
+          },
+          "tags": ["designer"]
+        }
+      JSON
+    end
+
+    context "when the substitute class is not registered" do
+      it "deserializes contactInfo using ContactInfo class" do
+        expect(person.contact).to be_a(RegisterKeyValueSpec::ContactInfo)
+        expect(person.contact).not_to respond_to(:preferred)
+        expect(person.contact.phone).to eq("555-5678")
+        expect(person.contact.email).to eq("jane@example.com")
+      end
+    end
+
+    context "when the substitute class is registered" do
+      it "deserializes contactInfo using EnhancedContactInfo class" do
+        register.register_model(RegisterKeyValueSpec::EnhancedContactInfo)
+        register_substitution
+
+        enhanced_person = RegisterKeyValueSpec::Person.from_json(json, register: register.id)
+
+        expect(enhanced_person.contact).to be_a(RegisterKeyValueSpec::EnhancedContactInfo)
+        expect(enhanced_person.contact).to respond_to(:preferred)
+        expect(enhanced_person.contact.phone).to eq("555-5678")
+        expect(enhanced_person.contact.email).to eq("jane@example.com")
+        expect(enhanced_person.contact.preferred).to be(true)
+
+        # Ensure serialization includes the new field
+        json_output = enhanced_person.to_json
+        parsed_json = JSON.parse(json_output)
+        expect(parsed_json["contactInfo"]["isPrimary"]).to be(true)
+      end
+    end
+  end
+
+  describe "handling complex nested JSON arrays" do
+    let(:complex_json) do
+      <<~JSON
+        {
+          "name": "Team Alpha",
+          "members": [
+            {
+              "name": "Alice",
+              "age": 32,
+              "address": {
+                "street": "789 Pine St",
+                "city": "Elsewhere"
+              }
+            },
+            {
+              "name": "Bob",
+              "age": 29,
+              "address": {
+                "street": "321 Elm St",
+                "city": "Nowhere"
+              }
+            }
+          ]
+        }
+      JSON
+    end
+
+    before do
+      stub_const("RegisterKeyValueSpec::Team", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :members, :person, collection: true
+
+        json do
+          map :name, to: :name
+          map :members, to: :members
+        end
+      end)
+
+      register.register_model(RegisterKeyValueSpec::Team)
+    end
+
+    it "correctly handles arrays of complex objects" do
+      team = RegisterKeyValueSpec::Team.from_json(complex_json, register: register)
+
+      expect(team.name).to eq("Team Alpha")
+      expect(team.members.size).to eq(2)
+      expect(team.members[0].name).to eq("Alice")
+      expect(team.members[0].age).to eq(32)
+      expect(team.members[0].address.street).to eq("789 Pine St")
+      expect(team.members[1].name).to eq("Bob")
+      expect(team.members[1].age).to eq(29)
+      expect(team.members[1].address.street).to eq("321 Elm St")
+
+      # Test round-trip serialization
+      toml_output = team.to_toml
+      team2 = RegisterKeyValueSpec::Team.from_toml(toml_output, register: register)
+
+      expect(team2).to eq(team)
+      expect(team2.members[0].name).to eq("Alice")
+      expect(team2.members[1].name).to eq("Bob")
+    end
+  end
+
+  describe "#resolve" do
+    before do
+      stub_const("RegisterKeyValueSpec::Team", Class.new(Lutaml::Model::Serializable))
+      register.register_model(RegisterKeyValueSpec::Team)
+    end
+
+    it "resolves a class" do
+      expect(register.resolve("RegisterKeyValueSpec::Team")).to eq(RegisterKeyValueSpec::Team)
+      expect(register.resolve(:"RegisterKeyValueSpec::Team")).to eq(RegisterKeyValueSpec::Team)
+      expect(register.resolve(RegisterKeyValueSpec::Team)).to eq(RegisterKeyValueSpec::Team)
+    end
+
+    it "returns nil for an unknown class" do
+      expect(register.resolve("UnknownClass")).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/register/xml_spec.rb

@@ -0,0 +1,187 @@
+require "spec_helper"
+
+module RegisterXmlSpec
+  class String < Lutaml::Model::Type::String
+    def to_xml
+      "custom_string: #{value}"
+    end
+  end
+
+  class Mi < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      root "mi"
+      namespace "http://www.w3.org/1998/Math/MathML"
+
+      map_content to: :value
+    end
+  end
+
+  # Define a MathML Operator element class
+  class Mo < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      root "mo"
+      namespace "http://www.w3.org/1998/Math/MathML"
+
+      map_content to: :value
+    end
+  end
+
+  # Define a MathML Fraction element
+  class Mfrac < Lutaml::Model::Serializable
+    attribute :numerator, :mo
+    attribute :denominator, :mi
+
+    xml do
+      root "mfrac"
+      namespace "http://www.w3.org/1998/Math/MathML"
+
+      map_element "mo", to: :numerator
+      map_element "mi", to: :denominator
+    end
+  end
+
+  # Define a full MathML expression
+  class Math < Lutaml::Model::Serializable
+    attribute :symbol, :mi
+    attribute :operator, :mo
+    attribute :fraction, :mfrac
+
+    xml do
+      root "math"
+      namespace "http://www.w3.org/1998/Math/MathML"
+
+      map_element "mi", to: :symbol
+      map_element "mo", to: :operator
+      map_element "mfrac", to: :fraction
+    end
+  end
+
+  class NewMi < Lutaml::Model::Serializable
+    attribute :value, :string
+    attribute :color, :string
+
+    xml do
+      root "mi"
+      namespace "http://www.w3.org/1998/Math/MathML"
+
+      map_content to: :value
+      map_attribute :color, to: :color
+    end
+  end
+end
+
+RSpec.describe "RegisterXmlSpec" do
+  let(:register) { Lutaml::Model::Register.new(:mathml_register) }
+  let(:formula) { RegisterXmlSpec::Math.from_xml(xml, register: register) }
+
+  before do
+    # Register the register in the global registry
+    Lutaml::Model::GlobalRegister.register(register)
+
+    # Register all the model classes
+    register.register_model_tree(RegisterXmlSpec::Math)
+    register.register_model(RegisterXmlSpec::Mi)
+    register.register_model(RegisterXmlSpec::Mo)
+    register.register_model(RegisterXmlSpec::Mfrac)
+  end
+
+  describe "parsing MathML XML" do
+    let(:xml) do
+      <<~XML
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <mi>x</mi>
+          <mo>=</mo>
+          <mfrac>
+            <mo>a</mo>
+            <mi>b</mi>
+          </mfrac>
+        </math>
+      XML
+    end
+
+    let(:instantiated) do
+      register.get_class(:math).new(
+        symbol: RegisterXmlSpec::Mi.new(value: "x"),
+        operator: RegisterXmlSpec::Mo.new(value: "="),
+        fraction: RegisterXmlSpec::Mfrac.new(
+          {
+            numerator: RegisterXmlSpec::Mo.new(value: "a"),
+            denominator: RegisterXmlSpec::Mi.new(value: "b"),
+          },
+          {
+            register: register,
+          },
+        ),
+      )
+    end
+
+    it "parses MathML XML into model objects" do
+      expect(formula).to be_a(RegisterXmlSpec::Math)
+      expect(formula.symbol.value).to eq("x")
+      expect(formula.operator.value).to eq("=")
+      expect(formula.fraction.numerator.value).to eq("a")
+      expect(formula.fraction.denominator.value).to eq("b")
+    end
+
+    it "serializes model objects back to MathML XML" do
+      expect(formula.to_xml).to be_equivalent_to(xml)
+    end
+
+    it "instantiates the model correctly" do
+      expect(instantiated.to_xml).to be_equivalent_to(xml)
+    end
+  end
+
+  describe "using global type substitution with MathML" do
+    let(:register_substitution) do
+      register.register_global_type_substitution(
+        from_type: RegisterXmlSpec::Mi,
+        to_type: RegisterXmlSpec::NewMi,
+      )
+      register.register_global_type_substitution(
+        from_type: Lutaml::Model::Type::String,
+        to_type: RegisterXmlSpec::String,
+      )
+    end
+
+    let(:xml) do
+      <<~XML
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <mi color="red">y</mi>
+        </math>
+      XML
+    end
+
+    let(:xml_type_substituted) do
+      <<~XML
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <mi color="custom_string: red">y</mi>
+        </math>
+      XML
+    end
+
+    context "when substitute class is not registered" do
+      it "serializes mi tag using Mi class" do
+        expect(formula.symbol).to be_a(RegisterXmlSpec::Mi)
+        expect(formula.symbol).not_to respond_to(:color)
+        expect(formula.symbol.value).to eq("y")
+        expect(formula.to_xml).not_to be_equivalent_to(xml)
+      end
+    end
+
+    context "when substitute class is registered" do
+      it "serializes mi tag using NewMi class" do
+        register_substitution
+        expect(formula.symbol).to be_a(RegisterXmlSpec::NewMi)
+        expect(formula.symbol).to respond_to(:color)
+        expect(formula.symbol.color).to eq("red")
+        expect(formula.symbol.value).to eq("y")
+        expect(formula.to_xml).to be_equivalent_to(xml_type_substituted)
+      end
+    end
+  end
+end

data/spec/lutaml/model/register_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+module RegisterSpec
+  class CustomString < Lutaml::Model::Type::String; end
+  class CustomInteger < Lutaml::Model::Type::Integer; end
+
+  Lutaml::Model::Type.register(:custom_string, CustomString)
+
+  class Address < Lutaml::Model::Serializable
+    attribute :location, :string
+    attribute :postal_code, :custom_string
+  end
+end
+
+RSpec.describe Lutaml::Model::Register do
+  describe "#initialize" do
+    it "initializes with id" do
+      register = described_class.new(:v1)
+      expect(register.id).to eq(:v1)
+      expect(register.models).to eq({})
+    end
+  end
+
+  describe "#register_model" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(RegisterSpec::CustomString, id: :custom_string)
+      v1_register.register_model(RegisterSpec::CustomInteger, id: :custom_integer)
+    end
+
+    it "registers model with explicit id" do
+      expect(v1_register.models[:custom_string]).to be_nil
+    end
+
+    it "allows overriding an existing type" do
+      v1_register.register_model(Lutaml::Model::Type::String, id: :custom_string)
+      expect(v1_register.models[:custom_string]).to be_nil
+    end
+
+    it "registers serializable class" do
+      v1_register.register_model(RegisterSpec::Address, id: :address)
+      expect(v1_register.models[:address]).to eq(RegisterSpec::Address)
+    end
+
+    it "registers model without explicit id" do
+      stub_const("TestModel", Class.new(Lutaml::Model::Serializable))
+      v1_register.register_model(TestModel)
+      expect(v1_register.models[:test_model]).to eq(TestModel)
+    end
+  end
+
+  describe "#resolve" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(RegisterSpec::Address, id: :address)
+    end
+
+    it "finds registered class by string representation" do
+      expect(v1_register.resolve("RegisterSpec::Address")).to eq(RegisterSpec::Address)
+    end
+
+    it "returns nil for unregistered class" do
+      expect(v1_register.resolve("UnknownClass")).to be_nil
+    end
+  end
+
+  describe "#get_class" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(Lutaml::Model::Type::String, id: :custom_type)
+    end
+
+    it "returns registered class by key" do
+      expect(v1_register.get_class(:custom_type)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class by string using constant lookup" do
+      expect(v1_register.get_class("String")).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class by symbol using Type.lookup" do
+      allow(Lutaml::Model::Type).to receive(:lookup).with(:String).and_return(Lutaml::Model::Type::String)
+      expect(v1_register.get_class(:String)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class directly if class is provided" do
+      expect(v1_register.get_class(Lutaml::Model::Type::String)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "raises error for unsupported type" do
+      expect { v1_register.get_class(123) }.to raise_error(Lutaml::Model::UnknownTypeError)
+    end
+  end
+
+  describe "#register_model_tree" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    context "when registering a valid model" do
+      let(:model_class) do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :nested_address, RegisterSpec::Address
+        end
+      end
+
+      it "registers the model and its nested attributes" do
+        v1_register.register_model_tree(model_class)
+        expect(v1_register.models.values).to include(model_class)
+        expect(v1_register.models.values).to include(RegisterSpec::Address)
+      end
+    end
+  end
+
+  describe "#register_global_type_substitution" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    it "registers a global type substitution" do
+      v1_register.register_global_type_substitution(from_type: :string, to_type: :text)
+      expect(v1_register.instance_variable_get(:@global_substitutions)).to include(string: :text)
+    end
+  end
+
+  describe "#register_attributes" do
+    let(:v1_register) { described_class.new(:v1) }
+    let(:model_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :nested_address, RegisterSpec::Address
+        attribute :string_attr, :string
+      end
+    end
+
+    it "registers non-builtin type attributes" do
+      attributes = model_class.attributes
+      v1_register.register_attributes(attributes)
+      expect(v1_register.models.values).to include(RegisterSpec::Address)
+    end
+
+    it "doesn't register built-in types" do
+      attributes = model_class.attributes
+      v1_register.register_attributes(attributes)
+      expect(v1_register.models.keys).not_to include(:string)
+    end
+  end
+end