lutaml-model 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45fc67305626a2fe4d38db31804a618fd887a9855ff8ddb7ef2d0d0e8cc8b9b8
-  data.tar.gz: 7ffbc1f1b1958d05ebbf82889b1b54f032df48a4ed9052f3a963b896bfb43238
+  metadata.gz: 30487a24277470ff7b3d12193e46262b0fc1cac85461224ed98749c8b6de5104
+  data.tar.gz: a161a8e5f83a10ec5db5b77a0d5a0abe72b629d0900a4ab040414c2a02c22725
 SHA512:
-  metadata.gz: 37a4e64c1b61b6a1112329b18ea4bd9b544fe125859cd81a1054b162817e1ffb22e03f4168836ce8890e6f6cba6f137c78110522322c0a0fe6fde3e121c533d4
-  data.tar.gz: bd3bfb6600103c25034c3604fcdc83947d8eb3a14b23ec54e93186f66d273a5270a923394bd5f00e5caf3d58c9ff7c65efce9cd5f7a874ac22f4582711622d27
+  metadata.gz: 2a805f81f93bc0dcb983d83e7f7fc870989f84fb25434de7edee18269c1b96b8572516132e17e3db2e188075e985cb8219ec84257fd380c7abfe4b65b32116af
+  data.tar.gz: 0243f89d6fb6c5466e29500e810a077096e260b51d53a8a23db7918c7b2d57dc30a9757dd00814a2c497dd552e39bd17e92729c509670dde555a0b508a77013b

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2024-08-19 03:44:26 UTC using RuboCop version 1.65.1.
+# on 2024-08-27 06:48:03 UTC using RuboCop version 1.65.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -14,7 +14,7 @@ Gemspec/RequireMFA:
   Exclude:
     - 'lutaml-model.gemspec'
 
-# Offense count: 78
+# Offense count: 57
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns.
 # URISchemes: http, https
@@ -24,6 +24,7 @@ Layout/LineLength:
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/serialize.rb'
     - 'lib/lutaml/model/type.rb'
+    - 'lib/lutaml/model/utils.rb'
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
@@ -43,7 +44,7 @@ Lint/ConstantDefinitionInBlock:
     - 'spec/lutaml/model/schema/xsd_schema_spec.rb'
     - 'spec/lutaml/model/schema/yaml_schema_spec.rb'
 
-# Offense count: 31
+# Offense count: 28
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
@@ -56,16 +57,17 @@ Metrics/AbcSize:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 4
+# Offense count: 5
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
-  Max: 31
+  Max: 43
 
-# Offense count: 23
+# Offense count: 22
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
+    - 'lib/lutaml/model/attribute.rb'
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/serialize.rb'
     - 'lib/lutaml/model/type.rb'
@@ -73,23 +75,23 @@ Metrics/CyclomaticComplexity:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 38
+# Offense count: 36
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 52
+  Max: 43
 
 # Offense count: 4
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
   Max: 9
 
-# Offense count: 20
+# Offense count: 18
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
+    - 'lib/lutaml/model/attribute.rb'
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/serialize.rb'
-    - 'lib/lutaml/model/type.rb'
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
@@ -103,7 +105,7 @@ RSpec/ContextWording:
     - 'spec/lutaml/model/xml_adapter/oga_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/ox_adapter_spec.rb'
 
-# Offense count: 73
+# Offense count: 76
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 57
@@ -132,7 +134,7 @@ RSpec/MultipleDescribes:
 
 # Offense count: 70
 RSpec/MultipleExpectations:
-  Max: 15
+  Max: 10
 
 # Offense count: 11
 # Configuration parameters: AllowSubject.

data/README.adoc

@@ -1338,11 +1338,11 @@ class CustomCeramic < Lutaml::Model::Serializable
   end
 
   def name_to_json(model, value)
-    "Masterpiece: #{value}"
+    doc["name"] = "Masterpiece: #{value}"
   end
 
   def name_from_json(model, doc)
-    doc['name'].sub(/^Masterpiece: /, '')
+    model.name = value.sub(/^JSON Masterpiece: /, '')
   end
 end
 ----
