lutaml-model 0.3.25 → 0.3.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 923c122ff4459f02c1949dc88ee8df94b93db6ce23c00c9da2159f6b376da3a0
-  data.tar.gz: aa537363d67a5383cdbd280cfa9ddee0a3c5de0cb151b79b2e195a030bc0061d
+  metadata.gz: 1dc709174fab4f4df2214f08b536e0b1aded39f0c9f48a18eb5a4a53da3fc4b6
+  data.tar.gz: 9eea83160b8210f84d4b2f9baf2ab577ca91d2a737eaf98b175d52385e6fb5d3
 SHA512:
-  metadata.gz: a0da4f4a87c8fe4a3951d302df5797594675f83616ea52b4582f417683d4f55076c57ad3d6f3018119c0a6021497bf6832b150ebf695d1fa8d4304da2040b641
-  data.tar.gz: 0d4d6d783728b53d453c23e2cfcfcd08d9eac83d94b4652d3bdee95c19d9d9bf68e233dea6d29d9478d4214271dd800be93b8f8e11a59cf9f9cd46d744dd2002
+  metadata.gz: 1e75326adeb9b8804f1bcc99104707edc3656e870d16c8af22e07e32ead9f4d78cd87eb372ebb834f2a5d942d58819e0fd3800e23a8099cf951360765223cd25
+  data.tar.gz: ecc145fb2d9250cf855243c7b9cf468919f2530eed03039bd6c7a521fa534327a1a67c5348237b3d5959e20fa0fc2b2cadc87e57139f451610cd2d7d695f251b

data/.rubocop_todo.yml

@@ -73,7 +73,7 @@ Metrics/MethodLength:
 # Offense count: 7
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
-  Max: 13
+  Max: 14
 
 # Offense count: 23
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.

data/README.adoc

@@ -543,8 +543,15 @@ end
 ====
 
 
+=== Attribute value validation
+
+==== General
+
+There are several mechanisms to validate attribute values in Lutaml::Model.
+
+
 [[attribute-enumeration]]
-=== Attribute as an enumeration
+==== Values of an enumeration
 
 An attribute can be defined as an enumeration by using the `values` directive.
 
@@ -641,6 +648,44 @@ acceptance of the newly updated component.
 ====
 
 
+==== String values restricted to patterns
+
+An attribute that accepts a string value accepts value validation using regular
+expressions.
+
+Syntax:
+
+[source,ruby]
+----
+attribute :name_of_attribute, :string, pattern: /regex/
+----
+
+.Using the `pattern` option to restrict the value of an attribute
+[example]
+====
+In this example, the `color` attribute takes hex color values such as `#ccddee`.
+
+A regular expression can be used to validate values assigned to the attribute.
+In this case, it is `/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/`.
+
+[source,ruby]
+----
+class Glaze < Lutaml::Model::Serializable
+  attribute :color, :string, pattern: /\A#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})\z/
+end
+----
+
+[source,ruby]
+----
+> Glaze.new(color: '#ff0000').color
+> # "#ff0000"
+> Glaze.new(color: '#ff000').color
+> # Lutaml::Model::InvalidValueError: Invalid value for attribute 'color'
+----
+====
+
+
+
 === Attribute value default and rendering defaults
 
 Specify default values for attributes using the `default` option.
@@ -771,7 +816,8 @@ class Person < Lutaml::Model::Serializable
 end
 ----
 
-For the following xml
+For the following XML snippet:
+
 [source,xml]
 ----
 <Person>
@@ -1144,6 +1190,80 @@ end
 ====
 
 
