lutaml-model 0.3.0 → 0.3.2

data/lib/lutaml/model/serialize.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/serialize.rb
 require_relative "yaml_adapter"
 require_relative "xml_adapter"
 require_relative "config"
@@ -25,11 +24,24 @@ module Lutaml
         def inherited(subclass)
           super
 
+          @mappings ||= {}
+          @attributes ||= {}
+
           subclass.instance_variable_set(:@attributes, @attributes.dup)
+          subclass.instance_variable_set(:@mappings, @mappings.dup)
+          subclass.instance_variable_set(:@model, subclass)
         end
 
+        def model(klass = nil)
+          if klass
+            @model = klass
+          else
+            @model
+          end
+        end
+
+        # Define an attribute for the model
         def attribute(name, type, options = {})
-          self.attributes ||= {}
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
@@ -38,19 +50,33 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
+            unless self.class.attr_value_valid?(name, value)
+              raise Lutaml::Model::InvalidValueError.new(name, value, options[:values])
+            end
+
             instance_variable_set(:"@#{name}", 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]
+
+          # If value validation failed but there is a default value, do not
+          # raise a validation error
+          attr.options[:values].include?(value || attr.default)
+        end
+
         FORMATS.each do |format|
           define_method(format) do |&block|
-            self.mappings ||= {}
             klass = format == :xml ? XmlMapping : KeyValueMapping
-            self.mappings[format] = klass.new
-            self.mappings[format].instance_eval(&block)
+            mappings[format] = klass.new
+            mappings[format].instance_eval(&block)
 
-            if format == :xml && !self.mappings[format].root_element
-              self.mappings[format].root(to_s)
+            if format == :xml && !mappings[format].root_element
+              mappings[format].root(model.to_s)
             end
           end
 
@@ -59,24 +85,200 @@ module Lutaml
             doc = adapter.parse(data)
             mapped_attrs = apply_mappings(doc.to_h, format)
             # apply_content_mapping(doc, mapped_attrs) if format == :xml
-            new(mapped_attrs)
+            generate_model_object(self, mapped_attrs)
+          end
+
+          define_method(:"to_#{format}") do |instance|
+            unless instance.is_a?(model)
+              msg = "argument is a '#{instance.class}' but should be a '#{model}'"
+              raise Lutaml::Model::IncorrectModelError, msg
+            end
+
+            adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+
+            if format == :xml
+              xml_options = { mapper_class: self }
+
+              adapter.new(instance).public_send(:"to_#{format}", xml_options)
+            else
+              hash = hash_representation(instance, format)
+              adapter.new(hash).public_send(:"to_#{format}")
+            end
+          end
+        end
+
+        def hash_representation(instance, format, options = {})
+          only = options[:only]
+          except = options[:except]
+          mappings = mappings_for(format).mappings
+
+          mappings.each_with_object({}) do |rule, hash|
+            name = rule.to
+            next if except&.include?(name) || (only && !only.include?(name))
+
+            next handle_delegate(instance, rule, hash) if rule.delegate
+
+            value = if rule.custom_methods[:to]
+                      instance.send(rule.custom_methods[:to], instance, instance.send(name))
+                    else
+                      instance.send(name)
+                    end
+
+            next if value.nil? && !rule.render_nil
+
+            attribute = attributes[name]
+
+            hash[rule.from] = if rule.child_mappings
+                                generate_hash_from_child_mappings(value, rule.child_mappings)
+                              elsif value.is_a?(Array)
+                                value.map do |v|
+                                  if attribute.type <= Serialize
+                                    attribute.type.hash_representation(v, format, options)
+                                  else
+                                    attribute.type.serialize(v)
+                                  end
+                                end
+                              elsif attribute.type <= Serialize
+                                attribute.type.hash_representation(value, format, options)
+                              else
+                                attribute.type.serialize(value)
+                              end
           end
         end
 
