lutaml-model 0.3.24 → 0.3.26

data/lib/lutaml/model/type/time_without_date.rb

@@ -1,16 +1,48 @@
+require "time"
+
 module Lutaml
   module Model
     module Type
-      # Time representation without date
-      class TimeWithoutDate
+      class TimeWithoutDate < Value
+        # TODO: we probably want to do something like this because using
+        # Time.parse will set the date to today.
+        #
+        # time = ::Time.parse(value.to_s)
+        # ::Time.new(1, 1, 1, time.hour, time.min, time.sec)
+
         def self.cast(value)
-          return if value.nil?
+          return nil if value.nil?
 
-          ::Time.parse(value.to_s)
+          case value
+          when ::Time then value
+          else ::Time.parse(value.to_s)
+          end
+        rescue ArgumentError
+          nil
         end
 
         def self.serialize(value)
-          value.strftime("%H:%M:%S")
+          return nil if value.nil?
+
+          value = cast(value)
+          value.strftime("%H:%M:%S") # Format as HH:MM:SS
+        end
+
+        # Instance methods for format-specific serialization
+        def to_xml
+          self.class.serialize(value)
+        end
+
+        def to_json(*_args)
+          self.class.serialize(value)
+        end
+
+        def to_yaml
+          self.class.serialize(value)
+        end
+
+        def to_toml
+          value.strftime("%H:%M:%S.%L") # Include milliseconds for TOML
         end
       end
     end

data/lib/lutaml/model/type/value.rb

@@ -0,0 +1,52 @@
+require_relative "../config"
+
+module Lutaml
+  module Model
+    module Type
+      # Base class for all value types
+      class Value
+        attr_reader :value
+
+        def initialize(value)
+          @value = self.class.cast(value)
+        end
+
+        def self.cast(value)
+          return nil if value.nil?
+
+          value
+        end
+
+        def self.serialize(value)
+          return nil if value.nil?
+
+          new(value).to_s
+        end
+
+        # Instance methods for serialization
+        def to_s
+          value.to_s
+        end
+
+        # Format-specific instance methods
+        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+          define_method(:"to_#{format}") do
+            value
+          end
+        end
+
+        # Class-level format conversion
+        def self.from_format(value, format)
+          new(send(:"from_#{format}", value))
+        end
+
+        # Default format-specific class methods that can be overridden
+        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+          define_singleton_method(:"from_#{format}") do |value|
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/type.rb

@@ -1,136 +1,72 @@
-require "date"
-require "bigdecimal"
-
 module Lutaml
   module Model
     module Type