+==== CDATA nodes
+
+CDATA is an XML feature that allows the inclusion of text that may contain
+characters that are unescaped in XML.
+
+While CDATA is not preferred in XML, it is sometimes necessary to handle CDATA
+nodes for both input and output.
+
+NOTE: The W3C XML Recommendation explicitly encourages escaping characters over
+usage of CDATA.
+
+Lutaml::Model supports the handling of CDATA nodes in XML in the following
+behavior:
+
+. When an attribute contains a CDATA node with no text:
+** On reading: The node (CDATA or text) is read as its value.
+** On writing: The value is written as its native type.
+
+. When an XML mapping sets `cdata: true` on `map_element` or `map_content`:
+** On reading: The node (CDATA or text) is read as its value.
+** On writing: The value is written as a CDATA node.
+
+. When an XML mapping sets `cdata: false` on `map_element` or `map_content`:
+** On reading: The node (CDATA or text) is read as its value.
+** On writing: The value is written as a text node (string).
+
+
+Syntax:
+
+[source,ruby]
+----
+xml do
+  map_content to: :name_of_attribute, cdata: (true | false)
+  map_element :name, to: :name, cdata: (true | false)
+end
+----
+
+.Using `cdata` to map CDATA content
+[example]
+====
+The following class will parse the XML snippet below:
+
+[source,ruby]
+----
+class Example < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :description, :string
+  attribute :title, :string
+  attribute :note, :string
+
+  xml do
+    root 'example'
+    map_element :name, to: :name, cdata: true
+    map_content to: :description, cdata: true
+    map_element :title, to: :title, cdata: false
+    map_element :note, to: :note, cdata: false
+  end
+end
+----
+
+[source,xml]
+----
+<example><name><![CDATA[John]]></name><![CDATA[here is the description]]><title><![CDATA[Lutaml]]></title><note>Careful</note></example>
+----
+
+[source,ruby]
+----
+> Example.from_xml(xml)
+> #<Example:0x0000000104ac7240 @name="John" @description="here is the description" @title="Lutaml" @note="Careful">
+> Example.new(name: "John", description: "here is the description", title: "Lutaml", note: "Careful").to_xml
+> #<example><name><![CDATA[John]]></name><![CDATA[here is the description]]><title>Lutaml</title><note>Careful</note></example>
+----
+====
+
 
 ==== Example for mapping
 

data/lib/lutaml/model/attribute.rb

@@ -9,6 +9,7 @@ module Lutaml
         delegate
         collection
         values
+        pattern
       ].freeze
 
       def initialize(name, type, options = {})
@@ -87,23 +88,12 @@ module Lutaml
         cast_value(value)
       end
 
-      def enum_values
-        @options.key?(:values) ? @options[:values] : []
+      def pattern
+        options[:pattern]
       end
 
-      # Check if the value to be assigned is valid for the attribute
-      #
-      # Currently there are 2 validations
-      #   1. Value should be from the values list if they are defined
-      #      e.g values: ["foo", "bar"] is set then any other value for this
-      #          attribute will raise `Lutaml::Model::InvalidValueError`
-      #
-      #   2. Value count should be between the collection range if defined
-      #      e.g if collection: 0..5 is set then the value greater then 5
-      #          will raise `Lutaml::Model::CollectionCountOutOfRangeError`
-      def validate_value!(value)
-        valid_value!(value)
-        valid_collection!(value)
+      def enum_values
+        @options.key?(:values) ? @options[:values] : []
       end
 
       def valid_value!(value)
@@ -123,14 +113,32 @@ module Lutaml
         options[:values].include?(value)
       end
 
-      def validate_value!(value)
-        # return true if none of the validations are present
-        return true if enum_values.empty? && singular?
+      def valid_pattern!(value)
+        return true unless type == Lutaml::Model::Type::String
+        return true unless pattern
+
+        unless pattern.match?(value)
+          raise Lutaml::Model::PatternNotMatchedError.new(name, pattern, value)
+        end
 
+        true
+      end
+
+      # Check if the value to be assigned is valid for the attribute
+      #
+      # Currently there are 2 validations
+      #   1. Value should be from the values list if they are defined
+      #      e.g values: ["foo", "bar"] is set then any other value for this
+      #          attribute will raise `Lutaml::Model::InvalidValueError`
+      #
+      #   2. Value count should be between the collection range if defined
+      #      e.g if collection: 0..5 is set then the value greater then 5
+      #          will raise `Lutaml::Model::CollectionCountOutOfRangeError`
+      def validate_value!(value)
         # Use the default value if the value is nil
         value = default if value.nil?
 
-        valid_value!(value) && valid_collection!(value)
+        valid_value!(value) && valid_collection!(value) && valid_pattern!(value)
       end
 
       def validate_collection_range
@@ -229,6 +237,13 @@ module Lutaml
           raise StandardError,
                 "Invalid options given for `#{name}` #{invalid_opts}"
         end
+
+        if options.key?(:pattern) && type != Lutaml::Model::Type::String
+          raise StandardError,
+                "Invalid option `pattern` given for `#{name}`, `pattern` is only allowed for :string type"
+        end
+
+        true
       end
 
       def validate_type!(type)

data/lib/lutaml/model/error/pattern_not_matched_error.rb

@@ -0,0 +1,17 @@
+module Lutaml
+  module Model
+    class PatternNotMatchedError < Error
+      def initialize(attr_name, pattern, value)
+        @attr_name = attr_name
+        @pattern = pattern
+        @value = value
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name}: \"#{@value}\" does not match #{@pattern.inspect}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -7,6 +7,7 @@ end
 
 require_relative "error/invalid_value_error"
 require_relative "error/incorrect_mapping_argument_error"
