lutaml-model 0.3.8 → 0.3.10

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/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

@@ -7,3 +7,5 @@ end
 
 require_relative "error/invalid_value_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/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,14 @@ require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
 require_relative "comparable_model"
+require_relative "schema_location"
+require_relative "validation"
 
 module Lutaml
   module Model
     module Serialize
       include ComparableModel
+      include Validation
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -52,25 +55,10 @@ module Lutaml
 
           define_method(:"#{name}=") do |value|
             instance_variable_set(:"@#{name}", value)
-            validate
+            # validate!(name)
           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
@@ -92,8 +80,8 @@ module Lutaml
           define_method(:"of_#{format}") do |hash|
             if hash.is_a?(Array)
               return hash.map do |item|
-                apply_mappings(item, format)
-              end
+                       apply_mappings(item, format)
+                     end
             end
 
             apply_mappings(hash, format)
@@ -276,7 +264,10 @@ module Lutaml
                     end
 
             if rule.custom_methods[:from]
-              value = new.send(rule.custom_methods[:from], instance, value) if value && !value.empty?
+              if value && !value.empty?
+                value = new.send(rule.custom_methods[:from], instance,
+                                 value)
+              end
               next
             end
 
@@ -313,6 +304,14 @@ module Lutaml
             instance.ordered = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
+          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
+
           mappings.each do |rule|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
@@ -373,9 +372,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)
@@ -383,13 +384,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
+
+          # Initialize collections with an empty array if no value is provided
+          if attr.collection? && value.nil?
+            value = []
+          end
 
-          send(:"#{name}=", self.class.ensure_utf8(value))
+          instance_variable_set(:"@#{name}", self.class.ensure_utf8(value))
+        end
+      end
+
+      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
 
-        validate
+      def validate_attribute!(attr_name)
+        attr = self.class.attributes[attr_name]
+        value = instance_variable_get(:"@#{attr_name}")
+        attr.validate_value!(value)
       end
 
       def ordered?
@@ -410,7 +439,7 @@ module Lutaml
 
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
-          validate
+          validate!
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
           representation = if format == :xml
                              self
@@ -422,16 +451,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/validation.rb

@@ -0,0 +1,24 @@
+module Lutaml
+  module Model
+    module Validation
+      def validate
+        errors = []
+        self.class.attributes.each do |name, attr|
+          value = instance_variable_get(:"@#{name}")
+          begin
+            attr.validate_value!(value)
+          rescue Lutaml::Model::InvalidValueError,
+                 Lutaml::Model::CollectionCountOutOfRangeError => e
+            errors << e
+          end
+        end
+        errors
+      end
+
+      def validate!
+        errors = validate
+        raise Lutaml::Model::ValidationError.new(errors) if errors.any?
+      end
+    end
+  end
+end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.8"
+    VERSION = "0.3.10"
   end
 end

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

@@ -17,9 +17,14 @@ module Lutaml
 
           def initialize(xml)
             @xml = xml
+            @current_namespace = nil
           end
 
           def create_element(name, attributes = {})
+            if @current_namespace && !name.start_with?("#{@current_namespace}:")
+              name = "#{@current_namespace}:#{name}"
+            end
+
             if block_given?
               xml.element(name, attributes) do |element|
                 yield(self.class.new(element))
@@ -36,6 +41,8 @@ module Lutaml
           def create_and_add_element(element_name, prefix: nil, attributes: {})
             prefixed_name = if prefix
                               "#{prefix}:#{element_name}"
+                            elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
+                              "#{@current_namespace}:#{element_name}"
                             else
                               element_name
                             end
@@ -47,6 +54,8 @@ module Lutaml
             else
               xml.element(prefixed_name, attributes)
             end
+
+            @current_namespace = nil
           end
 
           def <<(text)
@@ -59,9 +68,10 @@ module Lutaml
 
           # Add XML namespace to document
           #
-          # Ox doesn't support XML namespaces so this method does nothing.
-          def add_namespace_prefix(_prefix)
-            # :noop:
+          # Ox doesn't support XML namespaces so we only save the
+          # current namespace prefix to add it to the element's name later.
+          def add_namespace_prefix(prefix)
+            @current_namespace = prefix
             self
           end
 

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

@@ -20,6 +20,8 @@ module Lutaml
           elsif ordered?(@root, options)
             build_ordered_element(builder, @root, options)
           else
+            mapper_class = options[:mapper_class] || @root.class
+            options[:xml_attributes] = build_namespace_attributes(mapper_class)
             build_element(builder, @root, options)
           end
 
@@ -46,6 +48,7 @@ module Lutaml
               curr_index = index_hash[name] += 1
 
               element_rule = xml_mapping.find_by_name(name)
+              next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)

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

@@ -77,16 +77,23 @@ module Lutaml
           element.children.each_with_object(result) do |child, hash|
             value = child.text? ? child.text : parse_element(child)
 
