lutaml-model 0.3.23 → 0.3.25

data/spec/lutaml/model/key_value_mapping_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require_relative "../../../lib/lutaml/model/key_value_mapping"
+require_relative "../../../lib/lutaml/model/key_value_mapping_rule"
+
+RSpec.describe Lutaml::Model::KeyValueMapping do
+  let(:mapping) { described_class.new }
+
+  context "with delegate option" do
+    before do
+      mapping.map("type", to: :type, delegate: :some_delegate)
+      mapping.map("name", to: :name)
+    end
+
+    it "adds mappings with delegate option" do
+      expect(mapping.mappings.size).to eq(2)
+      expect(mapping.mappings[0].name).to eq("type")
+      expect(mapping.mappings[0].delegate).to eq(:some_delegate)
+      expect(mapping.mappings[1].name).to eq("name")
+      expect(mapping.mappings[1].delegate).to be_nil
+    end
+  end
+
+  describe "#deep_dup" do
+    before do
+      mapping.map(
+        "type",
+        to: :type,
+        render_nil: true,
+        delegate: :some_delegate,
+        child_mappings: {
+          id: :key,
+          path: %i[path link],
+          name: %i[path name],
+        },
+      )
+
+      mapping.map(
+        "name",
+        with: {
+          from: :model_from_json,
+          to: :json_from_model,
+        },
+      )
+    end
+
+    let(:dup_mapping) { mapping.deep_dup }
+
+    it "creates a deep duplicate" do
+      expect(dup_mapping.object_id).not_to eq(mapping.object_id)
+    end
+
+    it "correctly duplicates mapping with `to:`" do
+      m = mapping.mappings[0]
+      dup_m = dup_mapping.mappings[0]
+
+      expect(m.name).to eq(dup_m.name)
+      expect(m.name.object_id).not_to eq(dup_m.name.object_id)
+
+      # using symbols so object_id will remain same
+      expect(m.to).to eq(dup_m.to)
+
+      # render_nil is boolean so is constant with same object_id
+      expect(m.render_nil).to eq(dup_m.render_nil)
+
+      # using symbols so object_id will remain same
+      expect(m.delegate).to eq(dup_m.delegate)
+
+      expect(m.child_mappings).to eq(dup_m.child_mappings)
+      expect(m.child_mappings.object_id).not_to eq(dup_m.child_mappings.object_id)
+    end
+
+    it "correctly duplicates mapping with custom methods" do
+      m = mapping.mappings[0]
+      dup_m = dup_mapping.mappings[0]
+
+      expect(m.name).to eq(dup_m.name)
+      expect(m.name.object_id).not_to eq(dup_m.name.object_id)
+
+      # render_nil is boolean so is constant with same object_id
+      expect(m.render_nil).to eq(dup_m.render_nil)
+
+      expect(m.custom_methods).to eq(dup_m.custom_methods)
+      expect(m.custom_methods.object_id).not_to eq(dup_m.custom_methods.object_id)
+    end
+  end
+end

data/spec/lutaml/model/map_content_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "lutaml/model"
+
+# module MapContent
+#   class Italic < Lutaml::Model::Serializable
+#     attribute :text, Lutaml::Model::Type::String
+
+#     xml do
+#       root "italic"
+#       map_content to: :text
+#     end
+#   end
+
+#   class Bold < Lutaml::Model::Serializable
+#     attribute :text, Lutaml::Model::Type::String
+#     attribute :italic, Italic
+
+#     xml do
+#       root "b"
+#       mixed do
+#         map_content to: :text
+#         map "italic", to: :italic
+#       end
+#     end
+#   end
+
+#   class RichText < Lutaml::Model::Serializable
+#     attribute :text, Lutaml::Model::Type::String
+#     attribute :bold, Bold
+#     attribute :italic, Italic
+
+#     xml do
+#       mixed do
+#         map_content to: :text
+#         map_element "bold", to: :bold
+#         map_element "italic", to: :italic
+#       end
+#     end
+#   end
+
+#   class Car < Lutaml::Model::Serializable
+#     attribute :description, RichText
+#     attribute :make, Lutaml::Model::Type::String
+
+#     xml do
+#       root "car"
+#       map_element "description", to: :description
+#       map_element "make", to: :make
+#     end
+#   end
+# end
+
+# RSpec.xdescribe MapContent do
+#   let(:italic_text) { MapContent::Italic.new(text: "italic text") }
+#   let(:bold_text) do
+#     MapContent::Bold.new(
+#       text: "bold text",
+#       italic: italic_text,
+#     )
+#   end
+#   let(:rich_text) do
+#     MapContent::RichText.new(
+#       text: "regular text",
+#       bold: bold_text,
+#       italic: italic_text,
+#     )
+#   end
+#   let(:attributes) { { description: rich_text, make: "Toyota" } }
+#   let(:model) { MapContent::Car.new(attributes) }
+
+#   let(:model_xml) {
+#     <<~XML
+#       <car>
+#         <description>
+#           regular text
+#           <bold>
+#             bold text
+#             <italic>italic text</italic>
+#           </bold>
+#           <italic>italic text</italic>
+#         </description>
+#         <make>Toyota</make>
+#       </car>
+#     XML
+#   }
+
+#   it "initializes with default values" do
+#     default_model = Car.new
+#     expect(default_model.description).to eq(nil)
+#     expect(default_model.make).to eq(nil)
+#   end
+
+#   it "serializes to XML" do
+#     expected_xml = model_xml.strip
+#     expect(model.to_xml.strip).to eq(expected_xml)
+#   end
+
+#   it "deserializes from XML" do
+#     sample = Car.from_xml(model_xml)
+#     expect(sample.description.text).to eq("regular text")
+#     expect(sample.description.bold.text).to eq("bold text")
+#     expect(sample.description.bold.italic.text).to eq("italic text")
+#     expect(sample.description.italic.text).to eq("italic text")
+#     expect(sample.make).to eq("Toyota")
+#   end
+
+#   it "round-trips XML" do
+#     xml = model.to_xml
+#     new_model = Car.from_xml(xml)
+#     expect(new_model.description.text).to eq(model.description.text)
+#     expect(new_model.description.bold.text).to eq(model.description.bold.text)
+#     expect(new_model.description.bold.italic.text)
+#       .to eq(model.description.bold.italic.text)
+#     expect(new_model.description.italic.text)
+#       .to eq(model.description.italic.text)
+#     expect(new_model.make).to eq(model.make)
+#   end
+# end