+require_relative "error/pattern_not_matched_error"
 require_relative "error/unknown_adapter_type_error"
 require_relative "error/collection_count_out_of_range_error"
 require_relative "error/validation_error"

data/lib/lutaml/model/mapping_hash.rb

@@ -28,6 +28,14 @@ module Lutaml
         @item_order = order
       end
 
+      def text
+        self["#cdata-section"] || self["text"]
+      end
+
+      def text?
+        key?("#cdata-section") || key?("text")
+      end
+
       def ordered?
         @ordered
       end

data/lib/lutaml/model/serialize.rb

@@ -343,7 +343,7 @@ module Lutaml
             value = if rule.raw_mapping?
                       doc.node.inner_xml
                     elsif rule.content_mapping?
-                      doc["text"]
+                      doc[rule.content_key]
                     elsif doc.key_exist?(rule.namespaced_name(options[:default_namespace]))
                       doc.fetch(rule.namespaced_name(options[:default_namespace]))
                     else
@@ -399,12 +399,12 @@ module Lutaml
 
           value = if value.is_a?(Array)
                     value.map do |v|
-                      text_hash?(attr, v) ? v["text"] : v
+                      text_hash?(attr, v) ? v.text : v
                     end
                   elsif attr&.raw? && value
                     value.node.children.map(&:to_xml).join
                   elsif text_hash?(attr, value)
-                    value["text"]
+                    value.text
                   else
                     value
                   end
@@ -428,7 +428,7 @@ module Lutaml
 
         def text_hash?(attr, value)
           return false unless value.is_a?(Hash)
-          return value.keys == ["text"] unless attr
+          return value.one? && value.text? unless attr
 
           !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
         end

data/lib/lutaml/model/validation.rb

@@ -8,7 +8,8 @@ module Lutaml
           begin
             attr.validate_value!(value)
           rescue Lutaml::Model::InvalidValueError,
-                 Lutaml::Model::CollectionCountOutOfRangeError => e
+                 Lutaml::Model::CollectionCountOutOfRangeError,
+                 PatternNotMatchedError => e
             errors << e
           end
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.25"
+    VERSION = "0.3.26"
   end
 end

data/lib/lutaml/model/xml_adapter/builder/nokogiri.rb

@@ -51,7 +51,9 @@ module Lutaml
             end
           end
 
-          def add_text(element, text)
+          def add_text(element, text, cdata: false)
+            return add_cdata(element, text) if cdata
+
             if element.is_a?(self.class)
               element = element.xml.parent
             end
@@ -60,6 +62,10 @@ module Lutaml
             element.add_child(text_node)
           end
 
+          def add_cdata(element, value)
+            element.cdata(value)
+          end
+
           def add_namespace_prefix(prefix)
             xml[prefix] if prefix
 

data/lib/lutaml/model/xml_adapter/builder/ox.rb

@@ -66,10 +66,16 @@ module Lutaml
             xml.text(text)
           end
 
-          def add_text(element, text)
+          def add_text(element, text, cdata: false)
+            return element.cdata(text) if cdata
+
             element << text
           end
 
+          def add_cdata(element, value)
+            element.cdata(value)
+          end
+
           # Add XML namespace to document
           #
           # Ox doesn't support XML namespaces so we only save the

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -74,10 +74,12 @@ module Lutaml
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
+                next if element_rule.cdata && name == "text"
+
                 text = xml_mapping.content_mapping.serialize(element)
                 text = text[curr_index] if text.is_a?(Array)
 
-                next prefixed_xml.text(text) if element.mixed?
+                next prefixed_xml.add_text(xml, text, cdata: element_rule.cdata) if element.mixed?
 
                 content << text
               elsif !value.nil? || element_rule.render_nil?

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -56,15 +56,15 @@ module Lutaml
                                                        mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
+              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && name == "text"
+
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
-                if element.mixed?
-                  el.add_text(el, text)
-                else
-                  content << text
-                end
+                next el.add_text(el, text, cdata: element_rule.cdata) if element.mixed?
+
+                content << text
               elsif !value.nil? || element_rule.render_nil?
                 value = value[curr_index] if attribute_def.collection?
 
@@ -88,10 +88,13 @@ module Lutaml
 
       class OxElement < XmlElement
         def initialize(node, root_node: nil)
-          if node.is_a?(String)
+          case node
+          when String
             super("text", {}, [], node, parent_document: root_node)
-          elsif node.is_a?(Ox::Comment)
+          when Ox::Comment
             super("comment", {}, [], node.value, parent_document: root_node)