+        def handle_delegate(instance, rule, hash)
+          name = rule.to
+          value = instance.send(rule.delegate).send(name)
+          return if value.nil? && !rule.render_nil
+
+          attribute = instance.send(rule.delegate).class.attributes[name]
+          hash[rule.from] = case value
+                            when Array
+                              value.map do |v|
+                                if v.is_a?(Serialize)
+                                  hash_representation(v, format, options)
+                                else
+                                  attribute.type.serialize(v)
+                                end
+                              end
+                            else
+                              if value.is_a?(Serialize)
+                                hash_representation(value, format, options)
+                              else
+                                attribute.type.serialize(value)
+                              end
+                            end
+        end
+
         def mappings_for(format)
-          self.mappings[format] || default_mappings(format)
+          mappings[format] || default_mappings(format)
+        end
+
+        def generate_model_object(type, mapped_attrs)
+          return type.model.new(mapped_attrs) if self == model
+
+          instance = type.model.new
+
+          type.attributes.each do |name, attr|
+            value = attr_value(mapped_attrs, name, attr)
+
+            instance.send(:"#{name}=", ensure_utf8(value))
+          end
+
+          instance
+        end
+
+        def attr_value(attrs, name, attr_rule)
+          value = if attrs.key?(name)
+                    attrs[name]
+                  elsif attrs.key?(name.to_sym)
+                    attrs[name.to_sym]
+                  elsif attrs.key?(name.to_s)
+                    attrs[name.to_s]
+                  else
+                    attr_rule.default
+                  end
+
+          if attr_rule.collection? || value.is_a?(Array)
+            (value || []).map do |v|
+              if v.is_a?(Hash)
+                attr_rule.type.new(v)
+              else
+                # TODO: This code is problematic because Type.cast does not know
+                # about all the types.
+                Lutaml::Model::Type.cast(
+                  v, attr_rule.type
+                )
+              end
+            end
+          elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
+            generate_model_object(attr_rule.type, value)
+          else
+            # TODO: This code is problematic because Type.cast does not know
+            # about all the types.
+            Lutaml::Model::Type.cast(value, attr_rule.type)
+          end
         end
 
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
-              mapping.map_element(name.to_s, to: name,
-                                             render_nil: attr.render_nil?)
+              mapping.map_element(
+                name.to_s,
+                to: name,
+                render_nil: attr.render_nil?,
+              )
             end
           end
         end
 
+        def apply_child_mappings(hash, child_mappings)
+          return hash unless child_mappings
+
+          hash.map do |key, value|
+            child_mappings.to_h do |attr_name, path|
+              attr_value = if path == :key
+                             key
+                           elsif path == :value
+                             value
+                           else
+                             path = [path] unless path.is_a?(Array)
+                             value.dig(*path.map(&:to_s))
+                           end
+
+              [attr_name, attr_value]
+            end
+          end
+        end
+
+        def generate_hash_from_child_mappings(value, child_mappings)
+          return value unless child_mappings
+
+          hash = {}
+
+          value.each do |child_obj|
+            map_key = nil
+            map_value = {}
+            child_mappings.each do |attr_name, path|
+              if path == :key
+                map_key = child_obj.send(attr_name)
+              elsif path == :value
+                map_value = child_obj.send(attr_name)
+              else
+                path = [path] unless path.is_a?(Array)
+                path[0...-1].inject(map_value) do |acc, k|
+                  acc[k.to_s] ||= {}
+                end.public_send(:[]=, path.last.to_s, child_obj.send(attr_name))
+              end
+            end
+            # hash[mapping.name] ||= {}
+            hash[map_key] = map_value
+          end
+
+          hash
+        end
+
         def apply_mappings(doc, format)
           return apply_xml_mapping(doc) if format == :xml
 
@@ -98,6 +300,8 @@ module Lutaml
                       attr.default
                     end
 
+            value = apply_child_mappings(value, rule.child_mappings)
+
             if attr.collection?
               value = (value || []).map do |v|
                 attr.type <= Serialize ? attr.type.apply_mappings(v, format) : v
@@ -167,6 +371,21 @@ module Lutaml
             hash[rule.to] = value
           end
         end
+
+        def ensure_utf8(value)
+          case value
+          when String
+            value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+          when Array
+            value.map { |v| ensure_utf8(v) }
+          when Hash
+            value.transform_keys do |k|
+              ensure_utf8(k)
+            end.transform_values { |v| ensure_utf8(v) }
+          else
+            value
+          end
+        end
       end
 
       attr_reader :element_order
