lutaml-model 0.3.6 → 0.3.7

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

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.6"
+    VERSION = "0.3.7"
   end
 end

data/lib/lutaml/model/xml_adapter/builder/nokogiri.rb

@@ -0,0 +1,73 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Nokogiri
+          def self.build(options = {})
+            if block_given?
+              ::Nokogiri::XML::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Nokogiri::XML::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            xml.doc.create_element(name, attributes)
+          end
+
+          def add_element(element, child)
+            element.add_child(child)
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            add_namespace_prefix(prefix) if prefix
+
+            if block_given?
+              public_send(element_name, attributes) do
+                yield(self)
+              end
+            else
+              public_send(element_name, attributes)
+            end
+          end
+
+          def add_text(element, text)
+            if element.is_a?(self.class)
+              element = element.xml.parent
+            end
+
+            add_element(element, ::Nokogiri::XML::Text.new(text.to_s, xml.doc))
+          end
+
+          def add_namespace_prefix(prefix)
+            xml[prefix] if prefix
+
+            self
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/builder/ox.rb

@@ -0,0 +1,89 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Ox
+          def self.build(options = {})
+            if block_given?
+              ::Ox::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Ox::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            if block_given?
+              xml.element(name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(name, attributes)
+            end
+          end
+
+          def add_element(element, child)
+            element << child
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            prefixed_name = if prefix
+                              "#{prefix}:#{element_name}"
+                            else
+                              element_name
+                            end
+
+            if block_given?
+              xml.element(prefixed_name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(prefixed_name, attributes)
+            end
+          end
+
+          def <<(text)
+            xml.text(text)
+          end
+
+          def add_text(element, text)
+            element << text
+          end
+
+          # Add XML namespace to document
+          #
+          # Ox doesn't support XML namespaces so this method does nothing.
+          def add_namespace_prefix(_prefix)
+            # :noop:
+            self
+          end
+
+          def parent
+            xml
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end

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,6 +2,7 @@
 
 require_relative "model/version"
 require_relative "model/type"
+require_relative "model/utils"
 require_relative "model/serializable"
 require_relative "model/json_adapter/standard_json_adapter"
 require_relative "model/yaml_adapter/standard_yaml_adapter"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -82,8 +82,11 @@ files:
 - lib/lutaml/model/type.rb
 - lib/lutaml/model/type/date_time.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