lutaml-model 0.7.1 → 0.7.7

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

@@ -2,31 +2,34 @@ module Lutaml
   module Model
     module Type
       class Integer < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
           return 1 if value === true
           return 0 if value === false
 
-          case value
-          when ::String
-            if value.match?(/^0[0-7]+$/) # Octal
-              value.to_i(8)
-            elsif value.match?(/^-?\d+(\.\d+)?(e-?\d+)?$/i) # Float/exponential
-              Float(value).to_i
-            else
-              begin
-                Integer(value, 10)
-              rescue StandardError
-                nil
-              end
-            end
-          else
-            begin
-              Integer(value)
-            rescue StandardError
-              nil
-            end
-          end
+          value = case value
+                  when ::String
+                    if value.match?(/^0[0-7]+$/) # Octal
+                      value.to_i(8)
+                    elsif value.match?(/^-?\d+(\.\d+)?(e-?\d+)?$/i) # Float/exponential
+                      Float(value).to_i
+                    else
+                      begin
+                        Integer(value, 10)
+                      rescue StandardError
+                        nil
+                      end
+                    end
+                  else
+                    begin
+                      Integer(value)
+                    rescue StandardError
+                      nil
+                    end
+                  end
+
+          Model::Services::Type::Validator::Number.validate!(value, options)
+          value
         end
 
         # Override serialize to return Integer instead of String

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

@@ -2,10 +2,12 @@ module Lutaml
   module Model
     module Type
       class String < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
-          value.to_s
+          value = value.to_s
+          Model::Services::Type::Validator::String.validate!(value, options)
+          value
         end
 
         # xs:string format

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

@@ -4,7 +4,7 @@ module Lutaml
   module Model
     module Type
       class Time < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

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

@@ -10,7 +10,7 @@ module Lutaml
         # time = ::Time.parse(value.to_s)
         # ::Time.new(1, 1, 1, time.hour, time.min, time.sec)
 
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

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

@@ -11,7 +11,11 @@ module Lutaml
           @value = self.class.cast(value)
         end
 
-        def self.cast(value)
+        def initialized?
+          true
+        end
+
+        def self.cast(value, _options = {})
           return nil if value.nil?
 
           value
@@ -28,20 +32,17 @@ module Lutaml
           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|
+        # called from config when a new format is added
+        def self.register_format_to_from_methods(format)
+          define_method(:"to_#{format}") do
+            value
+          end
+
           define_singleton_method(:"from_#{format}") do |value|
             cast(value)
           end

data/lib/lutaml/model/type.rb

@@ -5,6 +5,7 @@ module Lutaml
         string: "Lutaml::Model::Type::String",
         integer: "Lutaml::Model::Type::Integer",
         float: "Lutaml::Model::Type::Float",
+        double: "Lutaml::Model::Type::Float",
         decimal: "Lutaml::Model::Type::Decimal",
         date: "Lutaml::Model::Type::Date",
         time: "Lutaml::Model::Type::Time",
@@ -32,6 +33,8 @@ module Lutaml
         end
 
         def lookup(type_name)
+          return type_name if type_name.is_a?(Class)
+
           @registry ||= {}
           klass = @registry[type_name.to_sym]
 
@@ -43,13 +46,13 @@ module Lutaml
         def cast(value, type)
           return nil if value.nil?
 
-          type.cast(value)
+          lookup(type).cast(value)
         end
 
         def serialize(value, type)
           return nil if value.nil?
 
-          type.serialize(value)
+          lookup(type).serialize(value)
         end
       end
     end

data/lib/lutaml/model/uninitialized_class.rb

@@ -12,7 +12,7 @@ module Lutaml
       end
 
       def inspect
-        "unititialized"
+        "uninitialized"
       end
 
       def uninitialized?

data/lib/lutaml/model/utils.rb

@@ -4,6 +4,8 @@ module Lutaml
   module Model
     module Utils
       class << self
+        UNINITIALIZED = Lutaml::Model::UninitializedClass.instance
+
         # Convert string to camel case
         def camel_case(str)
           return "" if str.nil? || str.empty?
@@ -34,14 +36,22 @@ module Lutaml
             .downcase
         end
 
-        def initialized?(value)
-          return true unless value.respond_to?(:initialized?)
+        # Extract the base name of the class
+        def base_class_name(klass)
+          klass.to_s.split("::").last
+        end
 
