lutaml-model 0.6.7 → 0.7.2

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

@@ -11,20 +11,34 @@ module Lutaml
         to:,
         render_nil: false,
         render_default: false,
+        render_empty: false,
+        treat_nil: :nil,
+        treat_empty: :empty,
+        treat_omitted: :nil,
         with: {},
         delegate: nil,
         child_mappings: nil,
         root_mappings: 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,
-          transform: transform
+          polymorphic: polymorphic,
+          polymorphic_map: polymorphic_map,
+          transform: transform,
+          value_map: value_map,
         )
 
         @child_mappings = child_mappings
@@ -42,9 +56,11 @@ module Lutaml
           name.dup,
           to: to.dup,
           render_nil: render_nil.dup,
+          render_empty: render_empty.dup,
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           child_mappings: Utils.deep_dup(child_mappings),
+          value_map: Utils.deep_dup(@value_map),
         )
       end
 

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

@@ -0,0 +1,13 @@
+module Lutaml
+  module Model
+    class Mapping
+      def initialize
+        @mappings = []
+      end
+
+      def mappings
+        raise NotImplementedError, "#{self.class.name} must implement `mappings`."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,300 @@
+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 has_custom_method_for_serialization?
+        !custom_methods.empty? && custom_methods[:to]
+      end
+
+      def has_custom_method_for_deserialization?
+        !custom_methods.empty? && custom_methods[:from]
+      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)
+        assign_value(model, ImportTransformer.call(value, self, attributes[to]))
+        true
+      end
+
+      def assign_value(model, value)
+        model.public_send(:"#{to}=", value)
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/xml_compiler.rb

@@ -19,7 +19,7 @@ module Lutaml
           require "lutaml/model"
           <%=
             requiring_files = resolve_required_files(content)
-            if requiring_files.any?
+            if requiring_files&.any?
               requiring_files.map { |file| "require_relative \\\"\#{file}\\\"" }.join("\n") + "\n"
             end
           -%>
@@ -168,8 +168,8 @@ module Lutaml
           return if schemas.empty?
 
           schemas.each do |schema|
-            schema_to_models(schema.include) if schema.include.any?
-            schema_to_models(schema.import) if schema.import.any?
+            schema_to_models(schema.include) if schema.include&.any?
+            schema_to_models(schema.import) if schema.import&.any?
             resolved_element_order(schema).each do |order_item|
               item_name = order_item&.name
               case order_item
@@ -205,7 +205,7 @@ module Lutaml
           hash[:min_length] = restriction.min_length.map(&:value).max if restriction.min_length&.any?
           hash[:min_inclusive] = restriction.min_inclusive.map(&:value).max if restriction.min_inclusive&.any?
           hash[:max_inclusive] = restriction.max_inclusive.map(&:value).min if restriction.max_inclusive&.any?
-          hash[:length] = restriction_length(restriction.length) if restriction.length.any?
+          hash[:length] = restriction_length(restriction.length) if restriction.length&.any?
         end
 
         def restriction_length(lengths)
@@ -219,8 +219,8 @@ module Lutaml
 
         def setup_complex_type(complex_type)
           MappingHash.new.tap do |hash|
-            hash[:attributes] = [] if complex_type.attribute.any?
-            hash[:attribute_groups] = [] if complex_type.attribute_group.any?
+            hash[:attributes] = [] if complex_type.attribute&.any?
+            hash[:attribute_groups] = [] if complex_type.attribute_group&.any?
             hash[:mixed] = complex_type.mixed
             resolved_element_order(complex_type).each do |element|
               case element
@@ -253,10 +253,10 @@ module Lutaml
 
         def setup_sequence(sequence)
           MappingHash.new.tap do |hash|
-            hash[:sequences] = [] if sequence.sequence.any?
-            hash[:elements] = [] if sequence.element.any?
-            hash[:choice] = [] if sequence.choice.any?
-            hash[:groups] = [] if sequence.group.any?
+            hash[:sequences] = [] if sequence.sequence&.any?
+            hash[:elements] = [] if sequence.element&.any?
+            hash[:choice] = [] if sequence.choice&.any?
+            hash[:groups] = [] if sequence.group&.any?
             resolved_element_order(sequence).each do |instance|
               case instance
               when Xsd::Sequence
@@ -340,8 +340,8 @@ module Lutaml
             if attribute_group.ref
               hash[:ref_class] = attribute_group.ref
             else
-              hash[:attributes] = [] if attribute_group.attribute.any?
-              hash[:attribute_groups] = [] if attribute_group.attribute_group.any?
+              hash[:attributes] = [] if attribute_group.attribute&.any?
+              hash[:attribute_groups] = [] if attribute_group.attribute_group&.any?
               resolved_element_order(attribute_group).each do |instance|
                 case instance
                 when Xsd::Attribute
@@ -380,14 +380,14 @@ module Lutaml
           hash[:base_class] = restriction.base
           restriction_patterns(restriction.pattern, hash) if restriction.respond_to?(:pattern)
           restriction_content(hash, restriction)
-          return hash unless restriction.respond_to?(:enumeration) && restriction.enumeration.any?
+          return hash unless restriction.respond_to?(:enumeration) && restriction.enumeration&.any?
 
           hash[:values] = restriction.enumeration.map(&:value)
           hash
         end
 
         def restriction_patterns(patterns, hash)
-          return if patterns.empty?
+          return if Utils.blank?(patterns)
 
           hash[:pattern] = patterns.map { |p| "(#{p.value})" }.join("|")
           hash
@@ -426,7 +426,7 @@ module Lutaml
           MappingHash.new.tap do |hash|
             hash[:min_occurs] = element.min_occurs if element.min_occurs
             hash[:max_occurs] = element.max_occurs if element.max_occurs
-            element_hash[:arguments] = hash if hash.any?
+            element_hash[:arguments] = hash if hash&.any?
           end
         end
 

data/lib/lutaml/model/sequence.rb

@@ -1,8 +1,8 @@
 module Lutaml
   module Model
     class Sequence
-      attr_reader :attributes,
-                  :model
+      attr_accessor :model
+      attr_reader :attributes
 
       def initialize(model)
         @attributes = []

data/lib/lutaml/model/serialization_adapter.rb

@@ -0,0 +1,22 @@
+module Lutaml
+  module Model
+    class SerializationAdapter
+      def self.handles_format(format)
+        # Lutaml::Model::Config.register_format(format, self)
+        @handles = format
+      end
+
+      def self.document_class(klass = nil)
+        if klass
+          @document_class = klass
+        else
+          @document_class
+        end
+      end
+
+      def self.parse(data, _options = {})
+        document_class.parse(data, create_additions: false)
+      end
+    end
+  end
+end