lutaml-model 0.3.5 → 0.3.7

data/lib/lutaml/model/serialize.rb

@@ -13,8 +13,6 @@ require_relative "comparable_model"
 module Lutaml
   module Model
     module Serialize
-      FORMATS = %i[xml json yaml toml].freeze
-
       include ComparableModel
 
       def self.included(base)
@@ -73,7 +71,7 @@ module Lutaml
           attr.options[:values].include?(value)
         end
 
-        FORMATS.each do |format|
+        Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
             mappings[format] = klass.new
@@ -87,9 +85,8 @@ module Lutaml
           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
-            generate_model_object(self, mapped_attrs)
+
+            apply_mappings(doc.to_h, format)
           end
 
           define_method(:"to_#{format}") do |instance|
@@ -120,13 +117,14 @@ module Lutaml
             name = rule.to
             next if except&.include?(name) || (only && !only.include?(name))
 
-            next handle_delegate(instance, rule, hash) if rule.delegate
+            next handle_delegate(instance, rule, hash, format) if rule.delegate
 
-            value = if rule.custom_methods[:to]
-                      instance.send(rule.custom_methods[:to], instance, instance.send(name))
-                    else
-                      instance.send(name)
-                    end
+            if rule.custom_methods[:to]
+              next instance.send(rule.custom_methods[:to], instance,
+                                 hash)
+            end
+
+            value = instance.send(name)
 
             next if value.nil? && !rule.render_nil
 
@@ -134,68 +132,27 @@ module Lutaml
 
             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)
+                                attribute.serialize(value, format, options)
                               end
           end
         end
 
-        def handle_delegate(instance, rule, hash)
+        def handle_delegate(instance, rule, hash, format)
           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
+          hash[rule.from] = attribute.serialize(value, format)
         end
 
         def mappings_for(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)
+          value = if attrs.key?(name.to_sym)
                     attrs[name.to_sym]
                   elsif attrs.key?(name.to_s)
                     attrs[name.to_s]
@@ -213,8 +170,6 @@ module Lutaml
                 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.
@@ -281,11 +236,12 @@ module Lutaml
           hash
         end
 
-        def apply_mappings(doc, format)
-          return apply_xml_mapping(doc) if format == :xml
+        def apply_mappings(doc, format, options = {})
+          instance = options[:instance] || model.new
+          return apply_xml_mapping(doc, instance, options) if format == :xml
 
           mappings = mappings_for(format).mappings
-          mappings.each_with_object(Lutaml::Model::MappingHash.new) do |rule, hash|
+          mappings.each do |rule|
             attr = if rule.delegate
                      attributes[rule.delegate].type.attributes[rule.to]
                    else
@@ -294,50 +250,51 @@ module Lutaml
 
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = if rule.custom_methods[:from]
-                      new.send(rule.custom_methods[:from], hash, doc)
-                    elsif doc.key?(rule.name) || doc.key?(rule.name.to_sym)
+            value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
                       doc[rule.name] || doc[rule.name.to_sym]
                     else
                       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
-              end
-            elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-              value = attr.type.apply_mappings(value, format)
+            if rule.custom_methods[:from]
+              value = new.send(rule.custom_methods[:from], instance, value)
+              next
             end
 
+            value = apply_child_mappings(value, rule.child_mappings)
+            value = attr.cast(value, format)
+
             if rule.delegate
-              hash[rule.delegate] ||= {}
-              hash[rule.delegate][rule.to] = value
+              if instance.public_send(rule.delegate).nil?
+                instance.public_send(:"#{rule.delegate}=",
+                                     attributes[rule.delegate].type.new)
+              end
+              instance.public_send(rule.delegate).public_send(:"#{rule.to}=",
+                                                              value)
             else
-              hash[rule.to] = value
+              instance.public_send(:"#{rule.to}=", value)
             end
           end
+
+          instance
         end
 
