lutaml-model 0.3.9 → 0.3.11

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

@@ -0,0 +1,29 @@
+module Lutaml
+  module Model
+    class CollectionCountOutOfRangeError < Error
+      def initialize(attr_name, value, range)
+        @attr_name = attr_name
+        @value = value
+        @range = range
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} count is #{@value.size}, must be #{range_to_string}"
+      end
+
+      private
+
+      def range_to_string
+        if @range.end.nil?
+          "at least #{@range.begin}"
+        elsif @range.begin == @range.end
+          "exactly #{@range.begin}"
+        else
+          "between #{@range.begin} and #{@range.end}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Lutaml
+  module Model
+    class IncorrectMappingArgumentsError < Error
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class TypeNotEnabledError < Error
+      def initialize(type_name, value)
+        super("#{type_name} type is not enabled. Value: #{value}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# lib/lutaml/model/error/validation_error.rb
+module Lutaml
+  module Model
+    class ValidationError < Error
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super(errors.join(", "))
+      end
+
+      def include?(error_class)
+        errors.any?(error_class)
+      end
+
+      def error_messages
+        errors.map(&:message)
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -6,4 +6,8 @@ module Lutaml
 end
 
 require_relative "error/invalid_value_error"
+require_relative "error/incorrect_mapping_argument_error"
 require_relative "error/unknown_adapter_type_error"
+require_relative "error/collection_count_out_of_range_error"
+require_relative "error/validation_error"
+require_relative "error/type_not_enabled_error"

data/lib/lutaml/model/json_adapter/standard_json_adapter.rb

@@ -6,8 +6,7 @@ module Lutaml
     module JsonAdapter
       class StandardJsonAdapter < JsonDocument
         def self.parse(json)
-          attributes = JSON.parse(json, create_additions: false)
-          new(attributes)
+          JSON.parse(json, create_additions: false)
         end
 
         def to_json(*args)

data/lib/lutaml/model/key_value_mapping.rb

@@ -11,12 +11,14 @@ module Lutaml
 
       def map(
         name,
-        to:,
+        to: nil,
         render_nil: false,
         with: {},
         delegate: nil,
         child_mappings: nil
       )
+        validate!(name, to, with)
+
         @mappings << KeyValueMappingRule.new(
           name,
           to: to,
@@ -28,6 +30,18 @@ module Lutaml
       end
 
       alias map_element map
+
+      def validate!(key, to, with)
+        if to.nil? && with.empty?
+          msg = ":to or :with argument is required for mapping '#{key}'"
+          raise IncorrectMappingArgumentsError.new(msg)
+        end
+
+        if !with.empty? && (with[:from].nil? || with[:to].nil?)
+          msg = ":with argument for mapping '#{key}' requires :to and :from keys"
+          raise IncorrectMappingArgumentsError.new(msg)
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/mapping_hash.rb

@@ -24,6 +24,20 @@ module Lutaml
         @ordered
       end
 
+      def method_missing(method_name, *args)
+        value = self[method_name] || self[method_name.to_s]
+        return value if value
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        key_present = key?(method_name) || key?(method_name.to_s)
+        return true if key_present
+
+        super
+      end
+
       private
 
       def normalize(key)

data/lib/lutaml/model/mapping_rule.rb

@@ -17,6 +17,7 @@ module Lutaml
         delegate: nil,
         mixed_content: false,
         namespace_set: false,
+        prefix_set: false,
         child_mappings: nil
       )
         @name = name
@@ -26,6 +27,7 @@ module Lutaml
         @delegate = delegate
         @mixed_content = mixed_content
         @namespace_set = namespace_set
+        @prefix_set = prefix_set
         @child_mappings = child_mappings
       end
 
@@ -40,25 +42,47 @@ module Lutaml
         end
       end
 
-      def serialize(model, value)
+      def serialize_attribute(model, element, doc)
         if custom_methods[:to]
-          model.send(custom_methods[:to], model, value)
+          model.send(custom_methods[:to], model, element, doc)
+        end
+      end
+
+      def serialize(model, parent = nil, doc = nil)
+        if custom_methods[:to]
+          model.send(custom_methods[:to], model, parent, doc)
+        elsif delegate
+          model.public_send(delegate).public_send(to)
         else
-          value
+          model.public_send(to)
         end
       end
 
-      def deserialize(model, doc)
+      def deserialize(model, value, attributes, mapper_class = nil)
         if custom_methods[:from]
-          model.send(custom_methods[:from], model, doc)
+          mapper_class.new.send(custom_methods[:from], model, value)
+        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)
         else
