lutaml-model 0.6.7 → 0.7.1

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -0,0 +1,299 @@
+module Lutaml
+  module Model
+    class MappingRule
+      attr_reader :name,
+                  :to,
+                  :render_nil,
+                  :render_default,
+                  :render_empty,
+                  :treat_nil,
+                  :treat_empty,
+                  :treat_omitted,
+                  :attribute,
+                  :custom_methods,
+                  :delegate,
+                  :polymorphic,
+                  :polymorphic_map,
+                  :transform,
+                  :format
+
+      ALLOWED_OPTIONS = {
+        render_nil: %i[
+          omit
+          as_nil
+          as_blank
+          as_empty
+        ],
+        render_empty: %i[
+          omit
+          as_empty
+          as_blank
+          as_nil
+        ],
+      }.freeze
+
+      ALLOWED_OPTIONS.each do |key, values|
+        attribute_name = key.to_s
+        values.each do |value|
+          define_method(:"#{attribute_name}_#{value}?") do
+            send(attribute_name) == value
+          end
+        end
+      end
+
+      def initialize(
+        name,
+        to:,
+        render_nil: false,
+        render_default: false,
+        render_empty: false,
+        treat_nil: :nil,
+        treat_empty: :empty,
+        treat_omitted: :nil,
+        with: {},
+        attribute: false,
+        delegate: nil,
+        root_mappings: nil,
+        polymorphic: {},
+        polymorphic_map: {},
+        transform: {},
+        value_map: {}
+      )
+        @name = name
+        @to = to
+        @render_nil = render_nil
+        @render_default = render_default
+        @render_empty = render_empty
+        @treat_nil = treat_nil
+        @treat_empty = treat_empty
+        @treat_omitted = treat_omitted
+        @custom_methods = with
+        @attribute = attribute
+        @delegate = delegate
+        @root_mappings = root_mappings
+        @polymorphic = polymorphic
+        @polymorphic_map = polymorphic_map
+        @transform = transform
+
+        @value_map = default_value_map
+        @value_map[:from].merge!(value_map[:from] || {})
+        @value_map[:to].merge!(value_map[:to] || {})
+      end
+
+      def default_value_map(options = {})
+        render_nil_as = render_as(:render_nil, :omitted, options)
+        render_empty_as = render_as(:render_empty, :empty, options)
+
+        treat_nil_as = treat_as(:treat_nil, :nil, options)
+        treat_empty_as = treat_as(:treat_empty, :empty, options)
+        treat_omitted_as = treat_as(:treat_omitted, :nil, options)
+
+        {
+          from: { omitted: treat_omitted_as, nil: treat_nil_as, empty: treat_empty_as },
+          to: { omitted: :omitted, nil: render_nil_as, empty: render_empty_as },
+        }
+      end
+
+      def render_as(key, default_value, options = {})
+        value = public_send(key)
+        value = options[key] if value.nil?
+
+        if value == true
+          key.to_s.split("_").last.to_sym
+        elsif value == false
+          :omitted
+        elsif value
+          {
+            as_empty: :empty,
+            as_blank: :empty,
+            as_nil: :nil,
+            omit: :omitted,
+          }[value]
+        else
+          default_value
+        end
+      end
+
+      def treat_as(key, default_value, options = {})
+        public_send(key) || options[key] || default_value
+      end
+
+      alias from name
+      alias render_default? render_default
+      alias attribute? attribute
+
+      def render?(value, instance = nil, options = {})
+        if invalid_value?(value, options)
+          false
+        elsif instance.respond_to?(:using_default?) && instance.using_default?(to)
+          render_default?
+        else
+          true
+        end
+      end
+
+      def treat?(value)
+        (treat_nil? || !value.nil?) &&
+          (treat_empty? || !Utils.empty?(value)) &&
+          (treat_omitted? || Utils.initialized?(value))
+      end
+
+      def render_value_for(value)
+        if value.nil?
+          value_for_option(value_map(:to)[:nil])
+        elsif Utils.empty?(value)
+          value_for_option(value_map(:to)[:empty], value)
+        elsif Utils.uninitialized?(value)
+          value_for_option(value_map(:to)[:omitted])
+        else
+          value
+        end
+      end
+
+      def value_for_option(option, empty_value = nil)
+        return nil if option == :nil
+        return empty_value || "" if option == :empty
+
+        Lutaml::Model::UninitializedClass.instance
+      end
+
+      def render_nil?(options = {})
+        value_map(:to, options)[:nil] != :omitted
+      end
+
+      def render_empty?(options = {})
+        value_map(:to, options)[:empty] != :omitted
+      end
+
+      def render_omitted?(options = {})
+        value_map(:to, options)[:omitted] != :omitted
+      end
+
+      def treat_nil?(options = {})
+        value_map(:from, options)[:nil] != :omitted
+      end
+
+      def treat_empty?(options = {})
+        value_map(:from, options)[:empty] != :omitted
+      end
+
+      def treat_omitted?(options = {})
+        value_map(:from, options)[:omitted] != :omitted
+      end
+
+      def polymorphic_mapping?
+        polymorphic_map && !polymorphic_map.empty?
+      end
+
+      def serialize_attribute(model, element, doc)
+        if custom_methods[:to]
+          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
+          return if to.nil?
+
+          model.public_send(to)
+        end
+      end
+
+      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)
+        handle_custom_method(model, value, mapper_class) ||
+          handle_delegate(model, value, attributes) ||
+          handle_transform_method(model, value, attributes) ||
+          assign_value(model, value)
+      end
+
+      def using_custom_methods?
+        !custom_methods.empty?
+      end
+
+      def multiple_mappings?
+        name.is_a?(Array)
+      end
+
+      def raw_mapping?
+        name == Constants::RAW_MAPPING_KEY
+      end
+
+      def eql?(other)
+        other.class == self.class &&
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+      end
+      alias == eql?
+
+      def deep_dup
+        raise NotImplementedError, "Subclasses must implement `deep_dup`."
+      end
+
+      def value_map(key, options = {})
+        options = {
+          nil: options[:nil],
+          empty: options[:empty],
+          omitted: options[:omitted],
+        }.compact
+
+        @value_map[key].merge(options)
+      end
+
+      private
+
+      # if value is nil and render nil is false, will not render
+      # if value is empty and render empty is false, will not render
+      # if value is uninitialized and render omitted is false, will not render
+      def invalid_value?(value, options)
+        (!render_nil?(options) && value.nil?) ||
+          (!render_empty?(options) && Utils.empty?(value)) ||
+          (!render_omitted?(options) && Utils.uninitialized?(value))
+      end
+
+      def handle_custom_method(model, value, mapper_class)
+        return if !custom_methods[:from] || value.nil?
+
+        mapper_class.new.send(custom_methods[:from], model, value)
+        true
+      end
+
+      def handle_delegate(model, value, attributes)
+        return unless delegate
+
+        handle_nil_or_uninitialized(model, attributes)
+        assign_value(model.public_send(delegate), value)
+        true
+      end
+
+      def handle_nil_or_uninitialized(model, attributes)
+        delegate_value = model.public_send(delegate)
+        return if Utils.initialized?(delegate_value) && !delegate_value.nil?
+
+        model.public_send(:"#{delegate}=", attributes[delegate].type.new)
+      end
+
+      def handle_transform_method(model, value, attributes)
+        transform_method = transform[:import] || attributes[to].transform_import_method
+        return unless transform_method
+
+        assign_value(model, transform_method.call(value))
+        true
+      end
+
+      def assign_value(model, value)
+        model.public_send(:"#{to}=", value)
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping/toml_mapping.rb

