lutaml-model 0.6.7 → 0.7.1

data/spec/lutaml/model/xml/xml_element_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XmlElement" do
+  describe "#text" do
+    context "when only text is present" do
+      let(:element) { create_element("name", text: "something") }
+
+      it "returns text" do
+        expect(element.text).to eq("something")
+      end
+    end
+
+    context "when single text node is present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("text", text: "John Doe"),
+          ],
+        )
+      end
+
+      it "returns single string" do
+        expect(element.text).to eq("John Doe")
+      end
+    end
+
+    context "when multiple text nodes are present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("text", text: "John"),
+            create_element("text", text: "\n"),
+            create_element("text", text: "Doe"),
+          ],
+        )
+      end
+
+      it "returns all text elements array" do
+        expect(element.text).to eq(["John", "\n", "Doe"])
+      end
+    end
+  end
+
+  describe "#cdata" do
+    context "when only cdata is present" do
+      let(:element) { create_element("name", text: "something") }
+
+      it "returns cdata" do
+        expect(element.cdata).to eq("something")
+      end
+    end
+
+    context "when single cdata node is present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("#cdata-section", text: "John Doe"),
+          ],
+        )
+      end
+
+      it "returns single string" do
+        expect(element.cdata).to eq("John Doe")
+      end
+    end
+
+    context "when multiple cdata nodes are present" do
+      let(:element) do
+        create_element(
+          "name",
+          children: [
+            create_element("#cdata-section", text: "John"),
+            create_element("#cdata-section", text: "\n"),
+            create_element("#cdata-section", text: "Doe"),
+          ],
+        )
+      end
+
+      it "returns all cdata elements array" do
+        expect(element.cdata).to eq(["John", "\n", "Doe"])
+      end
+    end
+  end
+
+  def create_element(name, attributes: {}, children: [], text: "")
+    Lutaml::Model::XmlAdapter::XmlElement.new(name, attributes, children, text)
+  end
+end

data/spec/lutaml/model/xml_mapping_rule_spec.rb

@@ -3,8 +3,6 @@ require "spec_helper"
 require "lutaml/model/xml_adapter/ox_adapter"
 require "lutaml/model/xml_adapter/oga_adapter"
 
-require_relative "../../../lib/lutaml/model/xml_mapping_rule"
-
 def content_to_xml(model, parent, doc)
   content = model.all_content.sub(/^<div>/, "").sub(/<\/div>$/, "")
   doc.add_xml_fragment(parent, content)
@@ -15,6 +13,108 @@ def content_from_xml(model, value)
 end
 
 RSpec.describe Lutaml::Model::XmlMappingRule do
+  describe "#namespaced_name" do
+    let(:namespaced_name) do
+      mapping_rule.namespaced_name
+    end
+
+    context "when attribute name is string 'lang'" do
+      let(:mapping_rule) do
+        described_class.new("lang", to: :lang, prefix: "xml")
+      end
+
+      it "returns `xml:lang`" do
+        expect(namespaced_name).to eq("xml:lang")
+      end
+    end
+
+    context "when attribute name is symbol ':lang'" do
+      let(:mapping_rule) do
+        described_class.new(:lang, to: :lang, prefix: "xml")
+      end
+
+      it "returns `xml:lang`" do
+        expect(namespaced_name).to eq("xml:lang")
+      end
+    end
+
+    context "when namespace is explicitly set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "explicit_namespace",
+          to: :explicit_namespace,
+          namespace: "http://test",
+          namespace_set: true,
+        )
+      end
+
+      it "returns `http://test:explicit_namespace`" do
+        expect(namespaced_name).to eq("http://test:explicit_namespace")
+      end
+    end
+
+    context "when namespace is explicitly set to nil" do
+      let(:mapping_rule) do
+        described_class.new(
+          "explicit_namespace",
+          to: :explicit_namespace,
+          namespace: nil,
+          namespace_set: true,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns name without namespace" do
+        expect(namespaced_name).to eq("explicit_namespace")
+      end
+    end
+
+    context "when attribute has namespace set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "attribute",
+          to: :attribute,
+          attribute: true,
+          namespace: "http://test",
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns `http://test:attribute`" do
+        expect(namespaced_name).to eq("http://test:attribute")
+      end
+    end
+
+    context "when attribute has no namespace set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "attribute",
+          to: :attribute,
+          attribute: true,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "does not use default namespace" do
+        expect(namespaced_name).to eq("attribute")
+      end
+    end
+
+    context "when default_namespace is set" do
+      let(:mapping_rule) do
+        described_class.new(
+          "default_namespace",
+          to: :default_namespace,
+          default_namespace: "http://default",
+        )
+      end
+
+      it "returns `default_namespace:name` if not an attribute" do
+        expect(namespaced_name).to eq("http://default:default_namespace")
+      end
+    end
+  end
+
   context "with Xml Mapping Rule" do
     let(:orig_mapping_rule) do
       described_class.new(

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -3,9 +3,6 @@ require "spec_helper"
 require "lutaml/model/xml_adapter/ox_adapter"
 require "lutaml/model/xml_adapter/oga_adapter"
 
-require_relative "../../../lib/lutaml/model/xml_mapping"
-require_relative "../../../lib/lutaml/model/xml_mapping_rule"
-
 # Define a sample class for testing map_content
 class Italic < Lutaml::Model::Serializable
   attribute :text, Lutaml::Model::Type::String, collection: true
@@ -445,6 +442,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       it "parse and serialize model correctly" do
         parsed = XmlMapping::OwnedComment.from_xml(xml_with_attribute)
+
         serialized = parsed.to_xml
 
         expect(serialized).to be_equivalent_to(xml_with_attribute)
@@ -1248,6 +1246,50 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
       end
     end
+
+    describe "validation errors" do
+      let(:mapping) { Lutaml::Model::XmlMapping.new }
+
+      it "raises error when neither :to nor :with provided" do
+        expect do
+          mapping.map_element("test")
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":to or :with argument is required for mapping 'test'",
+        )
+      end
+
+      it "raises error when :with is missing :to or :from keys" do
+        expect do
+          mapping.map_element("test", with: { to: "value" })
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":with argument for mapping 'test' requires :to and :from keys",
+        )
+      end
+
+      describe "map_attribute validations" do
+        it "raises error for invalid :with argument" do
+          expect do
+            mapping.map_attribute("test", with: { from: "value" })
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":with argument for mapping 'test' requires :to and :from keys",
+          )
+        end
+      end
+
+      describe "map_content validations" do
+        it "raises error when no :to provided" do
+          expect do
+            mapping.map_content
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":to or :with argument is required for mapping 'content'",
+          )
+        end
+      end
+    end
   end
 
   describe Lutaml::Model::XmlAdapter::NokogiriAdapter do