@@ -1971,52 +1971,56 @@ class Example < Lutaml::Model::Serializable
                         from: :description_from_xml }
   end
 
-  def name_to_json(_model, value)
-    "JSON Masterpiece: #{value}"
+  def name_to_json(model, doc)
+    doc["name"] = "JSON Masterpiece: #{model.name}"
   end
 
-  def name_from_json(_model, doc)
-    doc["name"].sub(/^JSON Masterpiece: /, "")
+  def name_from_json(model, value)
+    model.name = value.sub(/^JSON Masterpiece: /, "")
   end
 
-  def color_to_json(_model, value)
-    value.upcase
+  def color_to_json(model, doc)
+    doc["color"] = model.color.upcase
   end
 
-  def color_from_json(_model, doc)
-    doc["color"].downcase
+  def color_from_json(model, value)
+    model.color = value.downcase
   end
 
-  def description_to_json(_model, value)
-    "JSON Description: #{value}"
+  def description_to_json(model, doc)
+    doc["description"] = "JSON Description: #{model.description}"
   end
 
-  def description_from_json(_model, doc)
-    doc["description"].sub(/^JSON Description: /, "")
+  def description_from_json(model, value)
+    model.description = value.sub(/^JSON Description: /, "")
   end
 
-  def name_to_xml(_model, value)
-    "XML Masterpiece: #{value}"
+  def name_to_xml(model, parent, doc)
+    el = doc.create_element("Name")
+    doc.add_text(el, "XML Masterpiece: #{model.name}")
+    doc.add_element(parent, el)
   end
 
-  def name_from_xml(_model, value)
-    value.sub(/^XML Masterpiece: /, "")
+  def name_from_xml(model, value)
+    model.name = value.sub(/^XML Masterpiece: /, "")
   end
 
-  def color_to_xml(_model, value)
-    value.upcase
+  def color_to_xml(model, parent, doc)
+    color_element = doc.create_element("Color")
+    doc.add_text(color_element, model.color.upcase)
+    doc.add_element(parent, color_element)
   end
 
-  def color_from_xml(_model, value)
-    value.downcase
+  def color_from_xml(model, value)
+    model.color = value.downcase
   end
 
-  def description_to_xml(_model, value)
-    "XML Description: #{value}"
+  def description_to_xml(model, parent, doc)
+    doc.add_text(parent, "XML Description: #{model.description}")
   end
 
-  def description_from_xml(_model, value)
-    value.sub(/^XML Description: /, "")
+  def description_from_xml(model, value)
+    model.description = value.join.strip.sub(/^XML Description: /, "")
   end
 end
 ----

data/lib/lutaml/model/attribute.rb

@@ -40,6 +40,33 @@ module Lutaml
       def render_nil?
         options.fetch(:render_nil, false)
       end
+
+      def serialize(value, format, options = {})
+        if value.is_a?(Array)
+          value.map do |v|
+            serialize(v, format, options)
+          end
+        elsif type <= Serialize
+          type.hash_representation(value, format, options)
+        else
+          type.serialize(value)
+        end
+      end
+
+      def cast(value, format, options = {})
+        value ||= [] if collection?
+        instance = options[:instance]
+
+        if value.is_a?(Array)
+          value.map do |v|
+            cast(v, format, instance: instance)
+          end
+        elsif type <= Serialize && value.is_a?(Hash)
+          type.apply_mappings(value, format, options)
+        else
+          Lutaml::Model::Type.cast(value, type)
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/serialize.rb

@@ -84,29 +84,47 @@ module Lutaml
 
           define_method(:"from_#{format}") do |data|
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
+
             doc = adapter.parse(data)
-            mapped_attrs = apply_mappings(doc.to_h, format)
-            # apply_content_mapping(doc, mapped_attrs) if format == :xml
-            generate_model_object(self, mapped_attrs)
+            public_send(:"of_#{format}", doc.to_h)
           end
 
