lutaml-model 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12f6b0d44c864c56f2573bae9a712485e0b266120fe53f342671b8cb144ce022
-  data.tar.gz: 3facbc5cc6ef8149f1628415f3d511c2e010de28f8ab5968f2e436eb6aa41b39
+  metadata.gz: 5140f93f22f4b05222edc408aeca50552082e447b71fddd724b34ba9e6b82d55
+  data.tar.gz: 0aa44a3c72b65cca0ed2b7411614d8cdb0c44b4e8293e183935cb45ba7818d7c
 SHA512:
-  metadata.gz: 0157ca6aa7a9e0e0368fd1da623068670d033a54385b91aa45082412512f5ee1643d72da168d5b68fdef531034f49363417dbfce31c4b47452c8f1d0136d839d
-  data.tar.gz: cf6c69e91f9eb13275a845ee4253809cc60599527a26f28d13942fa26b10ce65bfbc6a6fed8fbc946a721a1d07edd8b98289447c668f7d8cba6dc3cd001bc85b
+  metadata.gz: 69e4d0d0a3a5bd19e11a43fd33e03566ca035d18cf948a0a2fc5abe5f880489e4a6ad347d8118a04c35c8c95be5b7eb29ca93d426643c7790ab045db2b34721c
+  data.tar.gz: df1699ba6647f53f97735d0986b92bf8f76d6bf44430117406100b257f5934ac4a7baa6a4243bb8384db277ecb975bf64efe2f1a16b293739b245150e800cb15

data/.rubocop_todo.yml

@@ -1,27 +1,26 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2024-09-04 07:55:32 UTC using RuboCop version 1.66.0.
+# on 2024-09-10 23:53:08 UTC using RuboCop version 1.66.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: Severity, Include.
-# Include: **/*.gemspec
-Gemspec/RequireMFA:
-  Exclude:
-    - 'lutaml-model.gemspec'
-
-# Offense count: 62
+# Offense count: 88
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 10
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowInHeredoc.
+Layout/TrailingWhitespace:
+  Exclude:
+    - 'lib/lutaml/model/schema_location.rb'
+
+# Offense count: 11
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: enums
 Lint/ConstantDefinitionInBlock:
@@ -30,12 +29,19 @@ Lint/ConstantDefinitionInBlock:
     - 'spec/lutaml/model/schema/relaxng_schema_spec.rb'
     - 'spec/lutaml/model/schema/xsd_schema_spec.rb'
     - 'spec/lutaml/model/schema/yaml_schema_spec.rb'
+    - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
-# Offense count: 29
+# Offense count: 1
+Lint/DuplicateMethods:
+  Exclude:
+    - 'lib/lutaml/model/attribute.rb'
+
+# Offense count: 31
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
+    - 'lib/lutaml/model/attribute.rb'
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/schema/relaxng_schema.rb'
     - 'lib/lutaml/model/schema/xsd_schema.rb'
@@ -51,7 +57,7 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Max: 42
 
-# Offense count: 22
+# Offense count: 25
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -63,17 +69,17 @@ Metrics/CyclomaticComplexity:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 36
+# Offense count: 39
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 43
+  Max: 49
 
 # Offense count: 4
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
   Max: 9
 
-# Offense count: 18
+# Offense count: 21
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
@@ -94,7 +100,7 @@ RSpec/ContextWording:
     - 'spec/lutaml/model/xml_adapter/ox_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
-# Offense count: 86
+# Offense count: 101
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 57
@@ -105,13 +111,14 @@ RSpec/IndexedLet:
   Exclude:
     - 'spec/address_spec.rb'
 
-# Offense count: 18
+# Offense count: 19
 RSpec/LeakyConstantDeclaration:
   Exclude:
     - 'spec/lutaml/model/schema/json_schema_spec.rb'
     - 'spec/lutaml/model/schema/relaxng_schema_spec.rb'
     - 'spec/lutaml/model/schema/xsd_schema_spec.rb'
     - 'spec/lutaml/model/schema/yaml_schema_spec.rb'