-          doc[name.to_s]
+          model.public_send(:"#{to}=", value)
         end
       end
 
       def namespace_set?
         @namespace_set
       end
+
+      def prefix_set?
+        @prefix_set
+      end
+
+      def content_mapping?
+        name.nil?
+      end
     end
   end
 end

data/lib/lutaml/model/schema_location.rb

@@ -0,0 +1,59 @@
+module Lutaml
+  module Model
+    class Location
+      attr_reader :namespace, :location
+
+      def initialize(namespace:, location:)
+        @namespace = namespace
+        @location = location
+      end
+
+      def to_xml_attribute
+        "#{@namespace} #{@location}".strip
+      end
+    end
+
+    class SchemaLocation
+      DEFAULT_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance".freeze
+
+      attr_reader :namespace, :prefix, :schema_location
+
+      def initialize(schema_location:, prefix: "xsi",
+namespace: DEFAULT_NAMESPACE)
+        @original_schema_location = schema_location
+        @schema_location = parsed_schema_locations(schema_location)
+        @prefix = prefix
+        @namespace = namespace
+      end
+
+      def to_xml_attributes
+        {
+          "xmlns:#{prefix}" => namespace,
+          "#{prefix}:schemaLocation" => schema_location.map(&:to_xml_attribute).join(" "),
+        }
+      end
+
+      def [](index)
+        @schema_location[index]
+      end
+
+      def size
+        @schema_location.size
+      end
+
+      private
+
+      def parsed_schema_locations(schema_location)
+        locations = if schema_location.is_a?(Hash)
+                      schema_location
+                    else
+                      schema_location.split.each_slice(2)
+                    end
+
+        locations.map do |n, l|
+          Location.new(namespace: n, location: l)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/serialize.rb

@@ -9,11 +9,15 @@ require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
 require_relative "comparable_model"
+require_relative "schema_location"
+require_relative "validation"
+require_relative "error"
 
 module Lutaml
   module Model
     module Serialize
       include ComparableModel
+      include Validation
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -36,11 +40,34 @@ module Lutaml
         def model(klass = nil)
           if klass
             @model = klass
+            add_order_handling_methods_to_model(klass)
           else
             @model
           end
         end
 
+        def add_order_handling_methods_to_model(klass)
+          Utils.add_method_if_not_defined(klass, :ordered=) do |ordered|
+            @ordered = ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :ordered?) do
+            !!@ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order=) do |order|
+            @element_order = order
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order) do
+            @element_order
+          end
+        end
+
+        def cast(value)
+          value
+        end
+
         # Define an attribute for the model
         def attribute(name, type, options = {})
           attr = Attribute.new(name, type, options)
@@ -51,26 +78,10 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
-            instance_variable_set(:"@#{name}", value)
-            validate
+            instance_variable_set(:"@#{name}", attr.cast_value(value))
           end
         end
 
-        # Check if the value to be assigned is valid for the attribute
-        def attr_value_valid?(name, value)
-          attr = attributes[name]
-
-          return true unless attr.options[:values]
-
-          # Allow nil values if there's no default
-          return true if value.nil? && !attr.default
-
-          # Use the default value if the value is nil
-          value = attr.default if value.nil?
-
-          attr.options[:values].include?(value)
-        end
-
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
@@ -86,17 +97,17 @@ module Lutaml
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
 
             doc = adapter.parse(data)
-            public_send(:"of_#{format}", doc.to_h)
+            public_send(:"of_#{format}", doc)
           end
 