-        def apply_xml_mapping(doc, caller_class: nil, mixed_content: false)
-          return unless doc
+        def apply_xml_mapping(doc, instance, options = {})
+          return instance unless doc
 
           mappings = mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
             raise "May be `collection: true` is" \
-                  "missing for #{self} in #{caller_class}"
+                  "missing for #{self} in #{options[: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
-
-          mapping_from = []
+          if instance.respond_to?(:ordered=)
+            instance.element_order = doc.item_order
+            instance.ordered = mappings_for(:xml).mixed_content? || options[:mixed_content]
+          end
 
-          mappings.each_with_object(mapping_hash) do |rule, hash|
+          mappings.each do |rule|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
@@ -348,52 +305,38 @@ module Lutaml
                       doc[rule.name.to_s] || doc[rule.name.to_sym]
                     end
 
-            if attr.collection?
-              if value && !value.is_a?(Array)
-                value = [value]
+            if value.is_a?(Array)
+              value = value.map do |v|
+                v.is_a?(Hash) && !(attr.type <= Serialize) ? v["text"] : v
               end
-
-              value = (value || []).map do |v|
-                if attr.type <= Serialize
-                  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, 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) unless is_content_mapping
+            elsif !(attr.type <= Serialize) && value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+              value = value["text"]
             end
 
-            mapping_from << rule if rule.custom_methods[:from]
-
-            hash[rule.to] = value
-          end
-
-          mapping_from.each do |rule|
-            value = if rule.name.nil?
-                      mapping_hash[rule.to].join("\n").strip
-                    else
-                      mapping_hash[rule.to]
-                    end
+            unless is_content_mapping
+              value = attr.cast(
+                value,
+                :xml,
+                caller_class: self,
+                mixed_content: rule.mixed_content,
+              )
+            end
 
-            mapping_hash[rule.to] = new.send(rule.custom_methods[:from], mapping_hash, value)
+            if rule.custom_methods[:from]
+              new.send(rule.custom_methods[:from], instance, value)
+            else
+              instance.public_send(:"#{rule.to}=", value)
+            end
           end
 
-          mapping_hash
+          instance
         end
 
         def ensure_utf8(value)
           case value
           when String
-            value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+            value.encode("UTF-8", invalid: :replace, undef: :replace,
+                                  replace: "")
           when Array
             value.map { |v| ensure_utf8(v) }
           when Hash
@@ -408,7 +351,7 @@ module Lutaml
         end
       end
 
-      attr_reader :element_order
+      attr_accessor :element_order
 
       def initialize(attrs = {})
         return unless self.class.attributes
@@ -431,22 +374,27 @@ module Lutaml
         @ordered
       end
 
+      def ordered=(ordered)
+        @ordered = ordered
+      end
+
       def key_exist?(hash, key)
-        hash.key?(key) || hash.key?(key.to_sym) || hash.key?(key.to_s)
+        hash.key?(key.to_sym) || hash.key?(key.to_s)
       end
 
       def key_value(hash, key)
-        hash[key] || hash[key.to_sym] || hash[key.to_s]
+        hash[key.to_sym] || hash[key.to_s]
       end
 
-      FORMATS.each do |format|
+      Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
           validate
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
           representation = if format == :xml
                              self
                            else
-                             self.class.hash_representation(self, format, options)
+                             self.class.hash_representation(self, format,
+                                                            options)
                            end
 
           adapter.new(representation).public_send(:"to_#{format}", options)
@@ -457,7 +405,8 @@ module Lutaml
         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])
+            raise Lutaml::Model::InvalidValueError.new(name, value,
+                                                       attr.options[:values])
           end
         end
       end

data/lib/lutaml/model/type.rb

@@ -1,8 +1,5 @@
 require "date"
 require "bigdecimal"
-require "securerandom"
-require "uri"
-require "ipaddr"
 
 module Lutaml
   module Model
@@ -20,12 +17,6 @@ module Lutaml
         Boolean
         Decimal
         Hash
