lutaml-model 0.3.23 → 0.3.25

data/spec/lutaml/model/custom_model_spec.rb

@@ -0,0 +1,410 @@
+require "spec_helper"
+
+class CustomModelChild
+  attr_accessor :street, :city
+end
+
+class CustomModelParent
+  attr_accessor :first_name, :middle_name, :last_name, :child_mapper
+
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+class CustomModelChildMapper < Lutaml::Model::Serializable
+  model CustomModelChild
+
+  attribute :street, Lutaml::Model::Type::String
+  attribute :city, Lutaml::Model::Type::String
+
+  xml do
+    map_element :street, to: :street
+    map_element :city, to: :city
+  end
+end
+
+class CustomModelParentMapper < Lutaml::Model::Serializable
+  model CustomModelParent
+
+  attribute :first_name, Lutaml::Model::Type::String
+  attribute :middle_name, Lutaml::Model::Type::String
+  attribute :last_name, Lutaml::Model::Type::String
+  attribute :child_mapper, CustomModelChildMapper
+
+  xml do
+    map_element :first_name, to: :first_name
+    map_element :middle_name, to: :middle_name
+    map_element :last_name, to: :last_name
+    map_element :CustomModelChild,
+                with: { to: :child_to_xml, from: :child_from_xml }
+  end
+
+  def child_to_xml(model, parent, doc)
+    child_el = doc.create_element("CustomModelChild")
+    street_el = doc.create_element("street")
+    city_el = doc.create_element("city")
+
+    doc.add_text(street_el, model.child_mapper.street)
+    doc.add_text(city_el, model.child_mapper.city)
+
+    doc.add_element(child_el, street_el)
+    doc.add_element(child_el, city_el)
+    doc.add_element(parent, child_el)
+  end
+
+  def child_from_xml(model, value)
+    model.child_mapper ||= CustomModelChild.new
+
+    model.child_mapper.street = value["street"].text
+    model.child_mapper.city = value["city"].text
+  end
+end
+
+module CustomModelSpecs
+  class TextElement < Lutaml::Model::Serializable
+    attribute :sup, :string
+    attribute :sub, :string
+    attribute :text, :string
+
+    xml do
+      root "text-element"
+
+      map_content to: :text
+
+      map_element "sup", to: :sup
+      map_element "sub", to: :sub
+    end
+  end
+
+  class Id
+    attr_accessor :id
+  end
+
+  class Docid < Lutaml::Model::Serializable
+    model Id
+    attribute :id, TextElement
+
+    xml do
+      root "docid", mixed: true
+
+      map_content to: :text, delegate: :id
+      map_element :sub, to: :sub, delegate: :id
+      map_element :sup, to: :sup, delegate: :id
+    end
+  end
+
+  class BibliographicItem
+    attr_accessor :type, :title, :schema_version, :language
+
+    def initialize(**attr)
+      @type = attr["type"]
+      @title = attr["title"]
+      @schema_version = attr["schema_version"]
+      @language = attr["language"]
+    end
+  end
+
+  class Bibdata < Lutaml::Model::Serializable
+    model BibliographicItem
+  end
+
+  class MixedWithNestedContent < Lutaml::Model::Serializable
+    attribute :street, :string, raw: true
+    attribute :city, :string, raw: true
+    attribute :bibdata, Bibdata
+
+    xml do
+      root "MixedWithNestedContent", mixed: true
+
+      map_element "street", to: :street
+      map_element "city", to: :city
+      map_element "bibdata",
+                  to: :bibdata,
+                  with: { from: :bibdata_from_xml, to: :bibdata_to_xml }
+    end
+
+    def bibdata_from_xml(model, value)
+      model.bibdata = BibliographicItem.new(
+        "type" => value["type"],
+        "title" => value["title"],
+        "language" => value["title"]["language"],
+        "schema_version" => value["schema-version"],
+      )
+    end
+
+    def bibdata_to_xml(model, _parent, doc)
+      attributes = {
+        "type" => model.bibdata.type,
+        "schema-version" => model.bibdata.schema_version,
+      }
+      lang = model.bibdata.language
+
+      doc.create_and_add_element("bibdata", attributes: attributes) do
+        doc.create_and_add_element("title", attributes: { language: lang }) do
+          doc.add_text(doc, model.bibdata.title.text)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe "CustomModel" do
+  let(:parent_mapper) { CustomModelParentMapper }
+  let(:child_mapper) { CustomModelChildMapper }
+  let(:parent_model) { CustomModelParent }
+  let(:child_model) { CustomModelChild }
+
+  context "with JSON mapping" do
+    let(:input_json) do
+      {
+        first_name: "John",
+        last_name: "Doe",
+        child_mapper: {
+          street: "Oxford Street",
+          city: "London",
+        },
+      }.to_json
+    end
+
+    describe ".from_json" do
+      it "maps JSON string to custom model" do
+        instance = parent_mapper.from_json(input_json)
+
+        expect(instance.class).to eq(parent_model)
+        expect(instance.first_name).to eq("John")
+        expect(instance.last_name).to eq("Doe")
+        expect(instance.name).to eq("John Doe")
+
+        expect(instance.child_mapper.class).to eq(child_model)
+        expect(instance.child_mapper.street).to eq("Oxford Street")
+        expect(instance.child_mapper.city).to eq("London")
+      end
+    end
+
+    describe ".to_json" do
+      it "with wrong model raises an exception" do
+        msg = /argument is a 'String' but should be a '#{parent_model.name}/
+
+        expect do
+          parent_mapper.to_json("")
+        end.to raise_error(Lutaml::Model::IncorrectModelError, msg)
+      end
+
+      it "with correct model converts objects to json" do
+        instance = parent_mapper.from_json(input_json)
+
+        expect(parent_mapper.to_json(instance)).to eq(input_json)
+      end
+    end
+  end
+
+  context "with YAML mapping" do
+    let(:input_yaml) do
+      {
+        "first_name" => "John",
+        "last_name" => "Doe",
+        "child_mapper" => {
+          "street" => "Oxford Street",
+          "city" => "London",
+        },
+      }.to_yaml
+    end
+
+    describe ".from_yaml" do
+      it "maps YAML to custom model" do
+        instance = parent_mapper.from_yaml(input_yaml)
+
+        expect(instance.class).to eq(parent_model)
+        expect(instance.first_name).to eq("John")
+        expect(instance.last_name).to eq("Doe")
+        expect(instance.name).to eq("John Doe")
+
+        expect(instance.child_mapper.class).to eq(child_model)
+        expect(instance.child_mapper.street).to eq("Oxford Street")
+        expect(instance.child_mapper.city).to eq("London")
+      end
+    end
+
+    describe ".to_yaml" do
+      it "with wrong model raises an exception" do
+        msg = /argument is a 'String' but should be a '#{parent_model.name}/
+
+        expect do
+          parent_mapper.to_yaml("")
+        end.to raise_error(Lutaml::Model::IncorrectModelError, msg)
+      end
+
+      it "with correct model converts objects to yaml" do
+        instance = parent_mapper.from_yaml(input_yaml)
+
+        expect(parent_mapper.to_yaml(instance)).to eq(input_yaml)
+      end
+    end
+  end
+
+  context "with TOML mapping" do
+    let(:input_toml) do
+      <<~TOML
+        first_name = "John"
+        last_name = "Doe"
+        [child_mapper]
+        city = "London"
+        street = "Oxford Street"
+      TOML
+    end
+
+    describe ".from_toml" do
+      it "maps TOML content to custom model" do
+        instance = parent_mapper.from_toml(input_toml)
+
+        expect(instance.class).to eq(parent_model)
+        expect(instance.first_name).to eq("John")
+        expect(instance.last_name).to eq("Doe")
+        expect(instance.name).to eq("John Doe")
+
+        expect(instance.child_mapper.class).to eq(child_model)
+        expect(instance.child_mapper.street).to eq("Oxford Street")
+        expect(instance.child_mapper.city).to eq("London")
+      end
+    end
+
+    describe ".to_toml" do
+      it "with wrong model raises an exception" do
+        msg = /argument is a 'String' but should be a '#{parent_model.name}/
+
+        expect do
+          parent_mapper.to_toml("")
+        end.to raise_error(Lutaml::Model::IncorrectModelError, msg)
+      end
+
+      it "with correct model converts objects to toml" do
+        instance = parent_mapper.from_toml(input_toml)
+
+        expect(parent_mapper.to_toml(instance)).to eq(input_toml)
+      end
+    end
+  end
+
+  context "with XML mapping" do
+    let(:input_xml) do
+      <<~XML
+        <CustomModelParent>
+          <first_name>John</first_name>
+          <last_name>Doe</last_name>
+          <CustomModelChild>
+            <street>Oxford Street</street>
+            <city>London</city>
+          </CustomModelChild>
+        </CustomModelParent>
+      XML
+    end
+
+    describe ".from_xml" do
+      it "maps XML content to custom model using custom methods" do
+        instance = parent_mapper.from_xml(input_xml)
+
+        expect(instance.class).to eq(parent_model)
+        expect(instance.first_name).to eq("John")
+        expect(instance.last_name).to eq("Doe")
+        expect(instance.name).to eq("John Doe")
+
+        expect(instance.child_mapper.class).to eq(child_model)
+        expect(instance.child_mapper.street).to eq("Oxford Street")
+        expect(instance.child_mapper.city).to eq("London")
+      end
+    end
+
+    describe ".to_xml" do
+      it "with wrong model raises an exception" do
+        msg = /argument is a 'String' but should be a '#{parent_model.name}/
+
+        expect do
+          parent_mapper.to_xml("")
+        end.to raise_error(Lutaml::Model::IncorrectModelError, msg)
+      end
+
+      it "with correct model converts objects to xml using custom methods" do
+        instance = parent_mapper.from_xml(input_xml)
+        result_xml = parent_mapper.to_xml(instance)
+
+        expect(result_xml.gsub(/\s+/, "")).to eq(input_xml.gsub(/\s+/, ""))
+      end
+    end
+
+    describe "custom serialization methods" do
+      it "uses custom to_xml method for child_mapper" do
+        instance = parent_model.new
+        instance.first_name = "John"
+        instance.last_name = "Doe"
+        instance.child_mapper = child_model.new
+        instance.child_mapper.street = "Custom Street"
+        instance.child_mapper.city = "Custom City"
+
+        result_xml = parent_mapper.to_xml(instance)
+        expect(result_xml).to include("<CustomModelChild>")
+        expect(result_xml).to include("<street>Custom Street</street>")
+        expect(result_xml).to include("<city>Custom City</city>")
+      end
+
+      it "uses custom from_xml method for child_mapper" do
+        custom_xml = <<~XML
+          <CustomModelParent>
+            <first_name>Jane</first_name>
+            <last_name>Smith</last_name>
+            <CustomModelChild>
+              <street>Custom Avenue</street>
+              <city>New City</city>
+            </CustomModelChild>
+          </CustomModelParent>
+        XML
+
+        instance = parent_mapper.from_xml(custom_xml)
+        expect(instance.child_mapper.street).to eq("Custom Avenue")
+        expect(instance.child_mapper.city).to eq("New City")
+      end
+
+      it "uses delegate to for child mapper class" do
+        xml = "<docid>Str<sub>2</sub>text<sup>1</sup>123</docid>"
+
+        docid = CustomModelSpecs::Docid.from_xml(xml)
+
+        expect(CustomModelSpecs::Docid.to_xml(docid)).to eq(xml)
+      end
+    end
+
+    describe "custom methods with custom model" do
+      it "uses delegate to for child mapper class" do
+        xml = <<~XML
+          <MixedWithNestedContent>
+            <street>
+              A <p>b</p> B <p>c</p> C
+            </street>
+            <bibdata type="collection" schema-version="v1.2.8">
+              <title language="en">
+                JCGM Collection 1
+              </title>
+            </bibdata>
+          </MixedWithNestedContent>
+        XML
+
+        expected_xml = <<~XML
+          <MixedWithNestedContent>
+            <street>
+              A &lt;p&gt;b&lt;/p&gt; B &lt;p&gt;c&lt;/p&gt; C
+            </street>
+            <bibdata type="collection" schema-version="v1.2.8">
+              <title language="en">
+                JCGM Collection 1
+              </title>
+            </bibdata>
+          </MixedWithNestedContent>
+        XML
+
+        bibdata = CustomModelSpecs::MixedWithNestedContent.from_xml(xml)
+
+        expect(bibdata.to_xml).to be_equivalent_to(expected_xml)
+      end
+    end
+  end
+end