-            if hash[child.unprefixed_name]
-              hash[child.unprefixed_name] =
-                [hash[child.unprefixed_name], value].flatten
-            else
-              hash[child.unprefixed_name] = value
-            end
+            hash[child.unprefixed_name] = if hash[child.unprefixed_name]
+                                            [hash[child.unprefixed_name], value].flatten
+                                          else
+                                            value
+                                          end
           end
 
           element.attributes.each_value do |attr|
-            result[attr.unprefixed_name] = attr.value
+            if attr.unprefixed_name == "schemaLocation"
+              result["__schema_location"] = {
+                namespace: attr.namespace,
+                prefix: attr.namespace_prefix,
+                schema_location: attr.value,
+              }
+            else
+              result[attr.unprefixed_name] = attr.value
+            end
           end
 
           result
@@ -150,6 +157,9 @@ module Lutaml
           attributes = options[:xml_attributes] ||= {}
           attributes = build_attributes(element,
                                         xml_mapping, options).merge(attributes)&.compact
+          if element.respond_to?(:schema_location) && element.schema_location
+            attributes.merge!(element.schema_location.to_xml_attributes)
+          end
 
           prefix = if options.key?(:namespace_prefix)
                      options[:namespace_prefix]
@@ -160,10 +170,10 @@ module Lutaml
           prefixed_xml = xml.add_namespace_prefix(prefix)
           tag_name = options[:tag_name] || xml_mapping.root_element
 
-          xml.create_and_add_element(tag_name, prefix: prefix,
-                                               attributes: attributes) do
+          prefixed_xml.create_and_add_element(tag_name, prefix: prefix,
+                                                        attributes: attributes) do
             if options.key?(:namespace_prefix) && !options[:namespace_prefix]
-              xml.add_namespace_prefix(nil)
+              prefixed_xml.add_namespace_prefix(nil)
             end
 
             xml_mapping.elements.each do |element_rule|
@@ -177,7 +187,7 @@ module Lutaml
               value = [value] if attribute_def.collection? && !value.is_a?(Array)
 
               add_to_xml(
-                xml,
+                prefixed_xml,
                 element_rule.prefix,
                 value,
                 options.merge({ attribute: attribute_def, rule: element_rule }),
@@ -212,9 +222,11 @@ module Lutaml
 
           attrs = {}
 
-          if xml_mappings.namespace_prefix
-            attrs["xmlns:#{xml_mappings.namespace_prefix}"] =
-              xml_mappings.namespace_uri
+          if xml_mappings.namespace_uri
+            prefixed_name = ["xmlns",
+                             xml_mappings.namespace_prefix].compact.join(":")
+
+            attrs[prefixed_name] = xml_mappings.namespace_uri
           end
 
           xml_mappings.mappings.each do |mapping_rule|

data/lib/lutaml/model/xml_mapping.rb

@@ -44,8 +44,7 @@ module Lutaml
         delegate: nil,
         namespace: (namespace_set = false
                     nil),
-        prefix: nil,
-        mixed: false
+        prefix: nil
       )
         @elements[name] = XmlMappingRule.new(
           name,
@@ -55,7 +54,6 @@ module Lutaml
           delegate: delegate,
           namespace: namespace,
           prefix: prefix,
-          mixed_content: mixed,
           namespace_set: namespace_set != false,
         )
       end

data/lutaml-model.gemspec

@@ -30,5 +30,7 @@ Gem::Specification.new do |spec|
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
+  spec.add_dependency "bigdecimal"
   spec.add_dependency "thor"
+  spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2024-09-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -55,8 +69,10 @@ files:
 - lib/lutaml/model/comparison.rb
 - lib/lutaml/model/config.rb
 - lib/lutaml/model/error.rb
+- lib/lutaml/model/error/collection_count_out_of_range_error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
 - lib/lutaml/model/error/unknown_adapter_type_error.rb
+- lib/lutaml/model/error/validation_error.rb
 - lib/lutaml/model/json_adapter.rb
 - lib/lutaml/model/json_adapter/json_document.rb
 - lib/lutaml/model/json_adapter/json_object.rb
@@ -72,6 +88,7 @@ files:
 - lib/lutaml/model/schema/relaxng_schema.rb
 - lib/lutaml/model/schema/xsd_schema.rb
 - lib/lutaml/model/schema/yaml_schema.rb
+- lib/lutaml/model/schema_location.rb
 - lib/lutaml/model/serializable.rb
 - lib/lutaml/model/serialize.rb
 - lib/lutaml/model/toml_adapter.rb
@@ -83,6 +100,7 @@ files:
 - lib/lutaml/model/type/date_time.rb
 - lib/lutaml/model/type/time_without_date.rb
 - lib/lutaml/model/utils.rb
+- lib/lutaml/model/validation.rb
 - lib/lutaml/model/version.rb
 - lib/lutaml/model/xml_adapter.rb
 - lib/lutaml/model/xml_adapter/builder/nokogiri.rb
@@ -105,7 +123,8 @@ files:
 homepage: https://github.com/lutaml/lutaml-model
 licenses:
 - BSD-2-Clause
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: