lutaml-model 0.1.0 → 0.2.1

data/lib/lutaml/model/type.rb

@@ -9,8 +9,6 @@ require "json"
 module Lutaml
   module Model
     module Type
-      class Boolean; end
-
       %w(String
          Integer
          Float
@@ -28,20 +26,29 @@ module Lutaml
          IPAddress
          JSON
          Enum).each do |t|
-        class_eval <<~HEREDOC
-                      class #{t}
-                        def self.cast(value)
-                         Type.cast(value, #{t})
-                       end
-                     end
-
-                   HEREDOC
+        class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+          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
+        HEREDOC
       end
 
       class TimeWithoutDate
         def self.cast(value)
-          parsed_time = ::Time.parse(value.to_s)
-          parsed_time.strftime("%H:%M:%S")
+          return if value.nil?
+
+          ::Time.parse(value.to_s)
+          # .strftime("%H:%M:%S")
         end
 
         def self.serialize(value)
@@ -51,64 +58,156 @@ module Lutaml
 
       class DateTime
         def self.cast(value)
-          ::DateTime.parse(value.to_s).new_offset(0).iso8601
+          return if value.nil?
+
+          ::DateTime.parse(value.to_s).new_offset(0)
+        end
+
+        def self.serialize(value)
+          value.iso8601
+        end
+      end
+
+      class Array
+        def initialize(array)
+          Array(array)
+        end
+      end
+
+      class JSON
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_json(*_args)
+          @value.to_json
+        end
+
+        def ==(other)
+          @value == if other.is_a?(::Hash)
+                      other
+                    else
+                      other.value
+                    end
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self)
+
+          new(::JSON.parse(value))
+        end
+
+        def self.serialize(value)
+          value.to_json
         end
       end
 
+      # rubocop:disable Layout/LineLength
+      UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
+      # rubocop:enable Layout/LineLength
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Layout/LineLength
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.cast(value, type)
-        case type
-        when String
+        return if value.nil?
+
+        if [String, Email].include?(type)
           value.to_s
-        when Integer
+        elsif [Integer, BigInteger].include?(type)
           value.to_i
-        when Float
+        elsif type == Float
           value.to_f
-        when Date
+        elsif type == Date
           begin
             ::Date.parse(value.to_s)
           rescue ArgumentError
             nil
           end
-        when DateTime
+        elsif type == DateTime
           DateTime.cast(value)
-        when Time
+        elsif type == Time
           ::Time.parse(value.to_s)
-        when TimeWithoutDate
+        elsif type == TimeWithoutDate
           TimeWithoutDate.cast(value)
-        when Boolean
+        elsif type == Boolean
           to_boolean(value)
-        when Decimal
+        elsif type == Decimal
           BigDecimal(value.to_s)
-        when Hash
-          Hash(value)
-        when UUID
-          value =~ /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/ ? value : SecureRandom.uuid
-        when Symbol
+        elsif type == Hash
+          normalize_hash(Hash(value))
+        elsif type == UUID
+          UUID_REGEX.match?(value) ? value : SecureRandom.uuid
+        elsif type == Symbol
           value.to_sym
-        when BigInteger
-          value.to_i
-        when Binary
+        elsif type == Binary
           value.force_encoding("BINARY")
-        when URL
+        elsif type == URL
           URI.parse(value.to_s)
-        when Email
-          value.to_s
-        when IPAddress
+        elsif type == IPAddress
           IPAddr.new(value.to_s)
-        when JSON
-          ::JSON.parse(value)
-        when Enum
-          value
+        elsif type == JSON
+          JSON.cast(value)
+        # elsif type == Enum
+        #   value
         else
           value
         end
       end
 
+      def self.serialize(value, type)
+        return if value.nil?
+
+        if type == Date
+          value.iso8601
+        elsif type == DateTime
+          DateTime.serialize(value)
+        elsif type == Integer
+          value.to_i
+        elsif type == Float
+          value.to_f
+        elsif type == Boolean
+          to_boolean(value)
+        elsif type == Decimal
+          value.to_s("F")
+        elsif type == Hash
+          Hash(value)
+        elsif type == JSON
+          value.to_json
+        else
+          value.to_s
+        end
+      end
+
       def self.to_boolean(value)
         return true if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
         return false if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
+
         raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
       end