-          define_method(:"of_#{format}") do |hash|
-            if hash.is_a?(Array)
-              return hash.map do |item|
-                apply_mappings(item, format)
-              end
+          define_method(:"of_#{format}") do |doc|
+            if doc.is_a?(Array)
+              return doc.map do |item|
+                       send(:"of_#{format}", item)
+                     end
             end
 
-            apply_mappings(hash, format)
+            apply_mappings(doc.to_h, format)
           end
 
           define_method(:"to_#{format}") do |instance|
@@ -197,6 +208,7 @@ module Lutaml
 
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
+
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
               mapping.map_element(
@@ -205,6 +217,8 @@ module Lutaml
                 render_nil: attr.render_nil?,
               )
             end
+
+            mapping.root(to_s.split("::").last) if format == :xml
           end
         end
 
@@ -254,20 +268,28 @@ module Lutaml
           hash
         end
 
+        def valid_rule?(rule)
+          attribute = attribute_for_rule(rule)
+
+          !!attribute || rule.custom_methods[:from]
+        end
+
+        def attribute_for_rule(rule)
+          return attributes[rule.to] unless rule.delegate
+
+          attributes[rule.delegate].type.attributes[rule.to]
+        end
+
         def apply_mappings(doc, format, options = {})
           instance = options[:instance] || model.new
-          return instance if !doc || doc.empty?
+          return instance if Utils.blank?(doc)
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           mappings = mappings_for(format).mappings
           mappings.each do |rule|
-            attr = if rule.delegate
-                     attributes[rule.delegate].type.attributes[rule.to]
-                   else
-                     attributes[rule.to]
-                   end
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+            attr = attribute_for_rule(rule)
 
             value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
                       doc[rule.name] || doc[rule.name.to_sym]
@@ -276,26 +298,17 @@ module Lutaml
                     end
 
             if rule.custom_methods[:from]
-              if value && !value.empty?
-                value = new.send(rule.custom_methods[:from], instance,
-                                 value)
+              if Utils.present?(value)
+                value = new.send(rule.custom_methods[:from], instance, value)
               end
+
               next
             end
 
             value = apply_child_mappings(value, rule.child_mappings)
             value = attr.cast(value, format)
 
-            if rule.delegate
-              if instance.public_send(rule.delegate).nil?
-                instance.public_send(:"#{rule.delegate}=",
-                                     attributes[rule.delegate].type.new)
-              end
-              instance.public_send(rule.delegate).public_send(:"#{rule.to}=",
-                                                              value)
-            else
-              instance.public_send(:"#{rule.to}=", value)
-            end
+            rule.deserialize(instance, value, attributes, self)
           end
 
           instance
@@ -316,45 +329,62 @@ module Lutaml
             instance.ordered = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
-          mappings.each do |rule|
-            attr = attributes[rule.to]
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+          if doc["__schema_location"]
+            instance.schema_location = Lutaml::Model::SchemaLocation.new(
+              schema_location: doc["__schema_location"][:schema_location],
+              prefix: doc["__schema_location"][:prefix],
+              namespace: doc["__schema_location"][:namespace],
+            )
+          end
 
-            is_content_mapping = rule.name.nil?
+          mappings.each do |rule|
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            value = if is_content_mapping
+            value = if rule.content_mapping?
                       doc["text"]
                     else
                       doc[rule.name.to_s] || doc[rule.name.to_sym]
                     end
 
-            value = [value].compact if attr.collection? && !value.is_a?(Array)
+            value = normalize_xml_value(value, rule)
+            rule.deserialize(instance, value, attributes, self)
+          end
 
-            if value.is_a?(Array)
-              value = value.map do |v|
-                v.is_a?(Hash) && !(attr.type <= Serialize) ? v["text"] : v
-              end
-            elsif !(attr.type <= Serialize) && value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-              value = value["text"]
-            end
+          instance
+        end
 
-            unless is_content_mapping
-              value = attr.cast(
-                value,
-                :xml,
-                caller_class: self,
-                mixed_content: rule.mixed_content,
-              )
-            end
+        def normalize_xml_value(value, rule)
+          attr = attribute_for_rule(rule)
 
