lutaml-model 0.3.0 → 0.3.1

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

@@ -0,0 +1,18 @@
+module Lutaml
+  module Model
+    class InvalidValueError < Error
+      def initialize(attr_name, value, allowed_values)
+        @attr_name = attr_name
+        @value = value
+        @allowed_values = allowed_values
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} is `#{@value}`, must be one of the " \
+          "following [#{@allowed_values.join(', ')}]"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    class Error < StandardError
+    end
+  end
+end
+
+require_relative "error/invalid_value_error"

data/lib/lutaml/model/key_value_mapping.rb

@@ -10,13 +10,21 @@ module Lutaml
         @mappings = []
       end
 
-      def map(name, to:, render_nil: false, with: {}, delegate: nil)
+      def map(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        child_mappings: nil
+      )
         @mappings << KeyValueMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
           with: with,
           delegate: delegate,
+          child_mappings: child_mappings,
         )
       end
 

data/lib/lutaml/model/mapping_rule.rb

@@ -7,7 +7,8 @@ module Lutaml
                   :render_nil,
                   :custom_methods,
                   :delegate,
-                  :mixed_content
+                  :mixed_content,
+                  :child_mappings
 
       def initialize(
         name,
@@ -16,7 +17,8 @@ module Lutaml
         with: {},
         delegate: nil,
         mixed_content: false,
-        namespace_set: false
+        namespace_set: false,
+        child_mappings: nil
       )
         @name = name
         @to = to
@@ -25,6 +27,7 @@ module Lutaml
         @delegate = delegate
         @mixed_content = mixed_content
         @namespace_set = namespace_set
+        @child_mappings = child_mappings
       end
 
       alias from name

data/lib/lutaml/model/serialize.rb

@@ -25,11 +25,23 @@ 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
 
         def attribute(name, type, options = {})
-          self.attributes ||= {}
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
@@ -38,19 +50,22 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
+            if options[:values] && !options[:values].include?(value)
+              raise Lutaml::Model::InvalidValueError.new(name, value, options[:values])
+            end
+
             instance_variable_set(:"@#{name}", value)
           end
         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,12 +74,135 @@ 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
+                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
+            Lutaml::Model::Type.cast(value, attr_rule.type)
+          end
         end
 
         def default_mappings(format)
@@ -77,6 +215,52 @@ module Lutaml
           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 +282,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 +353,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 +381,9 @@ module Lutaml
         end
 
         self.class.attributes.each do |name, attr|
-          value = attr_value(attrs, name, attr)
-
-          send(:"#{name}=", ensure_utf8(value))
-        end
-      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
+          value = self.class.attr_value(attrs, name, attr)
 
-        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 +399,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_rb_adapter.rb

@@ -11,8 +11,8 @@ module Lutaml
           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/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

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

@@ -13,11 +13,12 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Nokogiri::XML::Builder.new do |xml|
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
               root.to_xml(xml)
             else
-              options[:xml_attributes] = build_namespace_attributes(@root.class)
+              mapper_class = options[:mapper_class] || @root.class
+              options[:xml_attributes] = build_namespace_attributes(mapper_class)
               build_element(xml, @root, options)
             end
           end
@@ -32,7 +33,8 @@ module Lutaml
         private
 
         def build_unordered_element(xml, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = options[:xml_attributes] ||= {}
@@ -53,7 +55,7 @@ module Lutaml
             end
 
             xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, element_rule)
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
               next if value.nil? && !element_rule.render_nil?
@@ -79,7 +81,8 @@ module Lutaml
         end
 
         def build_ordered_element(xml, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = build_attributes(element, xml_mapping)&.compact
@@ -106,7 +109,7 @@ module Lutaml
               element_rule = xml_mapping.find_by_name(name)
               next if element_rule.nil?
 
-              attribute_def = attribute_definition_for(element, element_rule)
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
               nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
 
@@ -127,7 +130,12 @@ module Lutaml
 
         def add_to_xml(xml, value, attribute, rule)
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(xml, value, rule)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
           else
             xml.public_send(rule.name) do
               if !value.nil?

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

@@ -14,9 +14,10 @@ module Lutaml
 
         def to_xml(options = {})
           builder = Ox::Builder.new
+
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.to_xml(builder)
-          elsif @root.ordered?
+          elsif ordered?(@root, options)
             build_ordered_element(builder, @root, options)
           else
             build_element(builder, @root, options)
@@ -30,7 +31,8 @@ module Lutaml
         private
 
         def build_unordered_element(builder, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = build_attributes(element, xml_mapping).compact
@@ -45,7 +47,7 @@ module Lutaml
 
           builder.element(prefixed_name, attributes) do |el|
             xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, element_rule)
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
               val = if attribute_def.collection?
@@ -58,7 +60,7 @@ module Lutaml
 
               val.each do |v|
                 if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(el, v, element_rule)
+                  handle_nested_elements(el, v, rule: element_rule, attribute: attribute_def)
                 else
                   builder.element(element_rule.prefixed_name) do |el|
                     el.text(attribute_def.type.serialize(v)) if v
@@ -76,8 +78,9 @@ module Lutaml
           end
         end
 
-        def build_ordered_element(builder, element, _options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+        def build_ordered_element(builder, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = build_attributes(element, xml_mapping).compact
@@ -91,7 +94,7 @@ module Lutaml
 
               element_rule = xml_mapping.find_by_name(name)
 
-              attribute_def = attribute_definition_for(element, element_rule)
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
@@ -110,7 +113,12 @@ module Lutaml
 
         def add_to_xml(xml, value, attribute, rule)
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(xml, value, rule)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
           else
             xml.element(rule.name) do |el|
               if !value.nil?