-          value.initialized?
+        # Convert the extracted base class to snake case format
+        def base_class_snake_case(klass)
+          snake_case(base_class_name(klass))
+        end
+
+        def initialized?(value)
+          !value.equal?(UNINITIALIZED)
         end
 
         def uninitialized?(value)
-          !initialized?(value)
+          value.equal?(UNINITIALIZED)
         end
 
         def present?(value)
@@ -63,6 +73,48 @@ module Lutaml
           value.respond_to?(:empty?) ? value.empty? : false
         end
 
+        def add_if_present(hash, key, value)
+          hash[key] = value if value
+        end
+
+        # Check if the hash contains the given key in string or symbol format
+        # @param hash [Hash] the hash to check
+        # @param key [String, Symbol] the key to check
+        # @return [Boolean] true if the hash contains the key, false otherwise
+        # @example
+        #   hash = { "key" => "value" }
+        #   string_or_symbol_key?(hash, "key") # => true
+        #   string_or_symbol_key?(hash, :key) # => true
+        #   string_or_symbol_key?(hash, "invalid_key") # => false
+        def string_or_symbol_key?(hash, key)
+          hash.key?(key.to_s) || hash.key?(key.to_sym)
+        end
+
+        # Fetch the value from the hash using the key in string or symbol format
+        # @param hash [Hash] the hash to fetch the value from
+        # @param key [String, Symbol] the key to fetch the value for
+        # @return [Object] the value associated with the key
+        # @example
+        #   hash = { "key" => "value" }
+        #   fetch_str_or_sym(hash, "key") # => "value"
+        #   fetch_str_or_sym(hash, :key) # => "value"
+        #   fetch_str_or_sym(hash, "invalid_key") # => nil
+        def fetch_str_or_sym(hash, key, default = nil)
+          if hash.key?(key.to_s)
+            hash[key.to_s]
+          elsif hash.key?(key.to_sym)
+            hash[key.to_sym]
+          else
+            default
+          end
+        end
+
+        def add_singleton_method_if_not_defined(instance, method_name, &block)
+          return if instance.respond_to?(method_name)
+
+          instance.define_singleton_method(method_name, &block)
+        end
+
         def add_method_if_not_defined(klass, method_name, &block)
           unless klass.method_defined?(method_name)
             klass.class_eval do

data/lib/lutaml/model/validation.rb

@@ -1,20 +1,22 @@
 module Lutaml
   module Model
     module Validation
-      def validate
+      def validate(register: Lutaml::Model::Config.default_register)
         errors = []
+
         self.class.attributes.each do |name, attr|
           value = public_send(:"#{name}")
           begin
             if value.respond_to?(:validate)
               errors.concat(value.validate)
             else
-              attr.validate_value!(value)
+              attr.validate_value!(value, register)
             end
           rescue Lutaml::Model::InvalidValueError,
                  Lutaml::Model::CollectionCountOutOfRangeError,
                  Lutaml::Model::CollectionTrueMissingError,
                  Lutaml::Model::PolymorphicError,
+                 Lutaml::Model::ValidationFailedError,
                  PatternNotMatchedError => e
             errors << e
           end
@@ -23,8 +25,8 @@ module Lutaml
         validate_helper(errors)
       end
 
-      def validate!
-        errors = validate
+      def validate!(register: Lutaml::Model::Config.default_register)
+        errors = validate(register: register)
         raise Lutaml::Model::ValidationError.new(errors) if errors.any?
       end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.7.1"
+    VERSION = "0.7.7"
   end
 end

data/lib/lutaml/model/{xml_adapter → xml}/builder/nokogiri.rb

@@ -1,6 +1,6 @@
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Nokogiri
           def self.build(options = {})
@@ -84,7 +84,7 @@ module Lutaml
           end
 
           def method_missing(method_name, *args, &block)
-            if block_given?
+            if block
               xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)

data/lib/lutaml/model/{xml_adapter → xml}/builder/oga.rb

@@ -2,7 +2,7 @@
 
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Oga
           def self.build(options = {}, &block)
@@ -12,7 +12,7 @@ module Lutaml
           attr_reader :document, :current_node, :encoding
 
           def initialize(options = {})
-            @document = XmlAdapter::Oga::Document.new
+            @document = Xml::Oga::Document.new
             @current_node = @document
             @encoding = options[:encoding]
             yield(self) if block_given?