-            if rule.custom_methods[:from]
-              new.send(rule.custom_methods[:from], instance, value)
-            else
-              instance.public_send(:"#{rule.to}=", value)
-            end
+          value = [value].compact if attr&.collection? && !value.is_a?(Array)
+
+          value = if value.is_a?(Array)
+                    value.map do |v|
+                      text_hash?(attr, v) ? v["text"] : v
+                    end
+                  elsif text_hash?(attr, value)
+                    value["text"]
+                  else
+                    value
+                  end
+
+          if attr && !rule.content_mapping?
+            value = attr.cast(
+              value,
+              :xml,
+              caller_class: self,
+              mixed_content: rule.mixed_content,
+            )
           end
 
-          instance
+          value
+        end
+
+        def text_hash?(attr, value)
+          return false unless value.is_a?(Hash)
+          return value.keys == ["text"] unless attr
+
+          !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
         end
 
         def ensure_utf8(value)
@@ -376,9 +406,11 @@ module Lutaml
         end
       end
 
-      attr_accessor :element_order
+      attr_accessor :element_order, :schema_location
 
       def initialize(attrs = {})
+        @validate_on_set = attrs.delete(:validate_on_set) || false
+
         return unless self.class.attributes
 
         if attrs.is_a?(Lutaml::Model::MappingHash)
@@ -386,13 +418,41 @@ module Lutaml
           @element_order = attrs.item_order
         end
 
+        if attrs.key?(:schema_location)
+          self.schema_location = attrs[:schema_location]
+        end
+
         self.class.attributes.each do |name, attr|
-          value = self.class.attr_value(attrs, name, attr)
+          value = if attrs.key?(name) || attrs.key?(name.to_s)
+                    self.class.attr_value(attrs, name, attr)
+                  else
+                    attr.default
+                  end
 
-          send(:"#{name}=", self.class.ensure_utf8(value))
+          # Initialize collections with an empty array if no value is provided
+          if attr.collection? && value.nil?
+            value = []
+          end
+
+          instance_variable_set(:"@#{name}", self.class.ensure_utf8(value))
         end
+      end
 
-        validate
+      def method_missing(method_name, *args)
+        if method_name.to_s.end_with?("=") && self.class.attributes.key?(method_name.to_s.chomp("=").to_sym)
+          define_singleton_method(method_name) do |value|
+            instance_variable_set(:"@#{method_name.to_s.chomp('=')}", value)
+          end
+          send(method_name, *args)
+        else
+          super
+        end
+      end
+
+      def validate_attribute!(attr_name)
+        attr = self.class.attributes[attr_name]
+        value = instance_variable_get(:"@#{attr_name}")
+        attr.validate_value!(value)
       end
 
       def ordered?
@@ -413,7 +473,6 @@ module Lutaml
 
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
-          validate
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
           representation = if format == :xml
                              self
@@ -425,16 +484,6 @@ module Lutaml
           adapter.new(representation).public_send(:"to_#{format}", options)
         end
       end
-
-      def validate
-        self.class.attributes.each do |name, attr|
-          value = send(name)
-          unless self.class.attr_value_valid?(name, value)
-            raise Lutaml::Model::InvalidValueError.new(name, value,
-                                                       attr.options[:values])
-          end
-        end
-      end
     end
   end
 end

data/lib/lutaml/model/type.rb

@@ -62,6 +62,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           BigDecimal(value.to_s)
         when "Hash"
           normalize_hash(Hash(value))
@@ -85,6 +89,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           value.to_s("F")
         when "Hash"
           Hash(value)

data/lib/lutaml/model/utils.rb

@@ -34,6 +34,22 @@ module Lutaml
             .downcase
         end
 
+        def present?(value)
+          !blank?(value)
+        end
+
+        def blank?(value)
+          value.respond_to?(:empty?) ? value.empty? : !value
+        end
+
+        def add_method_if_not_defined(klass, method_name, &block)
+          unless klass.method_defined?(method_name)
+            klass.class_eval do
+              define_method(method_name, &block)
+            end
+          end
+        end
+
         private
 
         def camelize_part(part)