@@ -0,0 +1,25 @@
+require_relative "key_value_mapping"
+
+module Lutaml
+  module Model
+    class TomlMapping < KeyValueMapping
+      def initialize
+        super(:toml)
+      end
+
+      def deep_dup
+        self.class.new.tap do |new_mapping|
+          new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+        end
+      end
+
+      def validate!(key, to, with, render_nil, render_empty)
+        super
+
+        if [true, :as_nil].include?(render_nil) || render_empty == :as_nil
+          raise IncorrectMappingArgumentsError, "nil values are not supported in toml format"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/{xml_mapping.rb → mapping/xml_mapping.rb}

@@ -26,6 +26,7 @@ module Lutaml
         @content_mapping = nil
         @raw_mapping = nil
         @mixed_content = false
+        @format = :xml
       end
 
       alias mixed_content? mixed_content
@@ -70,31 +71,45 @@ module Lutaml
         to: nil,
         render_nil: false,
         render_default: false,
+        render_empty: false,
+        treat_nil: :nil,
+        treat_empty: :empty,
+        treat_omitted: :nil,
         with: {},
         delegate: nil,
         cdata: false,
+        polymorphic: {},
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
                  nil),
-        transform: {}
+        transform: {},
+        value_map: {}
       )
-        validate!(name, to, with, type: TYPES[:element])
+        validate!(
+          name, to, with, render_nil, render_empty, type: TYPES[:element]
+        )
 
         rule = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