@@ -180,37 +399,9 @@ module Lutaml
         end
 
         self.class.attributes.each do |name, attr|
-          value = attr_value(attrs, name, attr)
-
-          send(:"#{name}=", ensure_utf8(value))
-        end
-      end
+          value = self.class.attr_value(attrs, name, attr)
 
-      def attr_value(attrs, name, attr_rule)
-        value = if attrs.key?(name)
-                  attrs[name]
-                elsif attrs.key?(name.to_sym)
-                  attrs[name.to_sym]
-                elsif attrs.key?(name.to_s)
-                  attrs[name.to_s]
-                else
-                  attr_rule.default
-                end
-
-        if attr_rule.collection? || value.is_a?(Array)
-          (value || []).map do |v|
-            if v.is_a?(Hash)
-              attr_rule.type.new(v)
-            else
-              Lutaml::Model::Type.cast(
-                v, attr_rule.type
-              )
-            end
-          end
-        elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
-          attr_rule.type.new(value)
-        else
-          Lutaml::Model::Type.cast(value, attr_rule.type)
+          send(:"#{name}=", self.class.ensure_utf8(value))
         end
       end
 
@@ -226,119 +417,16 @@ module Lutaml
         hash[key] || hash[key.to_sym] || hash[key.to_s]
       end
 
-      # TODO: Make this work
-      # FORMATS.each do |format|
-      #   define_method("to_#{format}") do |options = {}|
-      #     adapter = Lutaml::Model::Config.send("#{format}_adapter")
-      #     representation = if format == :yaml
-      #                        self
-      #                      else
-      #                        hash_representation(format, options)
-      #                      end
-      #     adapter.new(representation).send("to_#{format}", options)
-      #   end
-      # end
-
-      def to_xml(options = {})
-        adapter = Lutaml::Model::Config.xml_adapter
-        adapter.new(self).to_xml(options)
-      end
-
-      def to_json(options = {})
-        adapter = Lutaml::Model::Config.json_adapter
-        adapter.new(hash_representation(:json, options)).to_json(options)
-      end
-
-      def to_yaml(options = {})
-        adapter = Lutaml::Model::Config.yaml_adapter
-        adapter.to_yaml(self, options)
-      end
-
-      def to_toml(options = {})
-        adapter = Lutaml::Model::Config.toml_adapter
-        adapter.new(hash_representation(:toml, options)).to_toml
-      end
-
-      # TODO: END Make this work
-
-      def hash_representation(format, options = {})
-        only = options[:only]
-        except = options[:except]
-        mappings = self.class.mappings_for(format).mappings
-
-        mappings.each_with_object({}) do |rule, hash|
-          name = rule.to
-          next if except&.include?(name) || (only && !only.include?(name))
-
-          next handle_delegate(self, rule, hash) if rule.delegate
-
-          value = if rule.custom_methods[:to]
-                    send(rule.custom_methods[:to], self, send(name))
-                  else
-                    send(name)
-                  end
-
-          next if value.nil? && !rule.render_nil
-
-          attribute = self.class.attributes[name]
-
-          hash[rule.from] = case value
-                            when Array
-                              value.map do |v|
-                                if v.is_a?(Serialize)
-                                  v.hash_representation(format, options)
-                                else
-                                  attribute.type.serialize(v)
-                                end
-                              end
-                            else
-                              if value.is_a?(Serialize)
-                                value.hash_representation(format, options)
-                              else
-                                attribute.type.serialize(value)
-                              end
-                            end
-        end
-      end
-
-      private
-
-      def handle_delegate(_obj, rule, hash)
-        name = rule.to
-        value = send(rule.delegate).send(name)
-        return if value.nil? && !rule.render_nil
-
-        attribute = send(rule.delegate).class.attributes[name]
-        hash[rule.from] = case value
-                          when Array
-                            value.map do |v|
-                              if v.is_a?(Serialize)
-                                v.hash_representation(format, options)
-                              else
-                                attribute.type.serialize(v)
-                              end
-                            end
-                          else
-                            if value.is_a?(Serialize)
-                              value.hash_representation(format, options)
-                            else
-                              attribute.type.serialize(value)
-                            end
-                          end
-      end
+      FORMATS.each do |format|
+        define_method(:"to_#{format}") do |options = {}|
+          adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+          representation = if format == :xml
+                             self
+                           else
+                             self.class.hash_representation(self, format, options)
+                           end
 