@@ -23,7 +23,7 @@ module Lutaml
               name = "#{@current_namespace}:#{name}"
             end
 
-            if block_given?
+            if block
               element(name, attributes, &block)
             else
               element(name, attributes)
@@ -48,9 +48,9 @@ module Lutaml
 
           def add_element(oga_element, child)
             if child.is_a?(String)
-              current_element = oga_element.is_a?(XmlAdapter::Oga::Document) ? current_node : oga_element
+              current_element = oga_element.is_a?(Xml::Oga::Document) ? current_node : oga_element
               add_xml_fragment(current_element, child)
-            elsif oga_element.is_a?(XmlAdapter::Oga::Document)
+            elsif oga_element.is_a?(Xml::Oga::Document)
               oga_element.children.last.children << child
             else
               oga_element.children << child
@@ -62,7 +62,7 @@ module Lutaml
               name: name,
               value: value.to_s,
             )
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.attributes << attribute
             else
               element.attributes << attribute
@@ -85,7 +85,7 @@ module Lutaml
                               element_name
                             end
 
-            if block_given?
+            if block
               element(prefixed_name, attributes, &block)
             else
               element(prefixed_name, attributes)
@@ -100,7 +100,7 @@ module Lutaml
             fragment = "<fragment>#{content}</fragment>"
             parsed_fragment = ::Oga.parse_xml(fragment)
             parsed_children = parsed_fragment.children.first.children
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.children += parsed_children
             else
               element.children += parsed_children
@@ -116,7 +116,7 @@ module Lutaml
           end
 
           def append_text_node(element, oga_text)
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               children = element.children
               children.empty? ? children << oga_text : children.last.children << oga_text
             else
@@ -126,7 +126,7 @@ module Lutaml
 
           def add_cdata(element, value)
             oga_cdata = ::Oga::XML::CData.new(text: value.to_s)
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.children << oga_cdata
             else
               element.children << oga_cdata

data/lib/lutaml/model/{xml_adapter → xml}/builder/ox.rb

@@ -1,6 +1,6 @@
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Ox
           def self.build(options = {})

data/lib/lutaml/model/{xml_adapter/xml_document.rb → xml/document.rb}

@@ -6,13 +6,14 @@ require_relative "element"
 
 module Lutaml
   module Model
-    module XmlAdapter
-      class XmlDocument
-        attr_reader :root, :encoding
+    module Xml
+      class Document
+        attr_reader :root, :encoding, :register
 
-        def initialize(root, encoding = nil)
+        def initialize(root, encoding = nil, register: nil)
           @root = root
           @encoding = encoding
+          @register = setup_register(register)
         end
 
         def self.parse(xml, _options = {})
@@ -79,7 +80,7 @@ module Lutaml
           options[:mixed_content] = rule.mixed_content
           options[:tag_name] = rule.name
 
-          options[:mapper_class] = attribute&.type if attribute
+          options[:mapper_class] = attribute&.type(register) if attribute
           options[:set_namespace] = set_namespace?(rule)
 
           options
@@ -107,7 +108,7 @@ module Lutaml
             result["elements"] ||= Lutaml::Model::MappingHash.new
             result["elements"].assign_or_append_value(
               self.class.namespaced_name_of(child),
-              parse_element(child, attr&.type || klass, format),
+              parse_element(child, attr&.type(register) || klass, format),
             )
           end
 
@@ -127,9 +128,9 @@ module Lutaml
                 prefix: attr.namespace_prefix,
                 schema_location: attr.value,
               }
+            else
+              result[attr.namespaced_name] = attr.value
             end
-
-            result[attr.namespaced_name] = attr.value
           end
 
           result
@@ -148,17 +149,16 @@ module Lutaml
           rule = options[:rule]
 
           if rule.custom_methods[:to]
-            options[:mapper_class].new.send(rule.custom_methods[:to], element,
-                                            xml.parent, xml)
+            options[:mapper_class].new.send(rule.custom_methods[:to], element, xml.parent, xml)
             return
           end
 
           # Only transform when recursion is not called
-          if (!attribute.collection? || value.is_a?(Array)) && transform_method = rule.transform[:export] || attribute.transform_export_method
-            value = transform_method.call(value)
+          if !attribute.collection? || attribute.collection_instance?(value)
+            value = ExportTransformer.call(value, rule, attribute)
           end
 