-          define_method(:"to_#{format}") do |instance|
-            unless instance.is_a?(model)
-              msg = "argument is a '#{instance.class}' but should be a '#{model}'"
-              raise Lutaml::Model::IncorrectModelError, msg
+          define_method(:"of_#{format}") do |hash|
+            if hash.is_a?(Array)
+              return hash.map do |item|
+                apply_mappings(item, format)
+              end
             end
 
+            apply_mappings(hash, format)
+          end
+
+          define_method(:"to_#{format}") do |instance|
+            value = public_send(:"as_#{format}", instance)
             adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
 
             if format == :xml
               xml_options = { mapper_class: self }
-
-              adapter.new(instance).public_send(:"to_#{format}", xml_options)
+              adapter.new(value).public_send(:"to_#{format}", xml_options)
             else
-              hash = hash_representation(instance, format)
-              adapter.new(hash).public_send(:"to_#{format}")
+              adapter.new(value).public_send(:"to_#{format}")
             end
           end
+
+          define_method(:"as_#{format}") do |instance|
+            if instance.is_a?(Array)
+              return instance.map { |item| public_send(:"as_#{format}", item) }
+            end
+
+            unless instance.is_a?(model)
+              msg = "argument is a '#{instance.class}' but should be a '#{model}'"
+              raise Lutaml::Model::IncorrectModelError, msg
+            end
+
+            return instance if format == :xml
+
+            hash_representation(instance, format)
+          end
         end
 
         def hash_representation(instance, format, options = {})
@@ -118,13 +136,13 @@ module Lutaml
             name = rule.to
             next if except&.include?(name) || (only && !only.include?(name))
 
-            next handle_delegate(instance, rule, hash) if rule.delegate
+            next handle_delegate(instance, rule, hash, format) if rule.delegate
 
-            value = if rule.custom_methods[:to]
-                      instance.send(rule.custom_methods[:to], instance, instance.send(name))
-                    else
-                      instance.send(name)
-                    end
+            if rule.custom_methods[:to]
+              next instance.send(rule.custom_methods[:to], instance, hash)
+            end
+
+            value = instance.send(name)
 
             next if value.nil? && !rule.render_nil
 
@@ -132,68 +150,27 @@ module Lutaml
 
             hash[rule.from] = if rule.child_mappings
                                 generate_hash_from_child_mappings(value, rule.child_mappings)
-                              elsif value.is_a?(Array)
-                                value.map do |v|
-                                  if attribute.type <= Serialize
-                                    attribute.type.hash_representation(v, format, options)
-                                  else
-                                    attribute.type.serialize(v)
-                                  end
-                                end
-                              elsif attribute.type <= Serialize
-                                attribute.type.hash_representation(value, format, options)
                               else
-                                attribute.type.serialize(value)
+                                attribute.serialize(value, format, options)
                               end
           end
         end
 
-        def handle_delegate(instance, rule, hash)
+        def handle_delegate(instance, rule, hash, format)
           name = rule.to
           value = instance.send(rule.delegate).send(name)
           return if value.nil? && !rule.render_nil
 
           attribute = instance.send(rule.delegate).class.attributes[name]
-          hash[rule.from] = case value
-                            when Array
-                              value.map do |v|
-                                if v.is_a?(Serialize)
-                                  hash_representation(v, format, options)
-                                else
-                                  attribute.type.serialize(v)
-                                end
-                              end
-                            else
-                              if value.is_a?(Serialize)
-                                hash_representation(value, format, options)
-                              else
-                                attribute.type.serialize(value)
-                              end
-                            end
+          hash[rule.from] = attribute.serialize(value, format)
         end
 
         def mappings_for(format)
           mappings[format] || default_mappings(format)
         end
 
-        def generate_model_object(type, mapped_attrs)
-          return type.model.new(mapped_attrs) if self == model
-
-          instance = type.model.new
-
-          type.attributes.each do |name, attr|
-            value = attr_value(mapped_attrs, name, attr)
-
-            instance.send(:"#{name}=", ensure_utf8(value))
-          end
-
-          instance
-        end
-
         def attr_value(attrs, name, attr_rule)