+
+      def self.normalize_hash(hash)
+        return hash["text"] if hash.keys == ["text"]
+
+        hash.filter_map do |key, value|
+          next if key == "text"
+
+          if value.is_a?(::Hash)
+            [key, normalize_hash(value)]
+          else
+            [key, value]
+          end
+        end.to_h
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Layout/LineLength
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.1.0"
+    VERSION = "0.2.1"
   end
 end

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

@@ -12,12 +12,9 @@ module Lutaml
           new(root)
         end
 
-        def initialize(root)
-          @root = root
-        end
-
         def to_h
-          { @root.name => parse_element(@root) }
+          # { @root.name => parse_element(@root) }
+          parse_element(@root)
         end
 
         def to_xml(options = {})
@@ -25,55 +22,94 @@ module Lutaml
             build_element(xml, @root, options)
           end
 
-          xml_data = builder.to_xml(options[:pretty] ? { indent: 2 } : {})
+          xml_options = {}
+          xml_options[:indent] = 2 if options[:pretty]
+
+          xml_data = builder.doc.root.to_xml(xml_options)
           options[:declaration] ? declaration(options) + xml_data : xml_data
         end
 
         private
 
-        def build_element(xml, element, options = {})
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def build_element(xml, element, _options = {})
+          if element.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
+            return element.to_xml(xml)
+          end
+
           xml_mapping = element.class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = build_attributes(element, xml_mapping)
 
-          xml.send(xml_mapping.root_element, attributes) do
-            xml_mapping.elements.each do |element_rule|
-              attribute_def = element.class.attributes[element_rule.to]
-              value = element.send(element_rule.to)
+          prefixed_xml = if xml_mapping.namespace_prefix
+                           xml[xml_mapping.namespace_prefix]
+                         else
+                           xml
+                         end
 
-              if attribute_def&.type <= Lutaml::Model::Serialize
-                handle_nested_elements(xml, element_rule, value)
+          prefixed_xml.send(xml_mapping.root_element, attributes) do
+            xml_mapping.elements.each do |element_rule|
+              if element_rule.delegate
+                attribute_def =
+                  element
+                    .send(element_rule.delegate)
+                    .class
+                    .attributes[element_rule.to]
+
+                value =
+                  element
+                    .send(element_rule.delegate)
+                    .send(element_rule.to)
               else
-                xml.send(element_rule.name) { xml.text value }
+                attribute_def = element.class.attributes[element_rule.to]
+                value = element.send(element_rule.to)
               end
-            end
-            xml.text element.text unless xml_mapping.elements.any?
-          end
-        end
 
-        def build_attributes(element, xml_mapping)
-          xml_mapping.attributes.each_with_object(namespace_attributes(xml_mapping)) do |mapping_rule, hash|
-            full_name = if mapping_rule.namespace
-                "#{mapping_rule.prefix ? "#{mapping_rule.prefix}:" : ""}#{mapping_rule.name}"
-              else
-                mapping_rule.name
+              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
+
+              val = if attribute_def.collection?
+                      value
+                    elsif !value.nil? || element_rule.render_nil?
+                      [value]
+                    else
+                      []
+                    end
+
+              val.each do |v|
+                if attribute_def&.type&.<= Lutaml::Model::Serialize
+                  handle_nested_elements(xml, element_rule, v)
+                else
+                  nsp_xml.send(element_rule.name) do
+                    if !v.nil?
+                      serialized_value = attribute_def.type.serialize(v)
+
+                      if attribute_def.type == Lutaml::Model::Type::Hash
+                        serialized_value.each do |key, val|
+                          xml.send(key) { xml.text val }
+                        end
+                      else
+                        xml.text(serialized_value)
+                      end
+                    end
+                  end
+                end
               end
-            hash[full_name] = element.send(mapping_rule.to)
-          end
-        end
-
-        def namespace_attributes(xml_mapping)
-          return {} unless xml_mapping.namespace_uri
-
-          if xml_mapping.namespace_prefix
-            { "xmlns:#{xml_mapping.namespace_prefix}" => xml_mapping.namespace_uri }
-          else
-            { "xmlns" => xml_mapping.namespace_uri }
+            end
+            prefixed_xml.text element.text unless xml_mapping.elements.any?
           end
         end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/BlockLength
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
 
-        def handle_nested_elements(xml, element_rule, value)
+        def handle_nested_elements(xml, _element_rule, value)
           case value
           when Array
             value.each { |val| build_element(xml, val) }
@@ -82,34 +118,128 @@ module Lutaml
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def parse_element(element)
           result = element.children.each_with_object({}) do |child, hash|
-            next if child.text?
+            value = child.text? ? child.text : parse_element(child)
 
-            hash[child.name] ||= []
-            hash[child.name] << parse_element(child)
+            if hash[child.unprefixed_name]
+              hash[child.unprefixed_name] =
+                [hash[child.unprefixed_name], value].flatten
+            else
+              hash[child.unprefixed_name] = value
+            end
           end
-          result["_text"] = element.text if element.text?
+
+          element.attributes.each do |name, attr|
+            result[name] = attr.value
+          end
+
+          # result["_text"] = element.text if element.text
           result
         end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
       end
 
       class NokogiriElement < Element
-        def initialize(node)
-          attributes = node.attributes.transform_values do |attr|
-            Attribute.new(attr.name, attr.value, namespace: attr.namespace&.href, namespace_prefix: attr.namespace&.prefix)
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def initialize(node, root_node: nil)
+          if root_node
+            node.namespaces.each do |prefix, name|
+              namespace = Lutaml::Model::XmlNamespace.new(name, prefix)
+
+              root_node.add_namespace(namespace)
+            end
+          end
+
+          attributes = {}
+          node.attributes.transform_values do |attr|
+            name = if attr.namespace
+                     "#{attr.namespace.prefix}:#{attr.name}"
+                   else
+                     attr.name
+                   end
+
+            attributes[name] = Attribute.new(
+              name,
+              attr.value,
+              namespace: attr.namespace&.href,
+              namespace_prefix: attr.namespace&.prefix,
+            )
           end
-          super(node.name, attributes, parse_children(node), node.text, namespace: node.namespace&.href, namespace_prefix: node.namespace&.prefix)
+
+          super(
+            node.name,
+            attributes,
+            parse_all_children(node, root_node: root_node || self),
+            node.text,
+            parent_document: root_node,
+            namespace_prefix: node.namespace&.prefix,
+          )
         end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
 
         def text?
-          false
+          # false
+          children.empty? && text.length.positive?
+        end
+
+        def to_xml(builder = nil)
+          builder ||= Nokogiri::XML::Builder.new
+
+          if name == "text"
+            builder.text(text)
+          else
+            builder.send(name, build_attributes(self)) do |xml|
+              children.each { |child| child.to_xml(xml) }
+            end
+          end
+
+          builder
         end
 
         private
 
-        def parse_children(node)
-          node.children.select(&:element?).map { |child| NokogiriElement.new(child) }
+        def parse_children(node, root_node: nil)
+          node.children.select(&:element?).map do |child|
+            NokogiriElement.new(child, root_node: root_node)
+          end
+        end
+
+        def parse_all_children(node, root_node: nil)
+          node.children.map do |child|
+            NokogiriElement.new(child, root_node: root_node)
+          end
+        end
+
+        def build_attributes(node)
+          attrs = node.attributes.transform_values(&:value)
+
+          attrs.merge(build_namespace_attributes(node))
+        end
+
+        def build_namespace_attributes(node)
+          namespace_attrs = {}
+
+          node.own_namespaces.each_value do |namespace|
+            namespace_attrs[namespace.attr_name] = namespace.uri
+          end
+
+          node.children.each do |child|
+            namespace_attrs = namespace_attrs.merge(
+              build_namespace_attributes(child),
+            )
+          end
+
+          namespace_attrs
         end
       end
     end

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

@@ -12,10 +12,6 @@ module Lutaml
           new(root)
         end
 
-        def initialize(root)
-          @root = root
-        end
-
         def to_h
           { @root.name => parse_element(@root) }
         end
@@ -40,15 +36,14 @@ module Lutaml
         end
 
         def build_attributes(attributes)
-          attributes.each_with_object({}) do |(name, attr), hash|
-            hash[name] = attr.value
-          end
+          attributes.transform_values(&:value)
         end
 
         def parse_element(element)
           result = { "_text" => element.text }
           element.children.each do |child|
             next if child.is_a?(Oga::XML::Text)
+
             result[child.name] ||= []
             result[child.name] << parse_element(child)
           end
@@ -67,7 +62,9 @@ module Lutaml
         private
 
         def parse_children(node)
-          node.children.select { |child| child.is_a?(Oga::XML::Element) }.map { |child| OgaElement.new(child) }
+          node.children.select do |child|
+            child.is_a?(Oga::XML::Element)
+          end.map { |child| OgaElement.new(child) }
         end
       end
     end