lutaml-model 0.2.1 → 0.3.1

data/lib/lutaml/model/serialize.rb

@@ -1,14 +1,11 @@
 # lib/lutaml/model/serialize.rb
-require_relative "json_adapter/standard"
-require_relative "json_adapter/multi_json"
 require_relative "yaml_adapter"
 require_relative "xml_adapter"
-require_relative "toml_adapter/toml_rb_adapter"
-require_relative "toml_adapter/tomlib_adapter"
 require_relative "config"
 require_relative "type"
 require_relative "attribute"
 require_relative "mapping_rule"
+require_relative "mapping_hash"
 require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
@@ -22,16 +19,29 @@ module Lutaml
         base.extend(ClassMethods)
       end
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/BlockLength
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       module ClassMethods
         attr_accessor :attributes, :mappings
 
+        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
 
@@ -40,29 +50,159 @@ 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 && !mappings[format].root_element
+              mappings[format].root(model.to_s)
+            end
           end
 
           define_method(:"from_#{format}") do |data|
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
             doc = adapter.parse(data)
             mapped_attrs = apply_mappings(doc.to_h, format)
-            apply_content_mapping(doc, mapped_attrs) if format == :xml
-            new(mapped_attrs)
+            # apply_content_mapping(doc, mapped_attrs) if format == :xml
+            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)
@@ -75,11 +215,57 @@ 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
 
           mappings = mappings_for(format).mappings
-          mappings.each_with_object({}) do |rule, hash|
+          mappings.each_with_object(Lutaml::Model::MappingHash.new) do |rule, hash|
             attr = if rule.delegate
                      attributes[rule.delegate].type.attributes[rule.to]
                    else
@@ -95,15 +281,8 @@ module Lutaml
                     else
                       attr.default
                     end
-            # if attr.collection?
-            #   value = (value || []).map do |v|
-            #     attr.type <= Serialize ? attr.type.new(v) : v
-            #   end
-            # elsif value.is_a?(Hash) && attr.type <= Serialize
-            #   value = attr.type.new(value)
-            # else
-            #   value = attr.type.cast(value)
-            # end
+
+            value = apply_child_mappings(value, rule.child_mappings)
 
             if attr.collection?
               value = (value || []).map do |v|
@@ -122,214 +301,116 @@ module Lutaml
           end
         end
 
-        def apply_xml_mapping(doc)
+        def apply_xml_mapping(doc, caller_class: nil, mixed_content: false)
+          return unless doc
+
           mappings = mappings_for(:xml).mappings
 
-          mappings.each_with_object({}) do |rule, hash|
+          if doc.is_a?(Array)
+            raise "May be `collection: true` is" \
+                  "missing for #{self} in #{caller_class}"
+          end
+
+          mapping_hash = Lutaml::Model::MappingHash.new
+          mapping_hash.item_order = doc.item_order
+          mapping_hash.ordered = mappings_for(:xml).mixed_content? || mixed_content
+
+          mappings.each_with_object(mapping_hash) do |rule, hash|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = if rule.name
-                      doc[rule.name.to_s] || doc[rule.name.to_sym]
-                    else
+            is_content_mapping = rule.name.nil?
+            value = if is_content_mapping
                       doc["text"]
+                    else
+                      doc[rule.name.to_s] || doc[rule.name.to_sym]
                     end
 
-            # if attr.collection?
-            #   value = (value || []).map do |v|
-            #     attr.type <= Serialize ? attr.type.from_hash(v) : v
-            #   end
-            # elsif value.is_a?(Hash) && attr.type <= Serialize
-            #   value = attr.type.cast(value)
-            # elsif value.is_a?(Array)
-            #   value = attr.type.cast(value.first["text"]&.first)
-            # end
-
             if attr.collection?
+              if value && !value.is_a?(Array)
+                value = [value]
+              end
+
               value = (value || []).map do |v|
                 if attr.type <= Serialize
-                  attr.type.apply_xml_mapping(v)
-                else
+                  attr.type.apply_xml_mapping(v, caller_class: self, mixed_content: rule.mixed_content)
+                elsif v.is_a?(Hash)
                   v["text"]
+                else
+                  v
                 end
               end
             elsif attr.type <= Serialize
-              value = attr.type.apply_xml_mapping(value) if value
+              value = attr.type.apply_xml_mapping(value, caller_class: self, mixed_content: rule.mixed_content)
             else
               if value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
                 value = value["text"]
               end
 
-              value = attr.type.cast(value)
+              value = attr.type.cast(value) unless is_content_mapping
             end
+
             hash[rule.to] = value
           end
         end
 
-        def apply_content_mapping(doc, mapped_attrs)
-          content_mapping = mappings_for(:xml).content_mapping
-          return unless content_mapping
-
-          content = doc.root.children.select(&:text?).map(&:text)
-          mapped_attrs[content_mapping.to] = content
+        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
 
-      # rubocop:disable Layout/LineLength
+      attr_reader :element_order
+
       def initialize(attrs = {})
         return unless self.class.attributes
 
+        if attrs.is_a?(Lutaml::Model::MappingHash)
+          @ordered = attrs.ordered?
+          @element_order = attrs.item_order
+        end
+
         self.class.attributes.each do |name, attr|
-          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.default
-                  end
+          value = self.class.attr_value(attrs, name, attr)
 
-          value = if attr.collection?
-                    (value || []).map do |v|
-                      if v.is_a?(Hash)
-                        attr.type.new(v)
-                      else
-                        Lutaml::Model::Type.cast(
-                          v, attr.type
-                        )
-                      end
-                    end
-                  elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-                    attr.type.new(value)
-                  else
-                    Lutaml::Model::Type.cast(value, attr.type)
-                  end
-          send(:"#{name}=", ensure_utf8(value))
+          send(:"#{name}=", self.class.ensure_utf8(value))
         end
       end
-      # rubocop:enable Layout/LineLength
-
-      # 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)
+      def ordered?
+        @ordered
       end
 
-      def to_toml(options = {})
-        adapter = Lutaml::Model::Config.toml_adapter
-        adapter.new(hash_representation(:toml, options)).to_toml
+      def key_exist?(hash, key)
+        hash.key?(key) || hash.key?(key.to_sym) || hash.key?(key.to_s)
       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
+      def key_value(hash, key)
+        hash[key] || hash[key.to_sym] || hash[key.to_s]
       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
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/BlockLength
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     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/type.rb

@@ -74,6 +74,24 @@ module Lutaml
         end
       end
 
+      class TextWithTags
+        attr_reader :content
+
+        def initialize(ordered_text_with_tags)
+          @content = ordered_text_with_tags
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self)
+
+          new(value)
+        end
+
+        def self.serialize(value)
+          value.content.join
+        end
+      end
+
       class JSON
         attr_reader :value
 
@@ -94,7 +112,7 @@ module Lutaml
         end
 
         def self.cast(value)
-          return value if value.is_a?(self)
+          return value if value.is_a?(self) || value.nil?
 
           new(::JSON.parse(value))
         end
@@ -104,15 +122,8 @@ module Lutaml
         end
       end
 
-      # rubocop:disable Layout/LineLength
       UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
-      # rubocop:enable Layout/LineLength
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Layout/LineLength
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       def self.cast(value, type)
         return if value.nil?
 
@@ -203,11 +214,6 @@ module Lutaml
           end
         end.to_h
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Layout/LineLength
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/lutaml/model/version.rb

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