+    - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
 # Offense count: 4
@@ -122,23 +129,29 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_adapter_spec.rb'
 
-# Offense count: 75
+# Offense count: 88
 RSpec/MultipleExpectations:
   Max: 11
 
-# Offense count: 11
+# Offense count: 17
 # Configuration parameters: AllowSubject.
 RSpec/MultipleMemoizedHelpers:
   Max: 9
 
-# Offense count: 4
+# Offense count: 7
 RSpec/PendingWithoutReason:
   Exclude:
     - 'spec/lutaml/model/mixed_content_spec.rb'
+    - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/oga_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_adapter_spec.rb'
 
+# Offense count: 2
+RSpec/RepeatedExampleGroupDescription:
+  Exclude:
+    - 'spec/lutaml/model/collection_spec.rb'
+
 # Offense count: 1
 # Configuration parameters: Include, CustomTransform, IgnoreMethods, IgnoreMetadata.
 # Include: **/*_spec.rb
@@ -152,6 +165,11 @@ Security/CompoundHash:
   Exclude:
     - 'lib/lutaml/model/comparable_model.rb'
 
+# Offense count: 1
+Style/MissingRespondToMissing:
+  Exclude:
+    - 'lib/lutaml/model/serialize.rb'
+
 # Offense count: 1
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: respond_to_missing?

data/README.adoc

@@ -204,11 +204,45 @@ end
 Define attributes as collections (arrays or hashes) to store multiple values
 using the `collection` option.
 
+`collection` can be set to:
+
+`true`:::
+The attribute contains an unbounded collection of objects of the declared class.
+
+`{min}..{max}`:::
+The attribute contains a collection of objects of the declared class with a
+count within the specified range.
+If the number of objects is out of this numbered range,
+`CollectionCountOutOfRangeError` will be raised.
++
+[example]
+====
+When set to `0..1`, it means that the attribute is optional, it could be empty
+or contain one object of the declared class.
+====
++
+[example]
+====
+When set to `1..` (equivalent to `1..Infinity`), it means that the
+attribute must contain at least one object of the declared class and can contain
+any number of objects.
+====
++
+[example]
+====
+When set to 5..10` means that there is a minimum of 5 and a maximum of 10
+objects of the declared class. If the count of values for the attribute is less
+then 5 or greater then 10, the `CollectionCountOutOfRangeError` will be raised.
+====
+
+
 Syntax:
 
 [source,ruby]
 ----
 attribute :name_of_attribute, Type, collection: true
+attribute :name_of_attribute, Type, collection: {min}..{max}
+attribute :name_of_attribute, Type, collection: {min}..
 ----
 
 .Using the `collection` option to define a collection attribute
@@ -219,18 +253,27 @@ attribute :name_of_attribute, Type, collection: true
 class Studio < Lutaml::Model::Serializable
   attribute :location, :string
   attribute :potters, :string, collection: true
+  attribute :address, :string, collection: 1..2
+  attribute :hobbies, :string, collection: 0..
 end
 ----
 
 [source,ruby]
 ----
-> Studio.new.potters
+> Studio.new
+> # address count is `0`, must be between 1 and 2  (Lutaml::Model::CollectionCountOutOfRangeError)
+> Studio.new({ address: ["address 1", "address 2", "address 3"] })
+> # address count is `3`, must be between 1 and 2  (Lutaml::Model::CollectionCountOutOfRangeError)
+> Studio.new({ address: ["address 1"] }).potters
 > # []
-> Studio.new(potters: ['John Doe', 'Jane Doe']).potters
+> Studio.new({ address: ["address 1"] }).address
+> # ["address 1"]
+> Studio.new(address: ["address 1"], potters: ['John Doe', 'Jane Doe']).potters
 > # ['John Doe', 'Jane Doe']
 ----
 ====
 
+
 [[attribute-enumeration]]
 === Attribute as an enumeration
 
@@ -947,6 +990,125 @@ end
 TODO: How to create mixed content from `#new`?
 
 