-          if value.is_a?(Array) && !Utils.empty_collection?(value)
+          if attribute.collection_instance?(value) && !Utils.empty_collection?(value)
             value.each do |item|
               add_to_xml(xml, element, prefix, item, options)
             end
@@ -170,7 +170,7 @@ module Lutaml
 
           value = rule.render_value_for(value)
 
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+          if value && (attribute&.type(register)&.<= Lutaml::Model::Serialize)
             handle_nested_elements(
               xml,
               value,
@@ -195,10 +195,10 @@ module Lutaml
 
         def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
-            serialized_value = attribute.serialize(value, :xml)
+            serialized_value = attribute.serialize(value, :xml, register)
             if attribute.raw?
               xml.add_xml_fragment(xml, value)
-            elsif attribute.type == Lutaml::Model::Type::Hash
+            elsif attribute.type(register) == Lutaml::Model::Type::Hash
               serialized_value.each do |key, val|
                 xml.create_and_add_element(key) do |element|
                   element.text(val)
@@ -233,7 +233,6 @@ module Lutaml
             end
 
             mappings = xml_mapping.elements + [xml_mapping.raw_mapping].compact
-
             mappings.each do |element_rule|
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)
@@ -243,7 +242,7 @@ module Lutaml
 
                 next if !element_rule.render?(value, element)
 
-                value = [value] if attribute_def.collection? && !value.is_a?(Array)
+                value = attribute_def.build_collection(value) if attribute_def.collection? && !attribute_def.collection_instance?(value)
               end
 
               add_to_xml(
@@ -265,14 +264,16 @@ module Lutaml
           return unless content_rule
 
           if content_rule.custom_methods[:to]
-            mapper_class.new.send(content_rule.custom_methods[:to], element,
-                                  xml.parent, xml)
+            mapper_class.new.send(
+              content_rule.custom_methods[:to],
+              element,
+              xml.parent,
+              xml,
+            )
           else
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
 
-            return unless content_rule.render?(text, element)
-
             xml.add_text(xml, text, cdata: content_rule.cdata)
           end
         end
@@ -323,9 +324,10 @@ module Lutaml
             processed[klass][mapping_rule.name] = true
 
             type = if mapping_rule.delegate
-                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
+                     attributes[mapping_rule.delegate].type(register)
+                       .attributes[mapping_rule.to].type(register)
                    else
-                     attributes[mapping_rule.to]&.type
+                     attributes[mapping_rule.to]&.type(register)
                    end
 
             next unless type
@@ -366,7 +368,9 @@ module Lutaml
 
             value = mapping_rule.to_value_for(element)
             attr = attribute_definition_for(element, mapping_rule, mapper_class: options[:mapper_class])
-            value = attr.serialize(value, :xml) if attr
+            value = attr.serialize(value, :xml, register) if attr
+
+            value = ExportTransformer.call(value, mapping_rule, attr)
 
             if render_element?(mapping_rule, element, value)
               hash[mapping_rule.prefixed_name] = value ? value.to_s : value
@@ -434,6 +438,19 @@ module Lutaml
 
         private
 
+        def setup_register(register)
+          return register if register.is_a?(Symbol)
+
+          return_register = if register.is_a?(Lutaml::Model::Register)
+                              register.id
+                            elsif @root.respond_to?(:__register)
+                              @root.__register
+                            elsif @root.instance_variable_defined?(:@__register)
+                              @root.instance_variable_get(:@__register)
+                            end
+          return_register || Lutaml::Model::Config.default_register
+        end
+
         def determine_mapper_class(element, options)
           if options[:mapper_class] && element.is_a?(options[:mapper_class])
             element.class

data/lib/lutaml/model/xml/element.rb

@@ -0,0 +1,32 @@
+module Lutaml
+  module Model
+    module Xml
+      class Element
+        attr_reader :type, :name
+
+        def initialize(type, name)
+          @type = type
+          @name = name
+        end
+
+        def text?
+          @type == "Text" && @name != "#cdata-section"
+        end
+
+        def element_tag
+          @name unless text?
+        end
+
+        def eql?(other)
+          return false unless other.is_a?(self.class)
+
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+        end
+
+        alias == eql?
+      end
+    end
+  end
+end