+          when Ox::CData
+            super("#cdata-section", {}, [], node.value, parent_document: root_node)
           else
             namespace_attributes(node.attributes).each do |(name, value)|
               if root_node

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -152,16 +152,16 @@ module Lutaml
             )
           elsif rule.prefix_set?
             xml.create_and_add_element(rule.name, prefix: prefix) do
-              add_value(xml, value, attribute)
+              add_value(xml, value, attribute, cdata: rule.cdata)
             end
           else
             xml.create_and_add_element(rule.name) do
-              add_value(xml, value, attribute)
+              add_value(xml, value, attribute, cdata: rule.cdata)
             end
           end
         end
 
-        def add_value(xml, value, attribute)
+        def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
             serialized_value = attribute.type.serialize(value)
 
@@ -172,7 +172,7 @@ module Lutaml
                 end
               end
             else
-              xml.add_text(xml, serialized_value)
+              xml.add_text(xml, serialized_value, cdata: cdata)
             end
           end
         end
@@ -244,7 +244,7 @@ module Lutaml
           value = attribute_value_for(element, rule)
           return unless render_element?(rule, element, value)
 
-          xml.add_text(xml, value)
+          xml.add_text(xml, value, cdata: rule.cdata)
         end
 
         def process_content_mapping(element, content_rule, xml)
@@ -261,7 +261,7 @@ module Lutaml
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
 
-            xml.add_text(xml, text)
+            xml.add_text(xml, text, cdata: content_rule.cdata)
           end
         end
 

data/lib/lutaml/model/xml_mapping.rb

@@ -47,6 +47,7 @@ module Lutaml
         render_default: false,
         with: {},
         delegate: nil,
+        cdata: false,
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
@@ -61,6 +62,7 @@ module Lutaml
           render_default: render_default,
           with: with,
           delegate: delegate,
+          cdata: cdata,
           namespace: namespace,
           default_namespace: namespace_uri,
           prefix: prefix,
@@ -109,7 +111,8 @@ module Lutaml
         render_default: false,
         with: {},
         delegate: nil,
-        mixed: false
+        mixed: false,
+        cdata: false
       )
         validate!("content", to, with)
 
@@ -121,6 +124,7 @@ module Lutaml
           with: with,
           delegate: delegate,
           mixed_content: mixed,
+          cdata: cdata,
         )
       end
 
@@ -211,7 +215,7 @@ module Lutaml
       end
 
       def find_by_name(name)
-        if name.to_s == "text"
+        if ["text", "#cdata-section"].include?(name.to_s)
           content_mapping
         else
           mappings.detect do |rule|

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -3,7 +3,7 @@ require_relative "mapping_rule"
 module Lutaml
   module Model
     class XmlMappingRule < MappingRule
