lutaml-model 0.6.7 → 0.7.2

data/lib/lutaml/model/xml_mapping.rb

@@ -1,307 +0,0 @@
-require_relative "xml_mapping_rule"
-
-module Lutaml
-  module Model
-    class XmlMapping
-      include Lutaml::Model::Loggable
-
-      TYPES = {
-        attribute: :map_attribute,
-        element: :map_element,
-        content: :map_content,
-        all_content: :map_all,
-      }.freeze
-
-      attr_reader :root_element,
-                  :namespace_uri,
-                  :namespace_prefix,
-                  :mixed_content,
-                  :ordered,
-                  :element_sequence
-
-      def initialize
-        @elements = {}
-        @attributes = {}
-        @element_sequence = []
-        @content_mapping = nil
-        @raw_mapping = nil
-        @mixed_content = false
-      end
-
-      alias mixed_content? mixed_content
-      alias ordered? ordered
-
-      def root(name, mixed: false, ordered: false)
-        @root_element = name
-        @mixed_content = mixed
-        @ordered = ordered || mixed # mixed contenet will always be ordered
-      end
-
-      def root?
-        !!root_element
-      end
-
-      def no_root
-        @no_root = true
-      end
-
-      def no_root?
-        !!@no_root
-      end
-
-      def prefixed_root
-        if namespace_uri && namespace_prefix
-          "#{namespace_prefix}:#{root_element}"
-        else
-          root_element
-        end
-      end
-
-      def namespace(uri, prefix = nil)
-        raise Lutaml::Model::NoRootNamespaceError if no_root?
-
-        @namespace_uri = uri
-        @namespace_prefix = prefix
-      end
-
-      # rubocop:disable Metrics/ParameterLists
-      def map_element(
-        name,
-        to: nil,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        cdata: false,
-        namespace: (namespace_set = false
-                    nil),
-        prefix: (prefix_set = false
-                 nil),
-        transform: {}
-      )
-        validate!(name, to, with, type: TYPES[:element])
-
-        rule = XmlMappingRule.new(
-          name,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          cdata: cdata,
-          namespace: namespace,
-          default_namespace: namespace_uri,
-          prefix: prefix,
-          namespace_set: namespace_set != false,
-          prefix_set: prefix_set != false,
-          transform: transform,
-        )
-        @elements[rule.namespaced_name] = rule
-      end
-
-      def map_attribute(
-        name,
-        to: nil,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        namespace: (namespace_set = false
-                    nil),
-        prefix: (prefix_set = false
-                 nil)
-      )
-        validate!(name, to, with, type: TYPES[:attribute])
-        warn_auto_handling(name) if name == "schemaLocation"
-
-        rule = XmlMappingRule.new(
-          name,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          namespace: namespace,
-          prefix: prefix,
-          attribute: true,
-          default_namespace: namespace_uri,
-          namespace_set: namespace_set != false,
-          prefix_set: prefix_set != false,
-        )
-        @attributes[rule.namespaced_name] = rule
-      end
-
-      # rubocop:enable Metrics/ParameterLists
-
-      def map_content(
-        to: nil,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        mixed: false,
-        cdata: false
-      )
-        validate!("content", to, with, type: TYPES[:content])
-
-        @content_mapping = XmlMappingRule.new(
-          nil,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          mixed_content: mixed,
-          cdata: cdata,
-        )
-      end
-
-      def map_all(
-        to:,
-        render_nil: false,
-        render_default: false,
-        delegate: nil,
-        with: {},
-        namespace: (namespace_set = false
-                    nil),
-        prefix: (prefix_set = false
-                 nil)
-      )
-        validate!(Constants::RAW_MAPPING_KEY, to, with, type: TYPES[:all_content])
-
-        rule = XmlMappingRule.new(
-          Constants::RAW_MAPPING_KEY,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          namespace: namespace,
-          prefix: prefix,
-          default_namespace: namespace_uri,
-          namespace_set: namespace_set != false,
-          prefix_set: prefix_set != false,
-        )
-
-        @raw_mapping = rule
-      end
-
-      alias map_all_content map_all
-
-      def sequence(&block)
-        @element_sequence << Sequence.new(self).tap do |s|
-          s.instance_eval(&block)
-        end
-      end
-
-      def import_model_mappings(model)
-        raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
-
-        mappings = model.mappings_for(:xml)
-        @elements.merge!(mappings.instance_variable_get(:@elements))
-        @attributes.merge!(mappings.instance_variable_get(:@attributes))
-        (@element_sequence << mappings.element_sequence).flatten!
-      end
-
-      def validate!(key, to, with, type: nil)
-        validate_mappings!(type)
-
-        if to.nil? && with.empty?
-          msg = ":to or :with argument is required for mapping '#{key}'"
-          raise IncorrectMappingArgumentsError.new(msg)
-        end
-
-        if !with.empty? && (with[:from].nil? || with[:to].nil?)
-          msg = ":with argument for mapping '#{key}' requires :to and :from keys"
-          raise IncorrectMappingArgumentsError.new(msg)
-        end
-      end
-
-      def validate_mappings!(type)
-        if !@raw_mapping.nil? && type != TYPES[:attribute]
-          raise StandardError, "#{type} is not allowed, only #{TYPES[:attribute]} " \
-                               "is allowed with #{TYPES[:all_content]}"
-        end
-
-        if !(elements.empty? && content_mapping.nil?) && type == TYPES[:all_content]
-          raise StandardError, "#{TYPES[:all_content]} is not allowed with other mappings"
-        end
-      end
-
-      def elements
-        @elements.values
-      end
-
-      def attributes
-        @attributes.values
-      end
-
-      def content_mapping
-        @content_mapping
-      end
-
-      def raw_mapping
-        @raw_mapping
-      end
-
-      def mappings
-        elements + attributes + [content_mapping, raw_mapping].compact
-      end
-
-      def element(name)
-        elements.detect do |rule|
-          name == rule.to
-        end
-      end
-
-      def attribute(name)
-        attributes.detect do |rule|
-          name == rule.to
-        end
-      end
-
-      def find_by_name(name)
-        if ["text", "#cdata-section"].include?(name.to_s)
-          content_mapping
-        else
-          mappings.detect do |rule|
-            rule.name == name.to_s || rule.name == name.to_sym
-          end
-        end
-      end
-
-      def deep_dup
-        self.class.new.tap do |xml_mapping|
-          xml_mapping.root(@root_element.dup, mixed: @mixed_content,
-                                              ordered: @ordered)
-          xml_mapping.namespace(@namespace_uri.dup, @namespace_prefix.dup)
-
-          attributes_to_dup.each do |var_name|
-            value = instance_variable_get(var_name)
-            xml_mapping.instance_variable_set(var_name, Utils.deep_dup(value))
-          end
-        end
-      end
-
-      def attributes_to_dup
-        @attributes_to_dup ||= %i[
-          @content_mapping
-          @raw_mapping
-          @element_sequence
-          @attributes
-          @elements
-        ]
-      end
-
-      def dup_mappings(mappings)
-        new_mappings = {}
-
-        mappings.each do |key, mapping_rule|
-          new_mappings[key] = mapping_rule.deep_dup
-        end
-
-        new_mappings
-      end
-    end
-  end
-end

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -1,122 +0,0 @@
-require_relative "mapping_rule"
-
-module Lutaml
-  module Model
-    class XmlMappingRule < MappingRule
-      attr_reader :namespace, :prefix, :mixed_content, :default_namespace, :cdata
-
-      def initialize(
-        name,
-        to:,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        namespace: nil,
-        prefix: nil,
-        mixed_content: false,
-        cdata: false,
-        namespace_set: false,
-        prefix_set: false,
-        attribute: false,
-        default_namespace: nil,
-        transform: {}
-      )
-        super(
-          name,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          attribute: attribute,
-          transform: transform
-        )
-
-        @namespace = if namespace.to_s == "inherit"
-                     # we are using inherit_namespace in xml builder by
-                     # default so no need to do anything here.
-                     else
-                       namespace
-                     end
-        @prefix = prefix
-        @mixed_content = mixed_content
-        @cdata = cdata
-
-        @default_namespace = default_namespace
-
-        @namespace_set = namespace_set
-        @prefix_set = prefix_set
-      end
-
-      def namespace_set?
-        !!@namespace_set
-      end
-
-      def prefix_set?
-        !!@prefix_set
-      end
-
-      def content_mapping?
-        name.nil?
-      end
-
-      def content_key
-        cdata ? "#cdata-section" : "text"
-      end
-
-      def mixed_content?
-        !!@mixed_content
-      end
-
-      def prefixed_name
-        rule_name = multiple_mappings? ? name.first : name
-        if prefix
-          "#{prefix}:#{rule_name}"
-        else
-          rule_name
-        end
-      end
-
-      def namespaced_names(parent_namespace = nil)
-        if multiple_mappings?
-          name.map { |rule_name| namespaced_name(parent_namespace, rule_name) }
-        else
-          [namespaced_name(parent_namespace)]
-        end
-      end
-
-      def namespaced_name(parent_namespace = nil, name = self.name)
-        if name == "lang"
-          "#{prefix}:#{name}"
-        elsif namespace_set? || @attribute
-          [namespace, name].compact.join(":")
-        elsif default_namespace
-          "#{default_namespace}:#{name}"
-        else
-          [parent_namespace, name].compact.join(":")
-        end
-      end
-
-      def deep_dup
-        self.class.new(
-          name.dup,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: Utils.deep_dup(custom_methods),
-          delegate: delegate,
-          namespace: namespace.dup,
-          prefix: prefix.dup,
-          mixed_content: mixed_content,
-          cdata: cdata,
-          namespace_set: namespace_set?,
-          prefix_set: prefix_set?,
-          attribute: attribute,
-          default_namespace: default_namespace.dup,
-          transform: transform.dup,
-        )
-      end
-    end
-  end
-end

data/lib/lutaml/model/yaml_adapter/yaml_document.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "yaml_object"
-
-module Lutaml
-  module Model
-    module YamlAdapter
-      # Base class for YAML documents
-      class YamlDocument < YamlObject
-        def self.parse(yaml, _options = {})
-          raise NotImplementedError, "Subclasses must implement `parse`."
-        end
-
-        def to_yaml(*args)
-          raise NotImplementedError, "Subclasses must implement `to_yaml`."
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/yaml_adapter/yaml_object.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module YamlAdapter
-      # Base class for YAML objects
-      class YamlObject
-        attr_reader :attributes
-
-        def initialize(attributes = {})
-          @attributes = attributes
-        end
-
-        def [](key)
-          @attributes[key]
-        end
-
-        def []=(key, value)
-          @attributes[key] = value
-        end
-
-        def to_h
-          @attributes
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/yaml_adapter.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module YamlAdapter
-    end
-  end
-end