+          render_empty: render_empty,
+          treat_nil: treat_nil,
+          treat_empty: treat_empty,
+          treat_omitted: treat_omitted,
           with: with,
           delegate: delegate,
           cdata: cdata,
           namespace: namespace,
           default_namespace: namespace_uri,
           prefix: prefix,
+          polymorphic: polymorphic,
           namespace_set: namespace_set != false,
           prefix_set: prefix_set != false,
           transform: transform,
+          value_map: value_map,
         )
         @elements[rule.namespaced_name] = rule
       end
@@ -104,14 +119,20 @@ module Lutaml
         to: nil,
         render_nil: false,
         render_default: false,
+        render_empty: false,
         with: {},
         delegate: nil,
+        polymorphic_map: {},
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
-                 nil)
+                 nil),
+        value_map: {}
       )
-        validate!(name, to, with, type: TYPES[:attribute])
+        validate!(
+          name, to, with, render_nil, render_empty, type: TYPES[:attribute]
+        )
+
         warn_auto_handling(name) if name == "schemaLocation"
 
         rule = XmlMappingRule.new(
@@ -124,9 +145,11 @@ module Lutaml
           namespace: namespace,
           prefix: prefix,
           attribute: true,
+          polymorphic_map: polymorphic_map,
           default_namespace: namespace_uri,
           namespace_set: namespace_set != false,
           prefix_set: prefix_set != false,
+          value_map: value_map,
         )
         @attributes[rule.namespaced_name] = rule
       end
@@ -137,22 +160,28 @@ module Lutaml
         to: nil,
         render_nil: false,
         render_default: false,
+        render_empty: false,
         with: {},
         delegate: nil,
         mixed: false,
-        cdata: false
+        cdata: false,
+        value_map: {}
       )
-        validate!("content", to, with, type: TYPES[:content])
+        validate!(
+          "content", to, with, render_nil, render_empty, type: TYPES[:content]
+        )
 
         @content_mapping = XmlMappingRule.new(
           nil,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
+          render_empty: render_empty,
           with: with,
           delegate: delegate,
           mixed_content: mixed,
           cdata: cdata,
+          value_map: value_map,
         )
       end
 
@@ -165,9 +194,17 @@ module Lutaml
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
-                 nil)
+                 nil),
+        render_empty: false
       )