+==== Automatic support of `xsi:schemaLocation`
+
+The
+https://www.w3.org/TR/xmlschema-1/#xsi_schemaLocation[W3C "XMLSchema-instance"]
+namespace describes a number of attributes that can be used to control the
+behavior of XML processors. One of these attributes is `xsi:schemaLocation`.
+
+The `xsi:schemaLocation` attribute locates schemas for elements and attributes
+that are in a specified namespace. Its value consists of pairs of a namespace
+URI followed by a relative or absolute URL where the schema for that namespace
+can be found.
+
+Usage of `xsi:schemaLocation` in an XML element depends on the declaration of
+the XML namespace of `xsi`, i.e.
+`xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"`. Without this namespace
+LutaML will not be able to serialize the `xsi:schemaLocation` attribute.
+
+NOTE: It is most commonly attached to the root element but can appear further
+down the tree.
+
+The following snippet shows how `xsi:schemaLocation` is used in an XML document:
+
+[source,xml]
+----
+<cera:Ceramic
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:cera="http://example.com/ceramic"
+  xmlns:clr='http://example.com/color'
+  xsi:schemaLocation=
+    "http://example.com/ceramic http://example.com/ceramic.xsd
+     http://example.com/color http://example.com/color.xsd"
+  clr:color="navy-blue">
+  <cera:Type>Porcelain</cera:Type>
+  <Glaze>Clear</Glaze>
+</cera:Ceramic>
+----
+
+LutaML::Model supports the `xsi:schemaLocation` attribute in all XML
+serializations by default, through the `schema_location` attribute on the model
+instance object.
+
+.Retrieving and setting the `xsi:schemaLocation` attribute in XML serialization
+[example]
+====
+In this example, the `xsi:schemaLocation` attribute will be automatically
+supplied without the explicit need to define in the model, and allows for
+round-trip serialization.
+
+[source,ruby]
+----
+class Ceramic < Lutaml::Model::Serializable
+  attribute :type, :string
+  attribute :glaze, :string
+  attribute :color, :string
+
+  xml do
+    root 'Ceramic'
+    namespace 'http://example.com/ceramic', 'cera'
+    map_element 'Type', to: :type, namespace: :inherit
+    map_element 'Glaze', to: :glaze
+    map_attribute 'color', to: :color, namespace: 'http://example.com/color', prefix: 'clr'
+  end
+end
+
+xml_content = <<~HERE
+<cera:Ceramic
+  xmlns:cera="http://example.com/ceramic"
+  xmlns:clr="http://example.com/color"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  clr:color="navy-blue"
+  xsi:schemaLocation="
+    http://example.com/ceramic http://example.com/ceramic.xsd
+    http://example.com/color http://example.com/color.xsd
+  ">
+  <cera:Type>Porcelain</cera:Type>
+  <Glaze>Clear</Glaze>
+</cera:Ceramic>
+HERE
+----
+
+[source,ruby]
+----
+> c = Ceramic.from_xml(xml_content)
+=>
+#<Ceramic:0x00000001222bdd60
+...
+> schema_loc = c.schema_location
+#<Lutaml::Model::SchemaLocation:0x0000000122773760
+...
+> schema_loc
+=>
+#<Lutaml::Model::SchemaLocation:0x0000000122773760
+ @namespace="http://www.w3.org/2001/XMLSchema-instance",
+ @original_schema_location="http://example.com/ceramic http://example.com/ceramic.xsd http://example.com/color http://example.com/color.xsd",
+ @prefix="xsi",
+ @schema_location=
+  [#<Lutaml::Model::Location:0x00000001222bd018 @location="http://example.com/ceramic.xsd", @namespace="http://example.com/ceramic">,
+   #<Lutaml::Model::Location:0x00000001222bcfc8 @location="http://example.com/color.xsd", @namespace="http://example.com/color">]>
+> new_c = Ceramic.new(type: "Porcelain", glaze: "Clear", color: "navy-blue", schema_location: schema_loc).to_xml
+> puts new_c
+# <cera:Ceramic
+#   xmlns:cera="http://example.com/ceramic"
+#   xmlns:clr="http://example.com/color"
+#   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+#   clr:color="navy-blue"
+#   xsi:schemaLocation="
+#     http://example.com/ceramic http://example.com/ceramic.xsd
+#     http://example.com/color http://example.com/color.xsd
+#   ">
+#   <cera:Type>Porcelain</cera:Type>
+#   <cera:Glaze>Clear</cera:Glaze>
+# </cera:Ceramic>
+----
+====
+
+NOTE: For details on `xsi:schemaLocation`, please refer to the
+https://www.w3.org/TR/xmlschema-1/#xsi_schemaLocation[W3C XML standard].
+
+
 
 === Key value data models
 
@@ -1333,12 +1495,12 @@ class CustomCeramic < Lutaml::Model::Serializable
     map 'size', to: :size
   end
 
-  def name_to_json(model, value)
-    doc["name"] = "Masterpiece: #{value}"
+  def name_to_json(model, doc)
+    doc["name"] = "Masterpiece: #{model.name}"
   end
 
-  def name_from_json(model, doc)
-    model.name = value.sub(/^JSON Masterpiece: /, '')
+  def name_from_json(model, value)
+    model.name = value.sub(/^Masterpiece: /, '')
   end
 end
 ----
@@ -1547,6 +1709,101 @@ In this example:
 ====
 
 
+== Validation
+
+=== General
+
+Lutaml::Model provides a way to validate data models using the `validate` and
+`validate!` methods.
+
+* The `validate` method sets an `errors` array in the model instance that
+contains all the validation errors. This method is used for checking the
+validity of the model silently.
+
+* The `validate!` method raises a `Lutaml::Model::ValidationError` that contains
+all the validation errors. This method is used for forceful validation of the
+model through raising an error.
+
+Lutaml::Model supports the following validation methods:
+
+* `collection`:: Validates collection size range.
+* `values`:: Validates the value of an attribute from a set of fixed values.
+
+[example]
+====
+The following class will validate the `degree_settings` attribute to ensure that
+it has at least one element and that the `description` attribute is one of the
+values in the set `[one, two, three]`.
+
+[source,ruby]
+----
+class Klin < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :degree_settings, :integer, collection: (1..)
+  attribute :description, :string, values: %w[one two three]
+
+  xml do
+    map_element 'name', to: :name
+    map_attribute 'degree_settings', to: :degree_settings
+  end
+end
+
+klin = Klin.new(name: "Klin", degree_settings: [100, 200, 300], description: "one")
+klin.validate
+# => []
+
+klin = Klin.new(name: "Klin", degree_settings: [], description: "four")
+klin.validate
+# => [
+#      #<Lutaml::Model::CollectionSizeError: degree_settings must have at least 1 element>,
+#      #<Lutaml::Model::ValueError: description must be one of [one, two, three]>
+#    ]
+
+e = klin.validate!
+# => Lutaml::Model::ValidationError: [
+#      degree_settings must have at least 1 element,
+#      description must be one of [one, two, three]
+#    ]
+e.errors
+# => [
+#     #<Lutaml::Model::CollectionSizeError: degree_settings must have at least 1 element>,
+#     #<Lutaml::Model::ValueError: description must be one of [one, two, three]>
+#   ]
+----
+====
+
+=== Custom validation
+
+To add custom validation, override the `validate` method in the model class.
+Additional errors should be added to the `errors` array.
+
+[example]
+====
+The following class validates the `degree_settings` attribute when the `type` is
+`glass` to ensure that the value is less than 1300.
+
+[source,ruby]
+----
+class Klin < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :type, :string, values: %w[glass ceramic]
+  attribute :degree_settings, :integer, collection: (1..)
+
+  def validate
+    errors = super
+    if type == "glass" && degree_settings.any? { |d| d > 1300 }
+      errors << Lutaml::Model::Error.new("Degree settings for glass must be less than 1300")
+    end
+  end
+end
+
+klin = Klin.new(name: "Klin", type: "glass", degree_settings: [100, 200, 1400])
+klin.validate
+# => [#<Lutaml::Model::Error: Degree settings for glass must be less than 1300>]
+----
+====
+
+
 == Adapters
 
 === General

data/lib/lutaml/model/attribute.rb

@@ -6,11 +6,11 @@ module Lutaml
       def initialize(name, type, options = {})
         @name = name
         @type = cast_type(type)
-
         @options = options
 
-        if collection? && !options[:default]
-          @options[:default] = -> { [] }
+        if collection?
+          validate_collection_range
+          @options[:default] = -> { [] } unless options[:default]
         end
       end
 
@@ -31,6 +31,10 @@ module Lutaml
         options[:collection] || false
       end
 
+      def singular?
+        !collection?
+      end
+
       def default
         return options[:default].call if options[:default].is_a?(Proc)
 
@@ -41,6 +45,113 @@ module Lutaml
         options.fetch(:render_nil, false)
       end
 
+      def enum_values
+        @options.key?(:values) ? @options[:values] : []
+      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)
+      end
+
+      def valid_value!(value)
+        return true if value.nil? && !collection?
+        return true if enum_values.empty?
+
+        unless valid_value?(value)
+          raise Lutaml::Model::InvalidValueError.new(name, value, enum_values)
+        end
+
+        true
+      end
+
+      def valid_value?(value)
+        return true unless options[:values]
+
+        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?
+
+        # Use the default value if the value is nil
+        value = default if value.nil?
+
+        valid_value!(value) && valid_collection!(value)
+      end
+
+      def validate_collection_range
+        range = @options[:collection]
+        return if range == true
+
+        unless range.is_a?(Range)
+          raise ArgumentError, "Invalid collection range: #{range}"
+        end
+
+        if range.begin.nil?
+          raise ArgumentError,
+                "Invalid collection range: #{range}. Begin must be specified."
+        end
+
+        if range.begin.negative?
+          raise ArgumentError,
+                "Invalid collection range: #{range}. Begin must be non-negative."
+        end
+
+        if range.end && range.end < range.begin
+          raise ArgumentError,
+                "Invalid collection range: #{range}. End must be greater than or equal to begin."
+        end
+      end
+
+      def valid_collection!(value)
+        return true unless collection?
+
+        # Allow nil values for collections during initialization
+        return true if value.nil?
+
+        # Allow any value for unbounded collections
+        return true if options[:collection] == true
+
+        unless value.is_a?(Array)
+          raise Lutaml::Model::CollectionCountOutOfRangeError.new(
+            name,
+            value,
+            options[:collection],
+          )
+        end
+
+        range = options[:collection]
+        return true unless range.is_a?(Range)
+
+        if range.end.nil?
+          if value.size < range.begin
+            raise Lutaml::Model::CollectionCountOutOfRangeError.new(
+              name,
+              value,
+              range,
+            )
+          end
+        elsif !range.cover?(value.size)
+          raise Lutaml::Model::CollectionCountOutOfRangeError.new(
+            name,
+            value,
+            range,
+          )
+        end
+      end
+
       def serialize(value, format, options = {})
         if value.is_a?(Array)
           value.map do |v|

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)
@@ -316,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
@@ -376,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)
@@ -386,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
 
-          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 +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
@@ -425,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.9"
+    VERSION = "0.3.10"
   end
 end

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]

data/lutaml-model.gemspec

@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "bigdecimal"
   spec.add_dependency "thor"
+  spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-04 00:00:00.000000000 Z
+date: 2024-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -69,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
@@ -86,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
@@ -97,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
@@ -119,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: