lutaml 0.9.27 → 0.9.29

data/lib/lutaml/xml/mapper.rb

@@ -1,448 +0,0 @@
-require "shale"
-
-module Lutaml
-  module Xml
-    class Mapper < Shale::Mapper
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/BlockLength
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      class << self
-        # Convert XML document to Object
-        #
-        # @param [Shale::Adapter::<XML adapter>::Node] element
-        # @param [Array<Symbol>] only
-        # @param [Array<Symbol>] except
-        # @param [any] context
-        #
-        # @return [model instance]
-        #
-        # @api public
-        def of_xml(element, only: nil, except: nil, context: nil)
-          instance = model.new
-
-          attributes
-            .values
-            .select(&:default)
-            .each { |attr| instance.send(attr.setter, attr.default.call) }
-
-          grouping = Shale::Mapping::Group::XmlGrouping.new
-          delegates = Shale::Mapping::Delegates.new
-
-          only = to_partial_render_attributes(only)
-          except = to_partial_render_attributes(except)
-
-          element.attributes.each do |key, value|
-            mapping = xml_mapping.attributes[key.to_s]
-            next unless mapping
-
-            if mapping.group
-              grouping.add(mapping, :attribute, value)
-            elsif mapping.method_from
-              mapper = new
-
-              if mapper.method(mapping.method_from).arity == 3
-                mapper.send(mapping.method_from, instance, value, context)
-              else
-                mapper.send(mapping.method_from, instance, value)
-              end
-            else
-              receiver_attributes = get_receiver_attributes(mapping)
-              attribute = receiver_attributes[mapping.attribute]
-              next unless attribute
-
-              next if only && !only.key?(attribute.name)
-              next if except&.key?(attribute.name)
-
-              casted_value = attribute.type.cast(value)
-
-              if attribute.collection?
-                if mapping.receiver
-                  delegates.add_collection(
-                    attributes[mapping.receiver],
-                    attribute.setter,
-                    casted_value,
-                  )
-                else
-                  instance.send(attribute.name) << casted_value
-                end
-              elsif mapping.receiver
-                delegates.add(attributes[mapping.receiver], attribute.setter,
-                              casted_value)
-              else
-                instance.send(attribute.setter, casted_value)
-              end
-            end
-          end
-
-          content_mapping = xml_mapping.content
-
-          if content_mapping
-            if content_mapping.group
-              grouping.add(content_mapping, :content, element)
-            elsif content_mapping.method_from
-              mapper = new
-
-              if mapper.method(content_mapping.method_from).arity == 3
-                mapper.send(content_mapping.method_from, instance, element,
-                            context)
-              else
-                mapper.send(content_mapping.method_from, instance, element)
-              end
-            else
-              get_content_value(content_mapping, element, only, except,
-                                delegates, instance)
-            end
-          end
-
-          # rubocop:disable Metrics/BlockNesting
-          element.instance_variable_get(:@node)&.children&.each do |nokogiri_node|
-            if nokogiri_node.name == "text"
-              content_value = get_content_value(content_mapping, nokogiri_node,
-                                                only, except, delegates, instance)
-              instance.all_content << ["content", content_value]
-              next
-            elsif nokogiri_node.name == "comment"
-              instance.all_content << ["comment", nokogiri_node.text]
-              next
-            end
-
-            node = element.class.new(nokogiri_node)
-            mapping = xml_mapping.elements[node.name]
-
-            next unless mapping
-
-            if mapping.group
-              grouping.add(mapping, :element, node)
-            elsif mapping.method_from
-              mapper = new
-
-              if mapper.method(mapping.method_from).arity == 3
-                mapper.send(mapping.method_from, instance, node, context)
-              else
-                mapper.send(mapping.method_from, instance, node)
-              end
-            else
-              receiver_attributes = get_receiver_attributes(mapping)
-              attribute = receiver_attributes[mapping.attribute]
-              next unless attribute
-
-              if only
-                attribute_only = only[attribute.name]
-                next unless only.key?(attribute.name)
-              end
-
-              if except
-                attribute_except = except[attribute.name]
-                next if except.key?(attribute.name) && attribute_except.nil?
-              end
-
-              value = attribute.type.of_xml(
-                node,
-                only: attribute_only,
-                except: attribute_except,
-                context: context,
-              )
-
-              casted_value = attribute.type.cast(value)
-              instance.all_content << [mapping, casted_value]
-
-              if attribute.collection?
-                if mapping.receiver
-                  delegates.add_collection(
-                    attributes[mapping.receiver],
-                    attribute.setter,
-                    casted_value,
-                  )
-                else
-                  instance.send(attribute.name) << casted_value
-                end
-              elsif mapping.receiver
-                delegates.add(attributes[mapping.receiver], attribute.setter,
-                              casted_value)
-              else
-                instance.send(attribute.setter, casted_value)
-              end
-            end
-          end
-          # rubocop:enable Metrics/BlockNesting
-
-          delegates.each do |delegate|
-            receiver = get_receiver(instance, delegate.receiver_attribute)
-            receiver.send(delegate.setter, delegate.value)
-          end
-
-          grouping.each do |group|
-            mapper = new
-
-            if mapper.method(group.method_from).arity == 3
-              mapper.send(group.method_from, instance, group.dict, context)
-            else
-              mapper.send(group.method_from, instance, group.dict)
-            end
-          end
-
-          instance
-        end
-
-        # Convert Object to XML document
-        #
-        # @param [any] instance Object to convert
-        # @param [String, nil] node_name XML node name
-        # @param [Shale::Adapter::<xml adapter>::Document, nil]
-        #          doc Object to convert
-        # @param [Array<Symbol>] only
-        # @param [Array<Symbol>] except
-        # @param [any] context
-        #
-        # @raise [IncorrectModelError]
-        #
-        # @return [::REXML::Document, ::Nokogiri::Document, ::Ox::Document]
-        #
-        # @api public
-        def as_xml(
-          instance,
-          node_name = nil,
-          doc = nil,
-          _cdata = nil,
-          only: nil,
-          except: nil,
-          context: nil,
-          version: nil
-        )
-          unless instance.is_a?(model)
-            msg = "argument is a '#{instance.class}' but should be a '#{model}'"
-            raise IncorrectModelError, msg
-          end
-
-          unless doc
-            doc = Shale.xml_adapter.create_document(version)
-
-            element = as_xml(
-              instance,
-              xml_mapping.prefixed_root,
-              doc,
-              only: only,
-              except: except,
-              context: context,
-            )
-            doc.add_element(doc.doc, element)
-
-            return doc.doc
-          end
-
-          element = doc.create_element(node_name)
-
-          doc.add_namespace(
-            xml_mapping.default_namespace.prefix,
-            xml_mapping.default_namespace.name,
-          )
-
-          grouping = Shale::Mapping::Group::XmlGrouping.new
-
-          only = to_partial_render_attributes(only)
-          except = to_partial_render_attributes(except)
-
-          # rubocop:disable Metrics/BlockNesting
-          xml_mapping.attributes.each_value do |mapping|
-            if mapping.group
-              grouping.add(mapping, :attribute, nil)
-            elsif mapping.method_to
-              mapper = new
-
-              if mapper.method(mapping.method_to).arity == 4
-                mapper.send(mapping.method_to, instance, element, doc, context)
-              else
-                mapper.send(mapping.method_to, instance, element, doc)
-              end
-            else
-              receiver = if mapping.receiver
-                           instance.send(mapping.receiver)
-                         else
-                           instance
-                         end
-
-              receiver_attributes = get_receiver_attributes(mapping)
-              attribute = receiver_attributes[mapping.attribute]
-              next unless attribute
-
-              next if only && !only.key?(attribute.name)
-              next if except&.key?(attribute.name)
-
-              value = receiver.send(attribute.name) if receiver
-
-              if mapping.render_nil? || !value.nil?
-                doc.add_namespace(mapping.namespace.prefix,
-                                  mapping.namespace.name)
-                doc.add_attribute(element, mapping.prefixed_name, value)
-              end
-            end
-          end
-          # rubocop:enable Metrics/BlockNesting
-
-          # rubocop:disable Metrics/BlockNesting
-          instance.all_content.each do |mapping, content|
-            if mapping == "comment"
-              comment = Nokogiri::XML::Comment.new(doc.doc, content)
-              doc.add_element(element, comment)
-            elsif mapping == "content"
-              content_mapping = xml_mapping.content
-              if content_mapping
-                if content_mapping.group
-                  grouping.add(content_mapping, :content, nil)
-                elsif content_mapping.method_to
-                  mapper = new
-
-                  if mapper.method(content_mapping.method_to).arity == 4
-                    mapper.send(content_mapping.method_to, instance, element,
-                                doc, context)
-                  else
-                    mapper.send(content_mapping.method_to, instance, element, doc)
-                  end
-                else
-                  receiver_attributes = get_receiver_attributes(content_mapping)
-                  attribute = receiver_attributes[content_mapping.attribute]
-
-                  if attribute
-                    skip = false
-
-                    skip = true if only && !only.key?(attribute.name)
-                    skip = true if except&.key?(attribute.name)
-
-                    unless skip
-                      # value = receiver.send(attribute.name) if receiver
-                      value = content
-
-                      if content_mapping.cdata
-                        doc.create_cdata(value, element)
-                      else
-                        a = Nokogiri::XML::Text.new(value, doc.doc)
-                        doc.add_element(element, a)
-                      end
-                    end
-                  end
-                end
-              end
-            elsif mapping.group
-              grouping.add(mapping, :element, nil)
-            elsif mapping.method_to
-              mapper = new
-
-              if mapper.method(mapping.method_to).arity == 4
-                mapper.send(mapping.method_to, instance, element, doc, context)
-              else
-                mapper.send(mapping.method_to, instance, element, doc)
-              end
-            else
-              receiver_attributes = get_receiver_attributes(mapping)
-              attribute = receiver_attributes[mapping.attribute]
-              next unless attribute
-
-              if only
-                attribute_only = only[attribute.name]
-                next unless only.key?(attribute.name)
-              end
-
-              if except
-                attribute_except = except[attribute.name]
-                next if except.key?(attribute.name) && attribute_except.nil?
-              end
-
-              value = content
-
-              if mapping.render_nil? || !value.nil?
-                doc.add_namespace(mapping.namespace.prefix,
-                                  mapping.namespace.name)
-              end
-
-              if value.nil?
-                if mapping.render_nil?
-                  child = doc.create_element(mapping.prefixed_name)
-                  doc.add_element(element, child)
-                end
-              elsif attribute.collection?
-                [*value].each do |v|
-                  next if v.nil?
-
-                  child = attribute.type.as_xml(
-                    v,
-                    mapping.prefixed_name,
-                    doc,
-                    mapping.cdata,
-                    only: attribute_only,
-                    except: attribute_except,
-                    context: context,
-                  )
-                  doc.add_element(element, child)
-                end
-              else
-                child = attribute.type.as_xml(
-                  value,
-                  mapping.prefixed_name,
-                  doc,
-                  mapping.cdata,
-                  only: attribute_only,
-                  except: attribute_except,
-                  context: context,
-                )
-                doc.add_element(element, child)
-              end
-            end
-          end
-          # rubocop:enable Metrics/BlockNesting
-
-          grouping.each do |group|
-            mapper = new
-
-            if mapper.method(group.method_to).arity == 4
-              mapper.send(group.method_to, instance, element, doc, context)
-            else
-              mapper.send(group.method_to, instance, element, doc)
-            end
-          end
-
-          element
-        end
-
-        def get_content_value(content_mapping, element, only, except, delegates, instance)
-          receiver_attributes = get_receiver_attributes(content_mapping)
-          attribute = receiver_attributes[content_mapping.attribute]
-
-          if attribute
-            skip = false
-
-            # rubocop:disable Metrics/BlockNesting
-            skip = true if only && !only.key?(attribute.name)
-            skip = true if except&.key?(attribute.name)
-
-            unless skip
-              value = attribute.type.cast(attribute.type.of_xml(element))
-
-              if content_mapping.receiver
-                delegates.add(attributes[content_mapping.receiver],
-                              attribute.setter, value)
-              else
-                instance.send(attribute.setter, value)
-              end
-            end
-            # rubocop:enable Metrics/BlockNesting
-          end
-        end
-      end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/BlockLength
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      attr_accessor :all_content
-
-      def initialize(*args)
-        @all_content = []
-
-        super
-      end
-    end
-  end
-end