lutaml-model 0.3.5 → 0.3.7

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -1,5 +1,6 @@
 require "nokogiri"
 require_relative "xml_document"
+require_relative "builder/nokogiri"
 
 module Lutaml
   module Model
@@ -12,12 +13,13 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          builder = Builder::Nokogiri.build(encoding: "UTF-8") do |xml|
             if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
               root.to_xml(xml)
             else
               mapper_class = options[:mapper_class] || @root.class
-              options[:xml_attributes] = build_namespace_attributes(mapper_class)
+              options[:xml_attributes] =
+                build_namespace_attributes(mapper_class)
               build_element(xml, @root, options)
             end
           end
@@ -31,59 +33,6 @@ module Lutaml
 
         private
 
-        def build_unordered_element(xml, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-          return xml unless xml_mapping
-
-          attributes = options[:xml_attributes] ||= {}
-          attributes = build_attributes(element,
-                                        xml_mapping).merge(attributes)&.compact
-
-          prefixed_xml = if options.key?(:namespace_prefix)
-                           options[:namespace_prefix] ? xml[options[:namespace_prefix]] : xml
-                         elsif xml_mapping.namespace_prefix
-                           xml[xml_mapping.namespace_prefix]
-                         else
-                           xml
-                         end
-
-          tag_name = options[:tag_name] || xml_mapping.root_element
-          prefixed_xml.public_send(tag_name, attributes) do
-            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
-              xml.parent.namespace = nil
-            end
-
-            xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
-              value = attribute_value_for(element, element_rule)
-
-              next if value.nil? && !element_rule.render_nil?
-
-              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
-
-              if attribute_def.collection?
-                value.each do |v|
-                  add_to_xml(nsp_xml, v, attribute_def, element_rule)
-                end
-              elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(nsp_xml, value, attribute_def, element_rule)
-              end
-            end
-
-            if (content_rule = xml_mapping.content_mapping)
-              text = element.send(content_rule.to)
-              text = text.join if text.is_a?(Array)
-
-              if content_rule.custom_methods[:to]
-                text = @root.send(content_rule.custom_methods[:to], @root, text)
-              end
-
-              prefixed_xml.text text
-            end
-          end
-        end
-
         def build_ordered_element(xml, element, options = {})
           mapper_class = options[:mapper_class] || element.class
           xml_mapping = mapper_class.mappings_for(:xml)
@@ -114,9 +63,9 @@ module Lutaml
               element_rule = xml_mapping.find_by_name(name)
               next if element_rule.nil?
 
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              attribute_def = attribute_definition_for(element, element_rule,
+                                                       mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
-              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
 
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
@@ -124,39 +73,16 @@ module Lutaml
 
                 prefixed_xml.text text
               elsif attribute_def.collection?
-                add_to_xml(nsp_xml, value[curr_index], attribute_def,
-                           element_rule)
+                add_to_xml(
+                  xml,
+                  element_rule.prefix,
+                  value[curr_index],
+                  attribute_def,
+                  element_rule,
+                )
               elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(nsp_xml, value, attribute_def, element_rule)
-              end
-            end
-          end
-        end
-
-        def add_to_xml(xml, value, attribute, rule)
-          if rule.custom_methods[:to]
-            value = @root.send(rule.custom_methods[:to], @root, value)
-          end
-
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(
-              xml,
-              value,
-              rule: rule,
-              attribute: attribute,
-            )
-          else
-            xml.public_send(rule.name) do
-              if !value.nil?
-                serialized_value = attribute.type.serialize(value)
-
-                if attribute.type == Lutaml::Model::Type::Hash
-                  serialized_value.each do |key, val|
-                    xml.public_send(key) { xml.text val }
-                  end
-                else
-                  xml.text(serialized_value)
-                end
+                add_to_xml(xml, element_rule.prefix, value, attribute_def,
+                           element_rule)
               end
             end
           end
@@ -205,7 +131,7 @@ module Lutaml
         end
 
         def to_xml(builder = nil)
-          builder ||= Nokogiri::XML::Builder.new
+          builder ||= Builder::Nokogiri.build
 
           if name == "text"
             builder.text(text)

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -1,5 +1,6 @@
 require "ox"
 require_relative "xml_document"
+require_relative "builder/ox"
 
 module Lutaml
   module Model
@@ -12,7 +13,7 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Ox::Builder.new
+          builder = Builder::Ox.build
 
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.to_xml(builder)
@@ -22,66 +23,12 @@ module Lutaml
             build_element(builder, @root, options)
           end
 
-          # xml_data = Ox.dump(builder)
-          xml_data = builder.to_s
+          xml_data = builder.xml.to_s
           options[:declaration] ? declaration(options) + xml_data : xml_data
         end
 
         private
 
-        def build_unordered_element(builder, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-          return xml unless xml_mapping
-
-          attributes = build_attributes(element, xml_mapping).compact
-
-          tag_name = options[:tag_name] || xml_mapping.root_element
-          prefixed_name = if options.key?(:namespace_prefix)
-                            [options[:namespace_prefix], tag_name].compact.join(":")
-                          elsif xml_mapping.namespace_prefix
-                            "#{xml_mapping.namespace_prefix}:#{tag_name}"
-                          else
-                            tag_name
-                          end
-
-          builder.element(prefixed_name, attributes) do |el|
-            xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
-              value = attribute_value_for(element, element_rule)
-
-              val = if attribute_def.collection?
-                      value
-                    elsif value || element_rule.render_nil?
-                      [value]
-                    else
-                      []
-                    end
-
-              val.each do |v|
-                if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(el, v, rule: element_rule, attribute: attribute_def)
-                else
-                  builder.element(element_rule.prefixed_name) do |el|
-                    el.text(attribute_def.type.serialize(v)) if v
-                  end
-                end
-              end
-            end
-
-            if (content_rule = xml_mapping.content_mapping)
-              text = element.send(xml_mapping.content_mapping.to)
-              text = text.join if text.is_a?(Array)
-
-              if content_rule.custom_methods[:to]
-                text = @root.send(content_rule.custom_methods[:to], @root, text)
-              end
-
-              el.text text
-            end
-          end
-        end
-
         def build_ordered_element(builder, element, options = {})
           mapper_class = options[:mapper_class] || element.class
           xml_mapping = mapper_class.mappings_for(:xml)
@@ -90,7 +37,8 @@ module Lutaml
           attributes = build_attributes(element, xml_mapping).compact
 
           tag_name = options[:tag_name] || xml_mapping.root_element
-          builder.element(tag_name, attributes) do |el|
+          builder.create_and_add_element(tag_name,
+                                         attributes: attributes) do |el|
             index_hash = {}
 
             element.element_order.each do |name|
@@ -99,47 +47,20 @@ module Lutaml
 
               element_rule = xml_mapping.find_by_name(name)
 
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              attribute_def = attribute_definition_for(element, element_rule,
+                                                       mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
-                el.text text
+                el.add_text(el, text)
               elsif attribute_def.collection?
-                add_to_xml(el, value[curr_index], attribute_def, element_rule)
+                add_to_xml(el, nil, value[curr_index], attribute_def,
+                           element_rule)
               elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(el, value, attribute_def, element_rule)
-              end
-            end
-          end
-        end
-
-        def add_to_xml(xml, value, attribute, rule)
-          if rule.custom_methods[:to]
-            value = @root.send(rule.custom_methods[:to], @root, value)
-          end
-
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(
-              xml,
-              value,
-              rule: rule,
-              attribute: attribute,
-            )
-          else
-            xml.element(rule.name) do |el|
-              if !value.nil?
-                serialized_value = attribute.type.serialize(value)
-
-                if attribute.type == Lutaml::Model::Type::Hash
-                  serialized_value.each do |key, val|
-                    el.element(key) { |child_el| child_el.text val }
-                  end
-                else
-                  el.text(serialized_value)
-                end
+                add_to_xml(el, nil, value, attribute_def, element_rule)
               end
             end
           end
@@ -188,13 +109,13 @@ module Lutaml
         end
 
         def to_xml(builder = nil)
-          builder ||= Ox::Builder.new
+          builder ||= Builder::Ox.build
           attrs = build_attributes(self)
 
           if text?
-            builder.text(text)
+            builder.add_text(builder, text)
           else
-            builder.element(name, attrs) do |el|
+            builder.create_and_add_element(name, attributes: attrs) do |el|
               children.each { |child| child.to_xml(el) }
             end
           end

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -97,6 +97,95 @@ module Lutaml
           end
         end
 
+        def add_to_xml(xml, prefix, value, attribute, rule)
+          if rule.custom_methods[:to]
+            @root.send(rule.custom_methods[:to], @root, xml.parent, xml)
+            return
+          end
+
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
+          else
+            xml.create_and_add_element(rule.name, prefix: prefix) do
+              if !value.nil?
+                serialized_value = attribute.type.serialize(value)
+
+                if attribute.type == Lutaml::Model::Type::Hash
+                  serialized_value.each do |key, val|
+                    xml.create_and_add_element(key) do |element|
+                      element.text(val)
+                    end
+                  end
+                else
+                  xml.add_text(xml, serialized_value)
+                end
+              end
+            end
+          end
+        end
+
+        def build_unordered_element(xml, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = options[:xml_attributes] ||= {}
+          attributes = build_attributes(element,
+                                        xml_mapping).merge(attributes)&.compact
+
+          prefix = if options.key?(:namespace_prefix)
+                     options[:namespace_prefix]
+                   elsif xml_mapping.namespace_prefix
+                     xml_mapping.namespace_prefix
+                   end
+
+          prefixed_xml = xml.add_namespace_prefix(prefix)
+          tag_name = options[:tag_name] || xml_mapping.root_element
+
+          xml.create_and_add_element(tag_name, prefix: prefix,
+                                               attributes: attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.add_namespace_prefix(nil)
+            end
+
+            xml_mapping.elements.each do |element_rule|
+              attribute_def = attribute_definition_for(element, element_rule,
+                                                       mapper_class: mapper_class)
+              value = attribute_value_for(element, element_rule)
+
+              next if value.nil? && !element_rule.render_nil?
+
+              if attribute_def.collection?
+                value = [value] unless value.is_a?(Array)
+
+                value.each do |v|
+                  add_to_xml(xml, element_rule.prefix, v, attribute_def,
+                             element_rule)
+                end
+              elsif !value.nil? || element_rule.render_nil?
+                add_to_xml(xml, element_rule.prefix, value, attribute_def,
+                           element_rule)
+              end
+            end
+
+            if (content_rule = xml_mapping.content_mapping)
+              if content_rule.custom_methods[:to]
+                @root.send(content_rule.custom_methods[:to], element,
+                           prefixed_xml.parent, prefixed_xml)
+              else
+                text = element.send(content_rule.to)
+                text = text.join if text.is_a?(Array)
+                prefixed_xml.add_text(xml, text)
+              end
+            end
+          end
+        end
+
         def ordered?(element, options = {})
           return false unless element.respond_to?(:element_order)
           return element.ordered? if element.respond_to?(:ordered?)

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

@@ -16,18 +16,6 @@ module Lutaml
         def to_yaml(options = {})
           YAML.dump(@attributes, options)
         end
-
-        # TODO: Is this really needed?
-        def self.to_yaml(attributes, *args)
-          new(attributes).to_yaml(*args)
-        end
-
-        # TODO: Is this really needed?
-        def self.from_yaml(yaml, klass)
-          data = parse(yaml)
-          mapped_attrs = klass.send(:apply_mappings, data, :yaml)
-          klass.new(mapped_attrs)
-        end
       end
     end
   end

data/lib/lutaml/model.rb

@@ -2,9 +2,10 @@
 
 require_relative "model/version"
 require_relative "model/type"
+require_relative "model/utils"
 require_relative "model/serializable"
-require_relative "model/json_adapter"
-require_relative "model/yaml_adapter"
+require_relative "model/json_adapter/standard_json_adapter"
+require_relative "model/yaml_adapter/standard_yaml_adapter"
 require_relative "model/xml_adapter"
 require_relative "model/toml_adapter"
 require_relative "model/error"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-18 00:00:00.000000000 Z
+date: 2024-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -56,6 +56,7 @@ files:
 - lib/lutaml/model/config.rb
 - lib/lutaml/model/error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
+- lib/lutaml/model/error/unknown_adapter_type_error.rb
 - lib/lutaml/model/json_adapter.rb
 - lib/lutaml/model/json_adapter/json_document.rb
 - lib/lutaml/model/json_adapter/json_object.rb
@@ -80,10 +81,12 @@ files:
 - lib/lutaml/model/toml_adapter/tomlib_adapter.rb
 - lib/lutaml/model/type.rb
 - lib/lutaml/model/type/date_time.rb
-- lib/lutaml/model/type/json.rb
 - lib/lutaml/model/type/time_without_date.rb
+- lib/lutaml/model/utils.rb
 - lib/lutaml/model/version.rb
 - lib/lutaml/model/xml_adapter.rb
+- lib/lutaml/model/xml_adapter/builder/nokogiri.rb
+- lib/lutaml/model/xml_adapter/builder/ox.rb
 - lib/lutaml/model/xml_adapter/nokogiri_adapter.rb
 - lib/lutaml/model/xml_adapter/oga_adapter.rb
 - lib/lutaml/model/xml_adapter/ox_adapter.rb

data/lib/lutaml/model/type/json.rb

@@ -1,34 +0,0 @@
-require "json"
-
-module Lutaml
-  module Model
-    module Type
-      # JSON representation
-      class Json
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-
-        def to_json(*_args)
-          @value.to_json
-        end
-
-        def ==(other)
-          @value == (other.is_a?(::Hash) ? other : other.value)
-        end
-
-        def self.cast(value)
-          return value if value.is_a?(self) || value.nil?
-
-          new(::JSON.parse(value))
-        end
-
-        def self.serialize(value)
-          value.to_json
-        end
-      end
-    end
-  end
-end