-        Uuid
-        Symbol
-        Binary
-        Url
-        IpAddress
-        Json
       ).each do |t|
         class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
                      class #{t}                        # class Integer
@@ -72,18 +63,6 @@ module Lutaml
           BigDecimal(value.to_s)
         when "Hash"
           normalize_hash(Hash(value))
-        when "Uuid"
-          UUID_REGEX.match?(value) ? value : SecureRandom.uuid
-        when "Symbol"
-          value.to_sym
-        when "Binary"
-          value.force_encoding("BINARY")
-        when "Url"
-          URI.parse(value.to_s)
-        when "IpAddress"
-          IPAddr.new(value.to_s)
-        when "Json"
-          Json.cast(value)
         else
           value
         end
@@ -107,8 +86,6 @@ module Lutaml
           value.to_s("F")
         when "Hash"
           Hash(value)
-        when "Json"
-          value.to_json
         else
           value.to_s
         end
@@ -145,4 +122,3 @@ end
 
 require_relative "type/time_without_date"
 require_relative "type/date_time"
-require_relative "type/json"

data/lib/lutaml/model/utils.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Utils
+      class << self
+        # Convert string to camel case
+        def camel_case(str)
+          return "" if str.nil? || str.empty?
+
+          str.split("/").map { |part| camelize_part(part) }.join("::")
+        end
+
+        # Convert string to class name
+        def classify(str)
+          str = str.to_s.delete(".")
+          str = str.sub(/^[a-z\d]*/) { |match| camel_case(match) || match }
+
+          str.gsub("::", "/").gsub(%r{(?:_|-|(/))([a-z\d]*)}i) do
+            word = Regexp.last_match(2)
+            substituted = camel_case(word) || word
+            Regexp.last_match(1) ? "::#{substituted}" : substituted
+          end
+        end
+
+        # Convert string to snake case
+        def snake_case(str)
+          str = str.to_s.tr(".", "_")
+          return str unless /[A-Z-]|::/.match?(str)
+
+          str.gsub("::", "/")
+            .gsub(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { "#{$1 || $2}_" }
+            .tr("-", "_")
+            .downcase
+        end
+
+        private
+
+        def camelize_part(part)
+          part.gsub(/(?:_|-|^)([a-z\d])/i) { $1.upcase }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.5"
+    VERSION = "0.3.7"
   end
 end

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

@@ -0,0 +1,73 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Nokogiri
+          def self.build(options = {})
+            if block_given?
+              ::Nokogiri::XML::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Nokogiri::XML::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            xml.doc.create_element(name, attributes)
+          end
+
+          def add_element(element, child)
+            element.add_child(child)
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            add_namespace_prefix(prefix) if prefix
+
+            if block_given?
+              public_send(element_name, attributes) do
+                yield(self)
+              end
+            else
+              public_send(element_name, attributes)
+            end
+          end
+
+          def add_text(element, text)
+            if element.is_a?(self.class)
+              element = element.xml.parent
+            end
+
+            add_element(element, ::Nokogiri::XML::Text.new(text.to_s, xml.doc))
+          end
+
+          def add_namespace_prefix(prefix)
+            xml[prefix] if prefix
+
+            self
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Ox
+          def self.build(options = {})
+            if block_given?
+              ::Ox::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Ox::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            if block_given?
+              xml.element(name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(name, attributes)
+            end
+          end
+
+          def add_element(element, child)
+            element << child
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            prefixed_name = if prefix
+                              "#{prefix}:#{element_name}"
+                            else
+                              element_name
+                            end
+
+            if block_given?
+              xml.element(prefixed_name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(prefixed_name, attributes)
+            end
+          end
+
+          def <<(text)
+            xml.text(text)
+          end
+
+          def add_text(element, text)
+            element << text
+          end
+
+          # Add XML namespace to document
+          #
+          # Ox doesn't support XML namespaces so this method does nothing.
+          def add_namespace_prefix(_prefix)
+            # :noop:
+            self
+          end
+
+          def parent
+            xml
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end