-          value = if attrs.key?(name)
-                    attrs[name]
-                  elsif attrs.key?(name.to_sym)
+          value = if attrs.key?(name.to_sym)
                     attrs[name.to_sym]
                   elsif attrs.key?(name.to_s)
                     attrs[name.to_s]
@@ -211,8 +188,6 @@ module Lutaml
                 Lutaml::Model::Type.cast(v, attr_rule.type)
               end
             end
-          elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
-            generate_model_object(attr_rule.type, value)
           else
             # TODO: This code is problematic because Type.cast does not know
             # about all the types.
@@ -279,11 +254,13 @@ module Lutaml
           hash
         end
 
-        def apply_mappings(doc, format)
-          return apply_xml_mapping(doc) if format == :xml
+        def apply_mappings(doc, format, options = {})
+          instance = options[:instance] || model.new
+          return instance if !doc || doc.empty?
+          return apply_xml_mapping(doc, instance, options) if format == :xml
 
           mappings = mappings_for(format).mappings
-          mappings.each_with_object(Lutaml::Model::MappingHash.new) do |rule, hash|
+          mappings.each do |rule|
             attr = if rule.delegate
                      attributes[rule.delegate].type.attributes[rule.to]
                    else
@@ -292,106 +269,96 @@ module Lutaml
 
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = if rule.custom_methods[:from]
-                      new.send(rule.custom_methods[:from], hash, doc)
-                    elsif doc.key?(rule.name) || doc.key?(rule.name.to_sym)
+            value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
                       doc[rule.name] || doc[rule.name.to_sym]
                     else
                       attr.default
                     end
 
-            value = apply_child_mappings(value, rule.child_mappings)
-
-            if attr.collection?
-              value = (value || []).map do |v|
-                attr.type <= Serialize ? attr.type.apply_mappings(v, format) : v
-              end
-            elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-              value = attr.type.apply_mappings(value, format)
+            if rule.custom_methods[:from]
+              value = new.send(rule.custom_methods[:from], instance, value) if value && !value.empty?
+              next
             end
 
+            value = apply_child_mappings(value, rule.child_mappings)
+            value = attr.cast(value, format)
+
             if rule.delegate
-              hash[rule.delegate] ||= {}
-              hash[rule.delegate][rule.to] = value
+              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
-              hash[rule.to] = value
+              instance.public_send(:"#{rule.to}=", value)
             end
           end
+
+          instance
         end
 
-        def apply_xml_mapping(doc, caller_class: nil, mixed_content: false)
-          return unless doc
+        def apply_xml_mapping(doc, instance, options = {})
+          return instance unless doc
 
           mappings = mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
             raise "May be `collection: true` is" \
-                  "missing for #{self} in #{caller_class}"
+                  "missing for #{self} in #{options[:caller_class]}"
           end
 
-          mapping_hash = Lutaml::Model::MappingHash.new
-          mapping_hash.item_order = doc.item_order
-          mapping_hash.ordered = mappings_for(:xml).mixed_content? || mixed_content
-
-          mapping_from = []
+          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]
+          end
 
-          mappings.each_with_object(mapping_hash) do |rule, hash|
+          mappings.each do |rule|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
             is_content_mapping = rule.name.nil?
+
             value = if is_content_mapping
                       doc["text"]
                     else
                       doc[rule.name.to_s] || doc[rule.name.to_sym]
                     end
 
-            if attr.collection?
-              if value && !value.is_a?(Array)
-                value = [value]
-              end
+            value = [value].compact if attr.collection? && !value.is_a?(Array)
 
-              value = (value || []).map do |v|
-                if attr.type <= Serialize
-                  attr.type.apply_xml_mapping(v, caller_class: self, mixed_content: rule.mixed_content)
-                elsif v.is_a?(Hash)
-                  v["text"]
-                else
-                  v
-                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 = attr.type.apply_xml_mapping(value, caller_class: self, mixed_content: rule.mixed_content)
-            else
-              if value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-                value = value["text"]
-              end
-
-              value = attr.type.cast(value) unless is_content_mapping
+            elsif !(attr.type <= Serialize) && value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+              value = value["text"]
             end
 