data/spec/lutaml/model/custom_serialization_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+require "lutaml/model"
+
+class CustomSerialization < Lutaml::Model::Serializable
+  attribute :full_name, :string
+  attribute :size, :integer
+  attribute :color, :string
+  attribute :description, :string
+
+  json do
+    map "name", with: { to: :name_to_json, from: :name_from_json }
+    map "color", with: { to: :color_to_json, from: :color_from_json }
+    map "size", with: { to: :size_to_json, from: :size_from_json }
+    map "description",
+        with: { to: :description_to_json, from: :description_from_json }
+  end
+
+  xml do
+    root "CustomSerialization"
+
+    # name, color are used to test XML elements with custom methods
+    map_element "Name", with: { to: :name_to_xml, from: :name_from_xml }
+    map_element "Color", with: { to: :color_to_xml, from: :color_from_xml }
+
+    # size is used to test XML attribute with custom methods
+    map_attribute "Size", with: { to: :size_to_xml, from: :size_from_xml }
+
+    # description is used to test XML textual content
+    map_content with: { to: :description_to_xml, from: :description_from_xml }
+  end
+
+  def name_to_json(model, doc)
+    doc["name"] = "JSON Masterpiece: #{model.full_name}"
+  end
+
+  def name_from_json(model, value)
+    model.full_name = value.sub(/^JSON Masterpiece: /, "")
+  end
+
+  def size_to_json(model, doc)
+    doc["size"] = model.size + 3
+  end
+
+  def size_from_json(model, value)
+    model.size = value - 3
+  end
+
+  def color_to_json(model, doc)
+    doc["color"] = model.color.upcase
+  end
+
+  def color_from_json(model, value)
+    model.color = value.downcase
+  end
+
+  def description_to_json(model, doc)
+    doc["description"] = "JSON Description: #{model.description}"
+  end
+
+  def description_from_json(model, value)
+    model.description = value.sub(/^JSON Description: /, "")
+  end
+
+  def name_to_xml(model, parent, doc)
+    el = doc.create_element("Name")
+    doc.add_text(el, "XML Masterpiece: #{model.full_name}")
+    doc.add_element(parent, el)
+  end
+
+  def name_from_xml(model, value)
+    model.full_name = value.sub(/^XML Masterpiece: /, "")
+  end
+
+  def size_to_xml(model, parent, doc)
+    doc.add_attribute(parent, "Size", model.size + 3)
+  end
+
+  def size_from_xml(model, value)
+    model.size = value.to_i - 3
+  end
+
+  def color_to_xml(model, parent, doc)
+    color_element = doc.create_element("Color")
+    doc.add_text(color_element, model.color.upcase)
+    doc.add_element(parent, color_element)
+  end
+
+  def color_from_xml(model, value)
+    model.color = value.downcase
+  end
+
+  def description_to_xml(model, parent, doc)
+    doc.add_text(parent, "XML Description: #{model.description}")
+  end
+
+  def description_from_xml(model, value)
+    model.description = value.join.strip.sub(/^XML Description: /, "")
+  end
+end
+
+RSpec.describe CustomSerialization do
+  let(:attributes) do
+    {
+      full_name: "Vase",
+      size: 12,
+      color: "blue",
+      description: "A beautiful ceramic vase",
+    }
+  end
+  let(:model) { described_class.new(attributes) }
+
+  context "with JSON serialization" do
+    it "serializes to JSON with custom methods" do
+      expected_json = {
+        name: "JSON Masterpiece: Vase",
+        color: "BLUE",
+        size: 15,
+        description: "JSON Description: A beautiful ceramic vase",
+      }.to_json
+
+      expect(model.to_json).to eq(expected_json)
+    end
+
+    it "deserializes from JSON with custom methods" do
+      json = {
+        name: "JSON Masterpiece: Vase",
+        color: "BLUE",
+        size: 15,
+        description: "JSON Description: A beautiful ceramic vase",
+      }.to_json
+
+      ceramic = described_class.from_json(json)
+
+      expect(ceramic.full_name).to eq(model.full_name)
+      expect(ceramic.size).to eq(model.size)
+      expect(ceramic.color).to eq(model.color)
+      expect(ceramic.description).to eq(model.description)
+    end
+  end
+
+  context "with XML serialization" do
+    it "serializes to XML with custom methods" do
+      expected_xml = <<~XML
+        <CustomSerialization Size="15">
+          <Name>XML Masterpiece: Vase</Name>
+          <Color>BLUE</Color>
+          XML Description: A beautiful ceramic vase
+        </CustomSerialization>
+      XML
+
+      expect(model.to_xml).to be_equivalent_to(expected_xml)
+    end
+
+    it "deserializes from XML with custom methods" do
+      xml = <<~XML
+        <CustomSerialization Size="15">
+          <Name>XML Masterpiece: Vase</Name>
+          <Color>BLUE</Color>
+          XML Description: A beautiful ceramic vase
+        </CustomSerialization>
+      XML
+
+      ceramic = described_class.from_xml(xml)
+      expect(ceramic.full_name).to eq(model.full_name)
+      expect(ceramic.size).to eq(model.size)
+      expect(ceramic.color).to eq(model.color)
+      expect(ceramic.description).to eq(model.description)
+    end
+  end
+end