-      # This module provides a set of methods to cast and serialize values
-
-      # TODO: Make Boolean a separate class
-
-      %w(
-        String
-        Integer
-        Float
-        Date
-        Time
-        Boolean
-        Decimal
-        Hash
-      ).each do |t|
-        class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-                     class #{t}                        # class Integer
-            def self.cast(value)            #   def self.cast(value)
-              return if value.nil?          #     return if value.nil?
-                                            #
-              Type.cast(value, #{t})        #     Type.cast(value, Integer)
-            end                             #   end
-
-            def self.serialize(value)       #   def self.serialize(value)
-              return if value.nil?          #     return if value.nil?
-                                            #
-              Type.serialize(value, #{t})   #     Type.serialize(value, Integer)
-            end                             #   end
-          end                               # end
-        HEREDOC
-      end
-
-      UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
-
-      def self.cast(value, type)
-        return if value.nil?
-
-        case type.to_s.split("::").last
-        when "String"
-          value.to_s
-        when "Integer"
-          value.to_i
-        when "Float"
-          value.to_f
-        when "Date"
-          begin
-            ::Date.parse(value.to_s)
-          rescue ArgumentError
-            nil
-          end
-        when "DateTime"
-          DateTime.cast(value)
-        when "Time"
-          ::Time.parse(value.to_s)
-        when "TimeWithoutDate"
-          TimeWithoutDate.cast(value)
-        when "Boolean"
-          to_boolean(value)
-        when "Decimal"
-          unless defined?(BigDecimal)
-            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+      TYPE_CODES = {
+        string: "Lutaml::Model::Type::String",
+        integer: "Lutaml::Model::Type::Integer",
+        float: "Lutaml::Model::Type::Float",
+        decimal: "Lutaml::Model::Type::Decimal",
+        date: "Lutaml::Model::Type::Date",
+        time: "Lutaml::Model::Type::Time",
+        date_time: "Lutaml::Model::Type::DateTime",
+        time_without_date: "Lutaml::Model::Type::TimeWithoutDate",
+        boolean: "Lutaml::Model::Type::Boolean",
+        hash: "Lutaml::Model::Type::Hash",
+      }.freeze
+
+      class << self
+        def register_builtin_types
+          TYPE_CODES.each do |type_name, type_class|
+            register(type_name, const_get(type_class))
           end
-
-          BigDecimal(value.to_s)
-        when "Hash"
-          normalize_hash(Hash(value))
-        else
-          value
         end
-      end
-
-      def self.serialize(value, type)
-        return if value.nil?
 
-        case type.to_s.split("::").last
-        when "Date"
-          value.iso8601
-        when "DateTime"
-          DateTime.serialize(value)
-        when "Integer"
-          value.to_i
-        when "Float"
-          value.to_f
-        when "Boolean"
-          to_boolean(value)
-        when "Decimal"
-          unless defined?(BigDecimal)
-            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+        def register(type_name, type_class)
+          unless type_class < Value
+            raise TypeError,
+                  "class '#{type_class}' is not a valid Lutaml::Model::Type::Value"
           end
 
-          value.to_s("F")
-        when "Hash"
-          Hash(value)
-        else
-          value.to_s
+          @registry ||= {}
+          @registry[type_name.to_sym] = type_class
         end
-      end
 
-      def self.to_boolean(value)
-        if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
-          return true
-        end
+        def lookup(type_name)
+          @registry ||= {}
+          klass = @registry[type_name.to_sym]
 
-        if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
-          return false
-        end
+          raise UnknownTypeError.new(type_name) unless klass
 
-        raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
-      end
+          klass
+        end
 
-      def self.normalize_hash(hash)
-        return hash["text"] if hash.keys == ["text"]
+        def cast(value, type)
+          return nil if value.nil?
 
-        hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+          type.cast(value)
+        end
 
-        hash.filter_map do |key, value|
-          next if key == "text"
+        def serialize(value, type)
+          return nil if value.nil?
 
-          if value.is_a?(::Hash)
-            [key, normalize_hash(value)]
-          else
-            [key, value]
-          end
-        end.to_h
+          type.serialize(value)
+        end
       end
     end
   end
 end
 
-require_relative "type/time_without_date"
+# Register built-in types
+require_relative "type/value"
+require_relative "type/string"
+require_relative "type/integer"
+require_relative "type/float"
+require_relative "type/date"
+require_relative "type/time"
 require_relative "type/date_time"
+require_relative "type/time_without_date"
+require_relative "type/boolean"
+require_relative "type/decimal"
+require_relative "type/hash"
+
+Lutaml::Model::Type.register_builtin_types

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.24"
+    VERSION = "0.3.26"
   end
 end

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

@@ -39,6 +39,8 @@ module Lutaml
           )
             add_namespace_prefix(prefix)
 
+            element_name = "#{element_name}_" if respond_to?(element_name)
+
             if block_given?
               public_send(element_name, attributes) do
                 xml.parent.namespace = nil if prefix.nil? && !prefix_unset
@@ -49,12 +51,19 @@ 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
 
-            element << text.to_s
+            text_node = ::Nokogiri::XML::Text.new(text.to_s, element)
+            element.add_child(text_node)
+          end
+
+          def add_cdata(element, value)
+            element.cdata(value)
           end
 
           def add_namespace_prefix(prefix)
@@ -64,7 +73,7 @@ module Lutaml
           end
 
           def method_missing(method_name, *args, &block)
-            if block
+            if block_given?
               xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)

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

@@ -14,6 +14,7 @@ module Lutaml
 
         def to_xml(options = {})
           builder = Builder::Ox.build
+          builder.xml.instruct(:xml, encoding: options[:encoding] || "UTF-8", version: options[:version])
 
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.build_xml(builder)
@@ -26,7 +27,7 @@ module Lutaml
           end
 
           xml_data = builder.xml.to_s
-          options[:declaration] ? declaration(options) + xml_data : xml_data
+          options[:declaration] ? xml_data : xml_data.sub(/\A<\?xml[^>]*\?>\n?/, "")
         end
 
         private
@@ -55,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?
 
@@ -87,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

@@ -84,8 +84,6 @@ module Lutaml
 
             value = if child.text?
                       child.text
-                    elsif attr&.raw?
-                      child.children.map(&:to_xml).join
                     else
                       parse_element(child, attr&.type || klass, format)
                     end
@@ -154,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)
 
@@ -174,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
@@ -246,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)
@@ -263,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/lutaml-model.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   # RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
+      f.match(%r{^(test|features)/})
     end
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }