lutaml-model 0.3.10 → 0.3.12

data/lib/lutaml/model/mapping_rule.rb

@@ -7,7 +7,8 @@ module Lutaml
                   :custom_methods,
                   :delegate,
                   :mixed_content,
-                  :child_mappings
+                  :child_mappings,
+                  :default_namespace
 
       def initialize(
         name,
@@ -17,6 +18,8 @@ module Lutaml
         delegate: nil,
         mixed_content: false,
         namespace_set: false,
+        prefix_set: false,
+        default_namespace: nil,
         child_mappings: nil
       )
         @name = name
@@ -26,7 +29,9 @@ module Lutaml
         @delegate = delegate
         @mixed_content = mixed_content
         @namespace_set = namespace_set
+        @prefix_set = prefix_set
         @child_mappings = child_mappings
+        @default_namespace = default_namespace
       end
 
       alias from name
@@ -40,25 +45,63 @@ module Lutaml
         end
       end
 
-      def serialize(model, value)
+      def namespaced_name
+        if name == "lang"
+          "#{prefix}:#{name}"
+        elsif namespace || default_namespace
+          "#{namespace || default_namespace}:#{name}"
+        else
+          name
+        end
+      end
+
+      def serialize_attribute(model, element, doc)
         if custom_methods[:to]
-          model.send(custom_methods[:to], model, value)
+          model.send(custom_methods[:to], model, element, doc)
+        end
+      end
+
+      def to_value_for(model)
+        if delegate
+          model.public_send(delegate).public_send(to)
         else
-          value
+          model.public_send(to)
         end
       end
 
-      def deserialize(model, doc)
+      def serialize(model, parent = nil, doc = nil)
+        if custom_methods[:to]
+          model.send(custom_methods[:to], model, parent, doc)
+        else
+          to_value_for(model)
+        end
+      end
+
+      def deserialize(model, value, attributes, mapper_class = nil)
         if custom_methods[:from]
-          model.send(custom_methods[:from], model, doc)
+          mapper_class.new.send(custom_methods[:from], model, value)
+        elsif delegate
+          if model.public_send(delegate).nil?
+            model.public_send(:"#{delegate}=", attributes[delegate].type.new)
+          end
+
+          model.public_send(delegate).public_send(:"#{to}=", value)
         else
-          doc[name.to_s]
+          model.public_send(:"#{to}=", value)
         end
       end
 
       def namespace_set?
         @namespace_set
       end
+
+      def prefix_set?
+        @prefix_set
+      end
+
+      def content_mapping?
+        name.nil?
+      end
     end
   end
 end

data/lib/lutaml/model/serialize.rb

@@ -11,6 +11,7 @@ require_relative "json_adapter"
 require_relative "comparable_model"
 require_relative "schema_location"
 require_relative "validation"
+require_relative "error"
 
 module Lutaml
   module Model
@@ -39,11 +40,42 @@ module Lutaml
         def model(klass = nil)
           if klass
             @model = klass
+            add_order_handling_methods_to_model(klass)
           else
             @model
           end
         end
 
+        def add_order_handling_methods_to_model(klass)
+          Utils.add_method_if_not_defined(klass, :ordered=) do |ordered|
+            @ordered = ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :ordered?) do
+            !!@ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :mixed=) do |mixed|
+            @mixed = mixed
+          end
+
+          Utils.add_method_if_not_defined(klass, :mixed?) do
+            !!@mixed
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order=) do |order|
+            @element_order = order
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order) do
+            @element_order
+          end
+        end
+
+        def cast(value)
+          value
+        end
+
         # Define an attribute for the model
         def attribute(name, type, options = {})
           attr = Attribute.new(name, type, options)
@@ -54,15 +86,14 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
-            instance_variable_set(:"@#{name}", value)
-            # validate!(name)
+            instance_variable_set(:"@#{name}", attr.cast_value(value))
           end
         end
 
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
-            mappings[format] = klass.new
+            mappings[format] ||= klass.new
             mappings[format].instance_eval(&block)
 
             if format == :xml && !mappings[format].root_element
@@ -74,17 +105,22 @@ module Lutaml
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
 
             doc = adapter.parse(data)
-            public_send(:"of_#{format}", doc.to_h)
+            public_send(:"of_#{format}", doc)
           end
 
-          define_method(:"of_#{format}") do |hash|
-            if hash.is_a?(Array)
-              return hash.map do |item|
-                       apply_mappings(item, format)
+          define_method(:"of_#{format}") do |doc|
+            if doc.is_a?(Array)
+              return doc.map do |item|
+                       send(:"of_#{format}", item)
                      end
             end
 
-            apply_mappings(hash, format)
+            if format == :xml
+              doc_hash = doc.parse_element(doc.root, self, :xml)
+              apply_mappings(doc_hash, format)
+            else
+              apply_mappings(doc.to_h, format)
+            end
           end
 
           define_method(:"to_#{format}") do |instance|
@@ -185,6 +221,7 @@ module Lutaml
 
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
+
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
               mapping.map_element(
@@ -193,6 +230,8 @@ module Lutaml
                 render_nil: attr.render_nil?,
               )
             end
+
+            mapping.root(to_s.split("::").last) if format == :xml
           end
         end
 
@@ -242,20 +281,34 @@ module Lutaml
           hash
         end
 
+        def valid_rule?(rule)
+          attribute = attribute_for_rule(rule)
+
+          !!attribute || rule.custom_methods[:from]
+        end
+
+        def attribute_for_rule(rule)
+          return attributes[rule.to] unless rule.delegate
+
+          attributes[rule.delegate].type.attributes[rule.to]
+        end
+
+        def attribute_for_child(child_name, format)
+          mapping_rule = mappings_for(format).find_by_name(child_name)
+
+          attribute_for_rule(mapping_rule) if mapping_rule
+        end
+
         def apply_mappings(doc, format, options = {})
           instance = options[:instance] || model.new
-          return instance if !doc || doc.empty?
+          return instance if Utils.blank?(doc)
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           mappings = mappings_for(format).mappings
           mappings.each do |rule|
-            attr = if rule.delegate
-                     attributes[rule.delegate].type.attributes[rule.to]
-                   else
-                     attributes[rule.to]
-                   end
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+            attr = attribute_for_rule(rule)
 
             value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
                       doc[rule.name] || doc[rule.name.to_sym]
@@ -264,26 +317,17 @@ module Lutaml
                     end
 
             if rule.custom_methods[:from]
-              if value && !value.empty?
-                value = new.send(rule.custom_methods[:from], instance,
-                                 value)
+              if Utils.present?(value)
+                value = new.send(rule.custom_methods[:from], instance, value)
               end
+
               next
             end
 
             value = apply_child_mappings(value, rule.child_mappings)
             value = attr.cast(value, format)
 
-            if rule.delegate
-              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
-              instance.public_send(:"#{rule.to}=", value)
-            end
+            rule.deserialize(instance, value, attributes, self)
           end
 
           instance
@@ -301,7 +345,8 @@ module Lutaml
 
           if instance.respond_to?(:ordered=) && doc.is_a?(Lutaml::Model::MappingHash)
             instance.element_order = doc.item_order
-            instance.ordered = mappings_for(:xml).mixed_content? || options[:mixed_content]
+            instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
+            instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
           if doc["__schema_location"]
@@ -313,44 +358,55 @@ module Lutaml
           end
 
           mappings.each do |rule|
-            attr = attributes[rule.to]
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
-
-            is_content_mapping = rule.name.nil?
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            value = if is_content_mapping
+            value = if rule.content_mapping?
                       doc["text"]
+                    elsif doc.key?(rule.namespaced_name.to_s) || doc.key?(rule.namespaced_name.to_sym)
+                      doc[rule.namespaced_name.to_s] || doc[rule.namespaced_name.to_sym]
                     else
-                      doc[rule.name.to_s] || doc[rule.name.to_sym]
+                      rule.to_value_for(instance)
                     end
 
-            value = [value].compact if attr.collection? && !value.is_a?(Array)
+            value = normalize_xml_value(value, rule)
+            rule.deserialize(instance, value, attributes, self)
+          end
 
-            if value.is_a?(Array)
-              value = value.map do |v|
-                v.is_a?(Hash) && !(attr.type <= Serialize) ? v["text"] : v
-              end
-            elsif !(attr.type <= Serialize) && value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-              value = value["text"]
-            end
+          instance
+        end
 
-            unless is_content_mapping
-              value = attr.cast(
-                value,
-                :xml,
-                caller_class: self,
-                mixed_content: rule.mixed_content,
-              )
-            end
+        def normalize_xml_value(value, rule)
+          attr = attribute_for_rule(rule)
 
-            if rule.custom_methods[:from]
-              new.send(rule.custom_methods[:from], instance, value)
-            else
-              instance.public_send(:"#{rule.to}=", value)
-            end
+          value = [value].compact if attr&.collection? && !value.is_a?(Array)
+
+          value = if value.is_a?(Array)
+                    value.map do |v|
+                      text_hash?(attr, v) ? v["text"] : v
+                    end
+                  elsif text_hash?(attr, value)
+                    value["text"]
+                  else
+                    value
+                  end
+
+          if attr && !rule.content_mapping?
+            value = attr.cast(
+              value,
+              :xml,
+              caller_class: self,
+              mixed_content: rule.mixed_content,
+            )
           end
 
-          instance
+          value
+        end
+
+        def text_hash?(attr, value)
+          return false unless value.is_a?(Hash)
+          return value.keys == ["text"] unless attr
+
+          !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
         end
 
         def ensure_utf8(value)
@@ -373,6 +429,7 @@ module Lutaml
       end
 
       attr_accessor :element_order, :schema_location
+      attr_writer :ordered, :mixed
 
       def initialize(attrs = {})
         @validate_on_set = attrs.delete(:validate_on_set) || false
@@ -422,11 +479,11 @@ module Lutaml
       end
 
       def ordered?
-        @ordered
+        !!@ordered
       end
 
-      def ordered=(ordered)
-        @ordered = ordered
+      def mixed?
+        !!@mixed
       end
 
       def key_exist?(hash, key)
@@ -439,7 +496,6 @@ module Lutaml
 
       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

data/lib/lutaml/model/type.rb

@@ -62,6 +62,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           BigDecimal(value.to_s)
         when "Hash"
           normalize_hash(Hash(value))
@@ -85,6 +89,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           value.to_s("F")
         when "Hash"
           Hash(value)
@@ -108,6 +116,8 @@ module Lutaml
       def self.normalize_hash(hash)
         return hash["text"] if hash.keys == ["text"]
 
+        hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+
         hash.filter_map do |key, value|
           next if key == "text"
 

data/lib/lutaml/model/utils.rb

@@ -34,6 +34,22 @@ module Lutaml
             .downcase
         end
 
+        def present?(value)
+          !blank?(value)
+        end
+
+        def blank?(value)
+          value.respond_to?(:empty?) ? value.empty? : !value
+        end
+
+        def add_method_if_not_defined(klass, method_name, &block)
+          unless klass.method_defined?(method_name)
+            klass.class_eval do
+              define_method(method_name, &block)
+            end
+          end
+        end
+
         private
 
         def camelize_part(part)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.10"
+    VERSION = "0.3.12"
   end
 end

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

@@ -27,11 +27,21 @@ module Lutaml
             element.add_child(child)
           end
 
-          def create_and_add_element(element_name, prefix: nil, attributes: {})
-            add_namespace_prefix(prefix) if prefix
+          def add_attribute(element, name, value)
+            element[name] = value
+          end
+
+          def create_and_add_element(
+            element_name,
+            prefix: (prefix_unset = true
+                     nil),
+            attributes: {}
+          )
+            add_namespace_prefix(prefix)
 
             if block_given?
               public_send(element_name, attributes) do
+                xml.parent.namespace = nil if prefix.nil? && !prefix_unset
                 yield(self)
               end
             else
@@ -53,11 +63,9 @@ module Lutaml
             self
           end
 
-          def method_missing(method_name, *args)
+          def method_missing(method_name, *args, &block)
             if block_given?
-              xml.public_send(method_name, *args) do
-                yield(xml)
-              end
+              xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)
             end

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

@@ -38,6 +38,10 @@ module Lutaml
             element << child
           end
 
+          def add_attribute(element, name, value)
+            element[name] = value
+          end
+
           def create_and_add_element(element_name, prefix: nil, attributes: {})
             prefixed_name = if prefix
                               "#{prefix}:#{element_name}"

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

@@ -55,6 +55,7 @@ module Lutaml
             end
 
             index_hash = {}
+            content = []
 
             element.element_order.each do |name|
               index_hash[name] ||= -1
@@ -68,15 +69,20 @@ module Lutaml
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
-                text = element.send(xml_mapping.content_mapping.to)
+                text = xml_mapping.content_mapping.serialize(element)
                 text = text[curr_index] if text.is_a?(Array)
 
-                prefixed_xml.text text
+                if element.mixed?
+                  prefixed_xml.text text
+                else
+                  content << text
+                end
               elsif !value.nil? || element_rule.render_nil?
                 value = value[curr_index] if attribute_def.collection?
 
                 add_to_xml(
                   xml,
+                  element,
                   element_rule.prefix,
                   value,
                   options.merge(
@@ -86,12 +92,14 @@ module Lutaml
                 )
               end
             end
+
+            prefixed_xml.text content.join
           end
         end
       end
 
       class NokogiriElement < XmlElement
-        def initialize(node, root_node: nil)
+        def initialize(node, root_node: nil, default_namespace: nil)
           if root_node
             node.namespaces.each do |prefix, name|
               namespace = XmlNamespace.new(name, prefix)
@@ -115,14 +123,15 @@ module Lutaml
               namespace_prefix: attr.namespace&.prefix,
             )
           end
-
+          default_namespace = node.namespace&.href if root_node.nil?
           super(
             node.name,
             attributes,
-            parse_all_children(node, root_node: root_node || self),
+            parse_all_children(node, root_node: root_node || self, default_namespace: default_namespace),
             node.text,
             parent_document: root_node,
             namespace_prefix: node.namespace&.prefix,
+            default_namespace: default_namespace
           )
         end
 
@@ -137,8 +146,10 @@ module Lutaml
           if name == "text"
             builder.text(text)
           else
-            builder.send(name, build_attributes(self)) do |xml|
-              children.each { |child| child.to_xml(xml) }
+            builder.public_send(name, build_attributes(self)) do |xml|
+              children.each do |child|
+                child.to_xml(xml)
+              end
             end
           end
 
@@ -153,9 +164,9 @@ module Lutaml
           end
         end
 
-        def parse_all_children(node, root_node: nil)
+        def parse_all_children(node, root_node: nil, default_namespace: nil)
           node.children.map do |child|
-            NokogiriElement.new(child, root_node: root_node)
+            NokogiriElement.new(child, root_node: root_node, default_namespace: default_namespace)
           end
         end
 

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

@@ -42,6 +42,7 @@ module Lutaml
           builder.create_and_add_element(tag_name,
                                          attributes: attributes) do |el|
             index_hash = {}
+            content = []
 
             element.element_order.each do |name|
               index_hash[name] ||= -1
@@ -58,12 +59,17 @@ module Lutaml
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
-                el.add_text(el, text)
+                if element.mixed?
+                  el.add_text(el, text)
+                else
+                  content << text
+                end
               elsif !value.nil? || element_rule.render_nil?
                 value = value[curr_index] if attribute_def.collection?
 
                 add_to_xml(
                   el,
+                  element,
                   nil,
                   value,
                   options.merge(
@@ -73,6 +79,8 @@ module Lutaml
                 )
               end
             end
+
+            el.add_text(el, content.join)
           end
         end
       end