-      attr_reader :namespace, :prefix, :mixed_content, :default_namespace
+      attr_reader :namespace, :prefix, :mixed_content, :default_namespace, :cdata
 
       def initialize(
         name,
@@ -15,6 +15,7 @@ module Lutaml
         namespace: nil,
         prefix: nil,
         mixed_content: false,
+        cdata: false,
         namespace_set: false,
         prefix_set: false,
         attribute: false,
@@ -38,6 +39,7 @@ module Lutaml
                      end
         @prefix = prefix
         @mixed_content = mixed_content
+        @cdata = cdata
 
         @default_namespace = default_namespace
 
@@ -61,6 +63,10 @@ module Lutaml
         name == "__raw_mapping"
       end
 
+      def content_key
+        cdata ? "#cdata-section" : "text"
+      end
+
       def mixed_content?
         !!@mixed_content
       end

data/spec/lutaml/model/attribute_spec.rb

@@ -33,6 +33,33 @@ RSpec.describe Lutaml::Model::Attribute do
       .to("avatar.png")
   end
 
+  describe "#validate_options!" do
+    let(:validate_options) { name_attr.method(:validate_options!) }
+
+    Lutaml::Model::Attribute::ALLOWED_OPTIONS.each do |option|
+      it "return true if option is `#{option}`" do
+        expect(validate_options.call({ option => "value" })).to be(true)
+      end
+    end
+
+    it "raise exception if option is not allowed" do
+      expect do
+        validate_options.call({ foo: "bar" })
+      end.to raise_error(StandardError, "Invalid options given for `name` [:foo]")
+    end
+
+    it "raise exception if pattern is given with non string type" do
+      age_attr = described_class.new("age", :integer)
+
+      expect do
+        age_attr.send(:validate_options!, { pattern: /[A-Za-z ]/ })
+      end.to raise_error(
+        StandardError,
+        "Invalid option `pattern` given for `age`, `pattern` is only allowed for :string type",
+      )
+    end
+  end
+
   describe "#validate_type!" do
     let(:validate_type) { name_attr.method(:validate_type!) }
 

data/spec/lutaml/model/cdata_spec.rb

@@ -0,0 +1,520 @@
+require "spec_helper"
+require "lutaml/model"
+require "lutaml/model/xml_adapter/nokogiri_adapter"
+require "lutaml/model/xml_adapter/ox_adapter"
+
+module CDATA
+  class Beta < Lutaml::Model::Serializable
+    attribute :element1, :string
+
+    xml do
+      root "beta"
+      map_content to: :element1, cdata: true
+    end
+  end
+
+  class Alpha < Lutaml::Model::Serializable
+    attribute :element1, :string
+    attribute :element2, :string
+    attribute :element3, :string
+    attribute :beta, Beta
+
+    xml do
+      root "alpha"
+
+      map_element "element1", to: :element1, cdata: false
+      map_element "element2", to: :element2, cdata: true
+      map_element "element3", to: :element3, cdata: false
+      map_element "beta", to: :beta
+    end
+  end
+
+  class Address < Lutaml::Model::Serializable
+    attribute :street, :string
+    attribute :city, :string
+    attribute :house, :string
+    attribute :address, Address
+
+    xml do
+      root "address"
+      map_element "street", to: :street
+      map_element "city", with: { from: :city_from_xml, to: :city_to_xml }, cdata: true
+      map_element "house", with: { from: :house_from_xml, to: :house_to_xml }, cdata: false
+      map_element "address", to: :address
+    end
+
+    def house_from_xml(model, node)
+      model.house = node
+    end
+
+    def house_to_xml(model, _parent, doc)
+      doc.create_and_add_element("house") do |element|
+        element.add_text(element, model.house, cdata: false)
+      end
+    end
+
+    def city_from_xml(model, node)
+      model.city = node
+    end
+
+    def city_to_xml(model, _parent, doc)
+      doc.create_and_add_element("city") do |element|
+        element.add_text(element, model.city, cdata: true)
+      end
+    end
+  end
+
+  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, cdata: true
+      map_element :city, to: :city, cdata: true
+    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
+      root "CustomModelParent"
+      map_element :first_name, to: :first_name, cdata: true
+      map_element :middle_name, to: :middle_name, cdata: true
+      map_element :last_name, to: :last_name, cdata: false
+      map_element :CustomModelChild, with: { to: :child_to_xml, from: :child_from_xml }, cdata: true
+    end
+
+    def child_to_xml(model, _parent, doc)
+      doc.create_and_add_element("CustomModelChild") do |child_el|
+        child_el.create_and_add_element("street") do |street_el|
+          street_el.add_text(street_el, model.child_mapper.street, cdata: true)
+        end
+        child_el.create_and_add_element("city") do |city_el|
+          city_el.add_text(city_el, model.child_mapper.city, cdata: true)
+        end
+      end
+    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
+
+  class RootMixedContent < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :bold, :string, collection: true
+    attribute :italic, :string, collection: true
+    attribute :underline, :string
+    attribute :content, :string
+
+    xml do
+      root "RootMixedContent", mixed: true
+      map_attribute :id, to: :id
+      map_element :bold, to: :bold, cdata: true
+      map_element :italic, to: :italic, cdata: true
+      map_element :underline, to: :underline, cdata: true
+      map_content to: :content, cdata: true
+    end
+  end
+
+  class RootMixedContentNested < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :data, :string
+    attribute :content, RootMixedContent
+    attribute :sup, :string, collection: true
+    attribute :sub, :string, collection: true
+
+    xml do
+      root "RootMixedContentNested", mixed: true
+      map_content to: :data, cdata: true
+      map_attribute :id, to: :id
+      map_element :sup, to: :sup, cdata: true
+      map_element :sub, to: :sub, cdata: false
+      map_element "MixedContent", to: :content
+    end
+  end
+
+  class DefaultValue < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "Default Value" }
+    attribute :temperature, :integer, default: -> { 1050 }
+    attribute :opacity, :string, default: -> { "Opaque" }
+    attribute :content, :string, default: -> { " " }
+
+    xml do
+      root "DefaultValue"
+      map_element "name", to: :name, render_default: true, cdata: true
+      map_element "temperature", to: :temperature, render_default: true, cdata: true
+      map_element "opacity", to: :opacity, cdata: false, render_default: true
+      map_content to: :content, cdata: true, render_default: true
+    end
+  end
+end
+
+RSpec.describe "CDATA" do
+  let(:parent_mapper) { CDATA::CustomModelParentMapper }
+  let(:child_mapper) { CDATA::CustomModelChildMapper }
+  let(:parent_model) { CDATA::CustomModelParent }
+  let(:child_model) { CDATA::CustomModelChild }
+
+  shared_examples "cdata behavior" do |adapter_class|
+    around do |example|
+      old_adapter = Lutaml::Model::Config.xml_adapter
+      Lutaml::Model::Config.xml_adapter = adapter_class
+      example.run
+    ensure
+      Lutaml::Model::Config.xml_adapter = old_adapter
+    end
+
+    context "with CDATA option" do
+      let(:xml) do
+        <<~XML.strip
+          <alpha>
+            <element1><![CDATA[foo]]></element1>
+            <element2><![CDATA[one]]></element2>
+            <element2><![CDATA[two]]></element2>
+            <element2><![CDATA[three]]></element2>
+            <element3>bar</element3>
+            <beta><![CDATA[child]]></beta>
+          </alpha>
+        XML
+      end
+
+      let(:expected_xml) do
+        <<~XML.strip
+          <alpha>
+            <element1>foo</element1>
+            <element2>
+              <![CDATA[one]]>
+            </element2>
+            <element2>
+              <![CDATA[two]]>
+            </element2>
+            <element2>
+              <![CDATA[three]]>
+            </element2>
+            <element3>bar</element3>
+            <beta>
+              <![CDATA[child]]>
+            </beta>
+          </alpha>
+        XML
+      end
+
+      it "maps xml to object" do
+        instance = CDATA::Alpha.from_xml(xml)
+
+        expect(instance.element1).to eq("foo")
+        expect(instance.element2).to eq(%w[one two three])
+        expect(instance.element3).to eq("bar")
+        expect(instance.beta.element1).to eq("child")
+      end
+
+      it "converts objects to xml" do
+        instance = CDATA::Alpha.new(
+          element1: "foo",
+          element2: %w[one two three],
+          element3: "bar",
+          beta: CDATA::Beta.new(element1: "child"),
+        )
+
+        expect(instance.to_xml).to be_equivalent_to(expected_xml)
+      end
+    end
+
+    context "with custom methods" do
+      let(:xml) do
+        <<~XML
+          <address>
+            <street>A</street>
+            <city><![CDATA[B]]></city>
+            <house><![CDATA[H]]></house>
+            <address>
+              <street>C</street>
+              <city><![CDATA[D]]></city>
+              <house><![CDATA[G]]></house>
+            </address>
+          </address>
+        XML
+      end
+
+      let(:expected_xml) do
+        <<~XML
+          <address>
+            <street>A</street>
+            <city>
+              <![CDATA[B]]>
+            </city>
+            <house>H</house>
+            <address>
+              <street>C</street>
+              <city>
+                <![CDATA[D]]>
+              </city>
+              <house>G</house>
+            </address>
+          </address>
+        XML
+      end
+
+      it "round-trips XML" do
+        model = CDATA::Address.from_xml(xml)
+        expect(model.to_xml).to be_equivalent_to(expected_xml)
+      end
+    end
+
+    context "with custom models" do
+      let(:input_xml) do
+        <<~XML
+          <CustomModelParent>
+            <first_name><![CDATA[John]]></first_name>
+            <last_name><![CDATA[Doe]]></last_name>
+            <CustomModelChild>
+              <street><![CDATA[Oxford Street]]></street>
+              <city><![CDATA[London]]></city>
+            </CustomModelChild>
+          </CustomModelParent>
+        XML
+      end
+
+      let(:expected_nokogiri_xml) do
+        <<~XML
+          <CustomModelParent>
+            <first_name><![CDATA[John]]></first_name>
+            <last_name>Doe</last_name>
+            <CustomModelChild>
+              <street><![CDATA[Oxford Street]]></street>
+              <city><![CDATA[London]]></city>
+            </CustomModelChild>
+          </CustomModelParent>
+        XML
+      end
+
+      let(:expected_ox_xml) do
+        <<~XML
+          <CustomModelParent>
+            <first_name>
+              <![CDATA[John]]>
+            </first_name>
+            <last_name>Doe</last_name>
+            <CustomModelChild>
+              <street>
+                <![CDATA[Oxford Street]]>
+              </street>
+              <city>
+                <![CDATA[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 correct model converts objects to xml using custom methods" do
+          instance = parent_mapper.from_xml(input_xml)
+          result_xml = parent_mapper.to_xml(instance)
+
+          expected_output = adapter_class == Lutaml::Model::XmlAdapter::OxAdapter ? expected_ox_xml : expected_nokogiri_xml
+
+          expect(result_xml.strip).to eq(expected_output.strip)
+        end
+      end
+    end
+
+    context "when mixed: true is set for nested content" do
+      let(:xml) do
+        <<~XML
+          <RootMixedContentNested id="outer123">
+            <![CDATA[The following text is about the Moon.]]>
+              <MixedContent id="inner456">
+                <![CDATA[The Earth's Moon rings like a ]]>
+                <bold><![CDATA[bell]]></bold>
+                <![CDATA[ when struck by meteroids. Distanced from the Earth by ]]>
+                <italic><![CDATA[384,400 km]]></italic>,
+                <![CDATA[ ,its surface is covered in ]]>
+                <underline><![CDATA[craters]]></underline>.
+                <![CDATA[ .Ain't that ]]>
+                <bold><![CDATA[cool]]></bold>
+                <![CDATA[ ? ]]>
+              </MixedContent>
+            <sup><![CDATA[1]]></sup>: <![CDATA[The Moon is not a planet.]]>
+            <sup><![CDATA[2]]></sup>: <![CDATA[The Moon's atmosphere is mainly composed of helium in the form of He]]><sub><![CDATA[2]]></sub>.
+          </RootMixedContentNested>
+        XML
+      end
+
+      expected_xml = "<RootMixedContentNested id=\"outer123\"><![CDATA[The following text is about the Moon.]]><MixedContent id=\"inner456\"><![CDATA[The Earth's Moon rings like a ]]><bold><![CDATA[bell]]></bold><![CDATA[ when struck by meteroids. Distanced from the Earth by ]]><italic><![CDATA[384,400 km]]></italic><![CDATA[ ,its surface is covered in ]]><underline><![CDATA[craters]]></underline><![CDATA[ .Ain't that ]]><bold><![CDATA[cool]]></bold><![CDATA[ ? ]]></MixedContent><sup><![CDATA[1]]></sup><![CDATA[The Moon is not a planet.]]><sup><![CDATA[2]]></sup><![CDATA[The Moon's atmosphere is mainly composed of helium in the form of He]]><sub>2</sub></RootMixedContentNested>"
+
+      expected_ox_xml = <<~XML
+        <RootMixedContentNested id="outer123">
+          <![CDATA[The following text is about the Moon.]]>
+          <MixedContent id="inner456">
+            <![CDATA[The Earth's Moon rings like a ]]>
+            <bold>
+              <![CDATA[bell]]>
+            </bold>
+            <![CDATA[ when struck by meteroids. Distanced from the Earth by ]]>
+            <italic>
+              <![CDATA[384,400 km]]>
+            </italic>
+            <![CDATA[ ,its surface is covered in ]]>
+            <underline>
+              <![CDATA[craters]]>
+            </underline>
+            <![CDATA[ .Ain't that ]]>
+            <bold>
+              <![CDATA[cool]]>
+            </bold>
+            <![CDATA[ ? ]]>
+          </MixedContent>
+          <sup>
+            <![CDATA[1]]>
+          </sup>
+          <![CDATA[The Moon is not a planet.]]>
+          <sup>
+            <![CDATA[2]]>
+          </sup>
+          <![CDATA[The Moon's atmosphere is mainly composed of helium in the form of He]]>
+          <sub>2</sub>
+        </RootMixedContentNested>
+      XML
+
+      it "deserializes and serializes mixed content correctly" do
+        parsed = CDATA::RootMixedContentNested.from_xml(xml)
+
+        expected_content = [
+          "The Earth's Moon rings like a ",
+          " when struck by meteroids. Distanced from the Earth by ",
+          " ,its surface is covered in ",
+          " .Ain't that ",
+          " ? ",
+        ]
+
+        expect(parsed.id).to eq("outer123")
+        expect(parsed.sup).to eq(["1", "2"])
+        expect(parsed.sub).to eq(["2"])
+        expect(parsed.content.id).to eq("inner456")
+        expect(parsed.content.bold).to eq(["bell", "cool"])
+        expect(parsed.content.italic).to eq(["384,400 km"])
+        expect(parsed.content.underline).to eq("craters")
+
+        parsed.content.content.each_with_index do |content, index|
+          expected_output = expected_content[index]
+
+          # due to the difference in capturing
+          # newlines in ox and nokogiri adapters
+          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+            expected_xml = expected_ox_xml
+          end
+
+          expect(content).to eq(expected_output)
+        end
+
+        serialized = parsed.to_xml
+        expect(serialized).to eq(expected_xml)
+      end
+    end
+
+    context "when defualt: true is set for attributes default values" do
+      let(:xml) do
+        <<~XML
+          <DefaultValue>
+            <![CDATA[The following text is about the Moon]]>
+            <temperature>
+              <![CDATA[500]]>
+            </temperature>
+            <![CDATA[The Moon's atmosphere is mainly composed of helium in the form]]>
+          </DefaultValue>
+        XML
+      end
+
+      expected_xml = "<DefaultValue><name><![CDATA[Default Value]]></name><temperature><![CDATA[500]]></temperature><opacity>Opaque</opacity><![CDATA[The following text is about the MoonThe Moon's atmosphere is mainly composed of helium in the form]]></DefaultValue>"
+
+      expected_ox_xml = <<~XML
+        <DefaultValue>
+          <name>
+            <![CDATA[Default Value]]>
+          </name>
+          <temperature>
+            <![CDATA[500]]>
+          </temperature>
+          <opacity>Opaque</opacity>
+          <![CDATA[The following text is about the MoonThe Moon's atmosphere is mainly composed of helium in the form]]>
+        </DefaultValue>
+      XML
+
+      it "deserializes and serializes mixed content correctly" do
+        parsed = CDATA::DefaultValue.from_xml(xml)
+
+        expected_content = [
+          "The following text is about the Moon",
+          "The Moon's atmosphere is mainly composed of helium in the form",
+        ]
+
+        expect(parsed.name).to eq("Default Value")
+        expect(parsed.opacity).to eq("Opaque")
+        expect(parsed.temperature).to eq(500)
+
+        parsed.content.each_with_index do |content, index|
+          expected_output = expected_content[index]
+
+          # due to the difference in capturing
+          # newlines in ox and nokogiri adapters
+          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+            expected_xml = expected_ox_xml
+          end
+
+          expect(content).to eq(expected_output)
+        end
+
+        serialized = parsed.to_xml
+        expect(serialized).to eq(expected_xml)
+      end
+    end
+  end
+
+  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+    it_behaves_like "cdata behavior", described_class
+  end
+
+  describe Lutaml::Model::XmlAdapter::OxAdapter do
+    it_behaves_like "cdata behavior", described_class
+  end
+end

data/spec/lutaml/model/serializable_validation_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 
 class TestSerializable < Lutaml::Model::Serializable
   attribute :name, :string, values: ["Alice", "Bob", "Charlie"]
+  attribute :email, :string, pattern: /.*?\S+@.+\.\S+/
   attribute :age, :integer, collection: 1..3
 
   xml do
@@ -27,9 +28,12 @@ class TestSerializable < Lutaml::Model::Serializable
 end
 
 RSpec.describe Lutaml::Model::Serializable do
-  let(:valid_instance) { TestSerializable.new(name: "Alice", age: [30]) }
+  let(:valid_instance) do
+    TestSerializable.new(name: "Alice", age: [30], email: "alice@gmail.com")
+  end
+
   let(:invalid_instance) do
-    TestSerializable.new(name: "David", age: [25, 30, 35, 40])
+    TestSerializable.new(name: "David", age: [25, 30, 35, 40], email: "david@gmail")
   end
 
   describe "serialization methods" do
@@ -66,8 +70,9 @@ RSpec.describe Lutaml::Model::Serializable do
     it "returns errors for invalid attributes" do
       errors = invalid_instance.validate
       expect(errors).not_to be_empty
-      expect(errors.first).to be_a(Lutaml::Model::InvalidValueError)
-      expect(errors.last).to be_a(Lutaml::Model::CollectionCountOutOfRangeError)
+      expect(errors[0]).to be_a(Lutaml::Model::InvalidValueError)
+      expect(errors[1]).to be_a(Lutaml::Model::PatternNotMatchedError)
+      expect(errors[2]).to be_a(Lutaml::Model::CollectionCountOutOfRangeError)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.25
+  version: 0.3.26
 platform: ruby
 authors:
 - Ribose Inc.
@@ -59,6 +59,7 @@ files:
 - lib/lutaml/model/error/collection_count_out_of_range_error.rb
 - lib/lutaml/model/error/incorrect_mapping_argument_error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
+- lib/lutaml/model/error/pattern_not_matched_error.rb
 - lib/lutaml/model/error/type_error.rb
 - lib/lutaml/model/error/type_not_enabled_error.rb
 - lib/lutaml/model/error/unknown_adapter_type_error.rb
@@ -127,6 +128,7 @@ files:
 - spec/fixtures/vase.rb
 - spec/fixtures/xml/special_char.xml
 - spec/lutaml/model/attribute_spec.rb
+- spec/lutaml/model/cdata_spec.rb
 - spec/lutaml/model/collection_spec.rb
 - spec/lutaml/model/comparable_model_spec.rb
 - spec/lutaml/model/custom_model_spec.rb