-      def ensure_utf8(value)
-        case value
-        when String
-          value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
-        when Array
-          value.map { |v| ensure_utf8(v) }
-        when Hash
-          value.transform_keys do |k|
-            ensure_utf8(k)
-          end.transform_values { |v| ensure_utf8(v) }
-        else
-          value
+          adapter.new(representation).public_send(:"to_#{format}", options)
         end
       end
     end

data/lib/lutaml/model/toml_adapter/toml_document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "toml_object"
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      # Base class for TOML documents
+      class TomlDocument < TomlObject
+        def self.parse(toml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_toml(*args)
+          raise NotImplementedError, "Subclasses must implement `to_toml`."
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter/toml_object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module TomlAdapter
+      # Base class for TOML objects
+      class TomlObject
+        attr_reader :attributes
+
+        def initialize(attributes = {})
+          @attributes = attributes
+        end
+
+        def [](key)
+          @attributes[key]
+        end
+
+        def []=(key, value)
+          @attributes[key] = value
+        end
+
+        def to_h
+          @attributes
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml_adapter/toml_rb_adapter.rb

@@ -1,18 +1,17 @@
-# lib/lutaml/model/toml_adapter/toml_rb_adapter.rb
 require "toml-rb"
-require_relative "../toml_adapter"
+require_relative "toml_document"
 
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlRbDocument < Document
+      class TomlRbAdapter < TomlDocument
         def self.parse(toml)
           data = TomlRB.parse(toml)
           new(data)
         end
 
-        def to_toml(*args)
-          TomlRB.dump(to_h, *args)
+        def to_toml(*)
+          TomlRB.dump(to_h)
         end
       end
     end

data/lib/lutaml/model/toml_adapter/tomlib_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/toml_adapter/tomlib_adapter.rb
 require "tomlib"
-require_relative "../toml_adapter"
+require_relative "toml_document"
 
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlibDocument < Document
+      class TomlibAdapter < TomlDocument
         def self.parse(toml)
           data = Tomlib.load(toml)
           new(data)

data/lib/lutaml/model/toml_adapter.rb

@@ -1,37 +1,6 @@
-# lib/lutaml/model/toml_adapter.rb
-
 module Lutaml
   module Model
     module TomlAdapter
-      class TomlObject
-        attr_reader :attributes
-
-        def initialize(attributes = {})
-          @attributes = attributes
-        end
-
-        def [](key)
-          @attributes[key]
-        end
-
-        def []=(key, value)
-          @attributes[key] = value
-        end
-
-        def to_h
-          @attributes
-        end
-      end
-
-      class Document < TomlObject
-        def self.parse(toml)
-          raise NotImplementedError, "Subclasses must implement `parse`."
-        end
-
-        def to_toml(*args)
-          raise NotImplementedError, "Subclasses must implement `to_toml`."
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+require "date"
+
+module Lutaml
+  module Model
+    module Type
+      # Date and time representation
+      class DateTime
+        def self.cast(value)
+          return if value.nil?
+
+          ::DateTime.parse(value.to_s).new_offset(0)
+        end
+
+        def self.serialize(value)
+          value.iso8601
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "json"
+
+module Lutaml
+  module Model
+    module Type
+      # JSON representation
+      class Json
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_json(*_args)
+          @value.to_json
+        end
+
+        def ==(other)
+          @value == (other.is_a?(::Hash) ? other : other.value)
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self) || value.nil?
+
+          new(::JSON.parse(value))
+        end
+
+        def self.serialize(value)
+          value.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -1,11 +1,12 @@
-# lib/lutaml/model/type/time_without_date.rb
 module Lutaml
   module Model
     module Type
+      # Time representation without date
       class TimeWithoutDate
         def self.cast(value)
-          parsed_time = ::Time.parse(value.to_s)
-          parsed_time.strftime("%H:%M:%S")
+          return if value.nil?
+
+          ::Time.parse(value.to_s)
         end
 
         def self.serialize(value)