lutaml-model 0.7.1 → 0.7.7

data/spec/lutaml/model/polymorphic_spec.rb

@@ -47,12 +47,63 @@ module PolymorphicSpec
       end
     end
 
+    module InvalidClasses
+      class AnchorReference < Lutaml::Model::Serializable
+        attribute :anchor_id, :string
+
+        xml do
+          map_element "anchor_id", to: :anchor_id
+        end
+
+        key_value do
+          map "anchor_id", to: :anchor_id
+        end
+      end
+
+      class DocumentReference < Reference
+        attribute :document_id, :string
+
+        xml do
+          map_element "document_id", to: :document_id
+        end
+
+        key_value do
+          map "document_id", to: :document_id
+        end
+      end
+    end
+
     class ReferenceSet < Lutaml::Model::Serializable
       attribute :references, Reference, collection: true, polymorphic: [
         DocumentReference,
         AnchorReference,
       ]
     end
+
+    class SimpleReferenceSet < Lutaml::Model::Serializable
+      attribute :references, Reference, collection: true, polymorphic: true
+
+      xml do
+        root "ReferenceSet"
+        map_element "references", to: :references, polymorphic: {
+          attribute: "reference-type",
+          class_map: {
+            "document-ref" => "PolymorphicSpec::Base::DocumentReference",
+            "anchor-ref" => "PolymorphicSpec::Base::AnchorReference",
+          },
+        }
+      end
+
+      key_value do
+        map "references", to: :references, polymorphic: {
+          attribute: "_class",
+          class_map: {
+            "Document" => "PolymorphicSpec::Base::DocumentReference",
+            "Anchor" => "PolymorphicSpec::Base::AnchorReference",
+          },
+        }
+      end
+    end
   end
 
   module Child
@@ -226,6 +277,133 @@ RSpec.describe "Polymorphic" do
     end
   end
 
+  context "when using polymorphic: true option" do
+    context "when key_value formats" do
+      let(:reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::DocumentReference.new(
+              _class: "Document",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::AnchorReference.new(
+              _class: "Anchor",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+
+      let(:invalid_reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::InvalidClasses::DocumentReference.new(
+              _class: "Document",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::InvalidClasses::AnchorReference.new(
+              _class: "Anchor",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+
+      let(:yaml) do
+        <<~YAML
+          ---
+          references:
+          - _class: Document
+            name: The Tibetan Book of the Dead
+            document_id: book:tbtd
+          - _class: Anchor
+            name: Chapter 1
+            anchor_id: book:tbtd:anchor-1
+        YAML
+      end
+
+      let(:parsed_yaml) do
+        PolymorphicSpec::Base::SimpleReferenceSet.from_yaml(yaml)
+      end
+
+      let(:error_message) do
+        "PolymorphicSpec::Base::InvalidClasses::AnchorReference is not " \
+          "valid sub class of PolymorphicSpec::Base::Reference"
+      end
+
+      it "deserializes correctly" do
+        expect(parsed_yaml).to eq(reference_set)
+      end
+
+      it "serializes correctly" do
+        expect(parsed_yaml.to_yaml).to eq(yaml)
+      end
+
+      it "raises error" do
+        expect do
+          invalid_reference_set.validate!
+        end.to raise_error(Lutaml::Model::ValidationError, error_message)
+      end
+    end
+
+    context "when XML format" do
+      let(:reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::DocumentReference.new(
+              _class: "document-ref",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::AnchorReference.new(
+              _class: "anchor-ref",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+      let(:xml) do
+        <<~XML
+          <ReferenceSet>
+            <references reference-type="document-ref">
+              <name>The Tibetan Book of the Dead</name>
+              <document_id>book:tbtd</document_id>
+            </references>
+            <references reference-type="anchor-ref">
+              <name>Chapter 1</name>
+              <anchor_id>book:tbtd:anchor-1</anchor_id>
+            </references>
+          </ReferenceSet>
+        XML
+      end
+
+      let(:parsed_xml) do
+        PolymorphicSpec::Base::SimpleReferenceSet.from_xml(xml)
+      end
+
+      it "deserializes correctly" do
+        expect(parsed_xml).to eq(reference_set)
+      end
+
+      it "serializes correctly" do
+        expect(parsed_xml.to_xml.strip).to be_equivalent_to(xml.strip)
+      end
+
+      it "does not raise error if polymorphic is set to true" do
+        expect { reference_set.validate! }.not_to raise_error
+      end
+
+      it "has empty errors array on validate" do
+        expect(reference_set.validate).to eq([])
+      end
+    end
+  end
+
   context "when defined in child class" do
     context "when key_value formats" do
       let(:reference_set) do

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,185 @@
+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