data/spec/sample_model_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require_relative "fixtures/sample_model"
 
 RSpec.describe SampleModel do
-  let(:model) { described_class.new(attributes) }
+  let(:model) { described_class.new(attributes, { omitted: :omitted }) }
   let(:attributes_yaml) do
     {
       "name" => "John Doe",
@@ -37,7 +37,7 @@ RSpec.describe SampleModel do
   end
 
   describe "default values" do
-    let(:model) { described_class.new }
+    let(:model) { described_class.new({}, { omitted: :omitted }) }
 
     it "sets default name" do
       expect(model.name).to eq("Anonymous")
@@ -52,7 +52,7 @@ RSpec.describe SampleModel do
     end
 
     it "sets default tags" do
-      expect(model.tags).to eq([])
+      expect(model.tags).to be_uninitialized
     end
 
     it "sets default preferences" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.7.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-24 00:00:00.000000000 Z
+date: 2025-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -76,6 +76,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/dependent-repos-todo.json"
 - ".github/workflows/dependent-repos.json"
 - ".github/workflows/dependent-tests.yml"
 - ".github/workflows/rake.yml"
@@ -116,6 +117,7 @@ files:
 - lib/lutaml/model/error/no_root_mapping_error.rb
 - lib/lutaml/model/error/no_root_namespace_error.rb
 - lib/lutaml/model/error/pattern_not_matched_error.rb
+- lib/lutaml/model/error/polymorphic_error.rb
 - lib/lutaml/model/error/type/invalid_value_error.rb
 - lib/lutaml/model/error/type_error.rb
 - lib/lutaml/model/error/type_not_enabled_error.rb
@@ -128,12 +130,18 @@ files:
 - lib/lutaml/model/json_adapter/json_object.rb
 - lib/lutaml/model/json_adapter/multi_json_adapter.rb
 - lib/lutaml/model/json_adapter/standard_json_adapter.rb
-- lib/lutaml/model/key_value_mapping.rb
-- lib/lutaml/model/key_value_mapping_rule.rb
 - lib/lutaml/model/liquefiable.rb
 - lib/lutaml/model/loggable.rb
+- lib/lutaml/model/mapping.rb
+- lib/lutaml/model/mapping/json_mapping.rb
+- lib/lutaml/model/mapping/key_value_mapping.rb
+- lib/lutaml/model/mapping/key_value_mapping_rule.rb
+- lib/lutaml/model/mapping/mapping_rule.rb
+- lib/lutaml/model/mapping/toml_mapping.rb
+- lib/lutaml/model/mapping/xml_mapping.rb
+- lib/lutaml/model/mapping/xml_mapping_rule.rb
+- lib/lutaml/model/mapping/yaml_mapping.rb
 - lib/lutaml/model/mapping_hash.rb
-- lib/lutaml/model/mapping_rule.rb
 - lib/lutaml/model/schema.rb
 - lib/lutaml/model/schema/json_schema.rb
 - lib/lutaml/model/schema/json_schema_parser.rb
@@ -163,6 +171,7 @@ files:
 - lib/lutaml/model/type/time.rb
 - lib/lutaml/model/type/time_without_date.rb
 - lib/lutaml/model/type/value.rb
+- lib/lutaml/model/uninitialized_class.rb
 - lib/lutaml/model/utils.rb
 - lib/lutaml/model/validation.rb
 - lib/lutaml/model/version.rb
@@ -180,8 +189,6 @@ files:
 - lib/lutaml/model/xml_adapter/xml_document.rb
 - lib/lutaml/model/xml_adapter/xml_element.rb
 - lib/lutaml/model/xml_adapter/xml_namespace.rb
-- lib/lutaml/model/xml_mapping.rb
-- lib/lutaml/model/xml_mapping_rule.rb
 - lib/lutaml/model/yaml_adapter.rb
 - lib/lutaml/model/yaml_adapter/standard_yaml_adapter.rb
 - lib/lutaml/model/yaml_adapter/yaml_document.rb
@@ -230,6 +237,8 @@ files:
 - spec/lutaml/model/multiple_mapping_spec.rb
 - spec/lutaml/model/namespace_spec.rb
 - spec/lutaml/model/ordered_content_spec.rb
+- spec/lutaml/model/polymorphic_spec.rb
+- spec/lutaml/model/render_empty_spec.rb
 - spec/lutaml/model/render_nil_spec.rb
 - spec/lutaml/model/root_mappings_spec.rb
 - spec/lutaml/model/schema/json_schema_spec.rb
@@ -256,8 +265,11 @@ files:
 - spec/lutaml/model/type_spec.rb
 - spec/lutaml/model/utils_spec.rb
 - spec/lutaml/model/validation_spec.rb
+- spec/lutaml/model/value_map_spec.rb
 - spec/lutaml/model/with_child_mapping_spec.rb
 - spec/lutaml/model/xml/derived_attributes_spec.rb
+- spec/lutaml/model/xml/namespace/nested_with_explicit_namespace_spec.rb
+- spec/lutaml/model/xml/xml_element_spec.rb
 - spec/lutaml/model/xml_adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/model/xml_adapter/oga_adapter_spec.rb
 - spec/lutaml/model/xml_adapter/ox_adapter_spec.rb
@@ -290,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: LutaML creating data models in Ruby

data/lib/lutaml/model/mapping_rule.rb

@@ -1,109 +0,0 @@
-module Lutaml
-  module Model
-    class MappingRule
-      attr_reader :name,
-                  :to,
-                  :render_nil,
-                  :render_default,
-                  :attribute,
-                  :custom_methods,
-                  :delegate,
-                  :transform
-
-      def initialize(
-        name,
-        to:,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        attribute: false,
-        delegate: nil,
-        root_mappings: nil,
-        transform: {}
-      )
-        @name = name
-        @to = to
-        @render_nil = render_nil
-        @render_default = render_default
-        @custom_methods = with
-        @attribute = attribute
-        @delegate = delegate
-        @root_mappings = root_mappings
-        @transform = transform
-      end
-
-      alias from name
-      alias render_nil? render_nil
-      alias render_default? render_default
-      alias attribute? attribute
-
-      def render?(value)
-        render_nil? || (!value.nil? && !Utils.empty_collection?(value))
-      end
-
-      def serialize_attribute(model, element, doc)
-        if custom_methods[:to]
-          model.send(custom_methods[:to], model, element, doc)
-        end
-      end
-
-      def to_value_for(model)
-        if delegate
-          model.public_send(delegate).public_send(to)
-        else
-          return if to.nil?
-
-          model.public_send(to)
-        end
-      end
-
-      def serialize(model, parent = nil, doc = nil)
-        if custom_methods[:to]
-          model.send(custom_methods[:to], model, parent, doc)
-        else
-          to_value_for(model)
-        end
-      end
-
-      def deserialize(model, value, attributes, mapper_class = nil)
-        if custom_methods[:from]
-          mapper_class.new.send(custom_methods[:from], model, value) unless value.nil?
-        elsif delegate
-          if model.public_send(delegate).nil?
-            model.public_send(:"#{delegate}=", attributes[delegate].type.new)
-          end
-
-          model.public_send(delegate).public_send(:"#{to}=", value)
-        elsif transform_method = transform[:import] || attributes[to].transform_import_method
-          model.public_send(:"#{to}=", transform_method.call(value))
-        else
-          model.public_send(:"#{to}=", value)
-        end
-      end
-
-      def using_custom_methods?
-        !custom_methods.empty?
-      end
-
-      def multiple_mappings?
-        name.is_a?(Array)
-      end
-
-      def raw_mapping?
-        name == Constants::RAW_MAPPING_KEY
-      end
-
-      def eql?(other)
-        other.class == self.class &&
-          instance_variables.all? do |var|
-            instance_variable_get(var) == other.instance_variable_get(var)
-          end
-      end
-      alias == eql?
-
-      def deep_dup
-        raise NotImplementedError, "Subclasses must implement `deep_dup`."
-      end
-    end
-  end
-end