-        validate!(Constants::RAW_MAPPING_KEY, to, with, type: TYPES[:all_content])
+        validate!(
+          Constants::RAW_MAPPING_KEY,
+          to,
+          with,
+          render_nil,
+          render_empty,
+          type: TYPES[:all_content],
+        )
 
         rule = XmlMappingRule.new(
           Constants::RAW_MAPPING_KEY,
@@ -203,21 +240,36 @@ module Lutaml
         (@element_sequence << mappings.element_sequence).flatten!
       end
 
-      def validate!(key, to, with, type: nil)
-        validate_mappings!(type)
+      def validate!(key, to, with, render_nil, render_empty, type: nil)
+        validate_raw_mappings!(type)
+        validate_to_and_with_arguments!(key, to, with)
 
+        if render_nil == :as_empty || render_empty == :as_empty
+          raise IncorrectMappingArgumentsError.new(
+            ":as_empty is not supported for XML mappings",
+          )
+        end
+      end
+
+      def validate_to_and_with_arguments!(key, to, with)
         if to.nil? && with.empty?
-          msg = ":to or :with argument is required for mapping '#{key}'"
-          raise IncorrectMappingArgumentsError.new(msg)
+          raise IncorrectMappingArgumentsError.new(
+            ":to or :with argument is required for mapping '#{key}'",
+          )
         end
 
+        validate_with_options!(key, with)
+      end
+
+      def validate_with_options!(key, with)
         if !with.empty? && (with[:from].nil? || with[:to].nil?)
-          msg = ":with argument for mapping '#{key}' requires :to and :from keys"
-          raise IncorrectMappingArgumentsError.new(msg)
+          raise IncorrectMappingArgumentsError.new(
+            ":with argument for mapping '#{key}' requires :to and :from keys",
+          )
         end
       end
 
-      def validate_mappings!(type)
+      def validate_raw_mappings!(type)
         if !@raw_mapping.nil? && type != TYPES[:attribute]
           raise StandardError, "#{type} is not allowed, only #{TYPES[:attribute]} " \
                                "is allowed with #{TYPES[:all_content]}"
@@ -270,6 +322,32 @@ module Lutaml
         end
       end
 
+      def mapping_attributes_hash
+        @attributes
+      end
+
+      def mapping_elements_hash
+        @elements
+      end
+
+      def merge_mapping_attributes(mapping)
+        mapping_attributes_hash.merge!(mapping.mapping_attributes_hash)
+      end
+
+      def merge_mapping_elements(mapping)
+        mapping_elements_hash.merge!(mapping.mapping_elements_hash)
+      end
+
+      def merge_elements_sequence(mapping)
+        mapping.element_sequence.each do |sequence|
+          element_sequence << Lutaml::Model::Sequence.new(self).tap do |instance|
+            sequence.attributes.each do |attr|
+              instance.attributes << attr.deep_dup
+            end
+          end
+        end
+      end
+
       def deep_dup
         self.class.new.tap do |xml_mapping|
           xml_mapping.root(@root_element.dup, mixed: @mixed_content,
@@ -283,6 +361,10 @@ module Lutaml
         end
       end
 
+      def polymorphic_mapping
+        mappings.find(&:polymorphic_mapping?)
+      end
+
       def attributes_to_dup
         @attributes_to_dup ||= %i[
           @content_mapping

data/lib/lutaml/model/{xml_mapping_rule.rb → mapping/xml_mapping_rule.rb}

@@ -10,6 +10,10 @@ module Lutaml
         to:,
         render_nil: false,
         render_default: false,
+        render_empty: false,
+        treat_nil: nil,
+        treat_empty: nil,
+        treat_omitted: nil,
         with: {},
         delegate: nil,
         namespace: nil,
@@ -20,17 +24,27 @@ module Lutaml
         prefix_set: false,
         attribute: false,
         default_namespace: nil,
-        transform: {}
+        polymorphic: {},
+        polymorphic_map: {},
+        transform: {},
+        value_map: {}
       )
         super(
           name,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
+          render_empty: render_empty,
+          treat_nil: treat_nil,
+          treat_empty: treat_empty,
+          treat_omitted: treat_omitted,
           with: with,
           delegate: delegate,
           attribute: attribute,
-          transform: transform
+          polymorphic: polymorphic,
+          polymorphic_map: polymorphic_map,
+          transform: transform,
+          value_map: value_map,
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -87,7 +101,7 @@ module Lutaml
       end
 
       def namespaced_name(parent_namespace = nil, name = self.name)
-        if name == "lang"
+        if name.to_s == "lang"
           "#{prefix}:#{name}"
         elsif namespace_set? || @attribute
           [namespace, name].compact.join(":")
@@ -113,8 +127,11 @@ module Lutaml
           namespace_set: namespace_set?,
           prefix_set: prefix_set?,
           attribute: attribute,
+          polymorphic: polymorphic.dup,
           default_namespace: default_namespace.dup,
           transform: transform.dup,
+          render_empty: render_empty.dup,
+          value_map: Utils.deep_dup(@value_map),
         )
       end
     end

data/lib/lutaml/model/mapping/yaml_mapping.rb

@@ -0,0 +1,17 @@
+require_relative "key_value_mapping"
+
+module Lutaml
+  module Model
+    class YamlMapping < KeyValueMapping
+      def initialize
+        super(:yaml)
+      end
+
+      def deep_dup
+        self.class.new.tap do |new_mapping|
+          new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping.rb

@@ -0,0 +1,14 @@
+module Lutaml
+  module Model
+    module Mapping
+    end
+  end
+end
+
+require_relative "mapping/mapping_rule"
+require_relative "mapping/yaml_mapping"
+require_relative "mapping/json_mapping"
+require_relative "mapping/toml_mapping"
+require_relative "mapping/key_value_mapping_rule"
+require_relative "mapping/xml_mapping"
+require_relative "mapping/xml_mapping_rule"