-            mapping_from << rule if rule.custom_methods[:from]
-
-            hash[rule.to] = value
-          end
-
-          mapping_from.each do |rule|
-            value = if rule.name.nil?
-                      mapping_hash[rule.to].join("\n").strip
-                    else
-                      mapping_hash[rule.to]
-                    end
+            unless is_content_mapping
+              value = attr.cast(
+                value,
+                :xml,
+                caller_class: self,
+                mixed_content: rule.mixed_content,
+              )
+            end
 
-            mapping_hash[rule.to] = new.send(rule.custom_methods[:from], mapping_hash, value)
+            if rule.custom_methods[:from]
+              new.send(rule.custom_methods[:from], instance, value)
+            else
+              instance.public_send(:"#{rule.to}=", value)
+            end
           end
 
-          mapping_hash
+          instance
         end
 
         def ensure_utf8(value)
           case value
           when String
-            value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+            value.encode("UTF-8", invalid: :replace, undef: :replace,
+                                  replace: "")
           when Array
             value.map { |v| ensure_utf8(v) }
           when Hash
@@ -406,7 +373,7 @@ module Lutaml
         end
       end
 
-      attr_reader :element_order
+      attr_accessor :element_order
 
       def initialize(attrs = {})
         return unless self.class.attributes
@@ -429,6 +396,10 @@ module Lutaml
         @ordered
       end
 
+      def ordered=(ordered)
+        @ordered = ordered
+      end
+
       def key_exist?(hash, key)
         hash.key?(key.to_sym) || hash.key?(key.to_s)
       end
@@ -444,7 +415,8 @@ module Lutaml
           representation = if format == :xml
                              self
                            else
-                             self.class.hash_representation(self, format, options)
+                             self.class.hash_representation(self, format,
+                                                            options)
                            end
 
           adapter.new(representation).public_send(:"to_#{format}", options)
@@ -455,7 +427,8 @@ module Lutaml
         self.class.attributes.each do |name, attr|
           value = send(name)
           unless self.class.attr_value_valid?(name, value)
-            raise Lutaml::Model::InvalidValueError.new(name, value, attr.options[:values])
+            raise Lutaml::Model::InvalidValueError.new(name, value,
+                                                       attr.options[:values])
           end
         end
       end

data/lib/lutaml/model/type.rb

@@ -22,11 +22,13 @@ module Lutaml
                      class #{t}                        # class Integer
             def self.cast(value)            #   def self.cast(value)
               return if value.nil?          #     return if value.nil?
+                                            #
               Type.cast(value, #{t})        #     Type.cast(value, Integer)
             end                             #   end
 
             def self.serialize(value)       #   def self.serialize(value)
               return if value.nil?          #     return if value.nil?
+                                            #
               Type.serialize(value, #{t})   #     Type.serialize(value, Integer)
             end                             #   end
           end                               # end

data/lib/lutaml/model/utils.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Utils
+      class << self
+        # Convert string to camel case
+        def camel_case(str)
+          return "" if str.nil? || str.empty?
+
+          str.split("/").map { |part| camelize_part(part) }.join("::")
+        end
+
+        # Convert string to class name
+        def classify(str)
+          str = str.to_s.delete(".")
+          str = str.sub(/^[a-z\d]*/) { |match| camel_case(match) || match }
+
+          str.gsub("::", "/").gsub(%r{(?:_|-|(/))([a-z\d]*)}i) do
+            word = Regexp.last_match(2)
+            substituted = camel_case(word) || word
+            Regexp.last_match(1) ? "::#{substituted}" : substituted
+          end
+        end
+
+        # Convert string to snake case
+        def snake_case(str)
+          str = str.to_s.tr(".", "_")
+          return str unless /[A-Z-]|::/.match?(str)
+
+          str.gsub("::", "/")
+            .gsub(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { "#{$1 || $2}_" }
+            .tr("-", "_")
+            .downcase
+        end
+
+        private
+
+        def camelize_part(part)
+          part.gsub(/(?:_|-|^)([a-z\d])/i) { $1.upcase }
+        end
+      end
+    end
+  end
+end