lutaml-model 0.1.0 → 0.3.0

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,162 @@ 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 TextWithTags
+        attr_reader :content
+
+        def initialize(ordered_text_with_tags)
+          @content = ordered_text_with_tags
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self)
+
+          new(value)
+        end
+
+        def self.serialize(value)
+          value.content.join
+        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) || value.nil?
+
+          new(::JSON.parse(value))
+        end
+
+        def self.serialize(value)
+          value.to_json
+        end
+      end
+
+      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/
+
       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
     end
   end
 end

data/lib/lutaml/model/version.rb

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

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

@@ -12,104 +12,229 @@ module Lutaml
           new(root)
         end
 
-        def initialize(root)
-          @root = root
-        end
-
-        def to_h
-          { @root.name => parse_element(@root) }
-        end
-
         def to_xml(options = {})
           builder = Nokogiri::XML::Builder.new do |xml|
-            build_element(xml, @root, options)
+            if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
+              root.to_xml(xml)
+            else
+              options[:xml_attributes] = build_namespace_attributes(@root.class)
+              build_element(xml, @root, options)
+            end
           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 = {})
+        def build_unordered_element(xml, element, options = {})
           xml_mapping = element.class.mappings_for(:xml)
           return xml unless xml_mapping
 
-          attributes = build_attributes(element, 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
+
+          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.parent.namespace = nil
+            end
 
-          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)
+              attribute_def = attribute_definition_for(element, element_rule)
+              value = attribute_value_for(element, element_rule)
 
-              if attribute_def&.type <= Lutaml::Model::Serialize
-                handle_nested_elements(xml, element_rule, value)
-              else
-                xml.send(element_rule.name) { xml.text value }
+              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
-            xml.text element.text unless xml_mapping.elements.any?
+
+            if xml_mapping.content_mapping
+              text = element.send(xml_mapping.content_mapping.to)
+              text = text.join if text.is_a?(Array)
+
+              prefixed_xml.text text
+            end
           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
+        def build_ordered_element(xml, element, options = {})
+          xml_mapping = element.class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping)&.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
+
+          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.parent.namespace = nil
+            end
+
+            index_hash = {}
+
+            element.element_order.each do |name|
+              index_hash[name] ||= -1
+              curr_index = index_hash[name] += 1
+
+              element_rule = xml_mapping.find_by_name(name)
+              next if element_rule.nil?
+
+              attribute_def = attribute_definition_for(element, element_rule)
+              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)
+                text = text[curr_index] if text.is_a?(Array)
+
+                prefixed_xml.text text
+              elsif attribute_def.collection?
+                add_to_xml(nsp_xml, 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
-            hash[full_name] = element.send(mapping_rule.to)
+            end
           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 }
+        def add_to_xml(xml, value, attribute, rule)
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(xml, value, rule)
           else
-            { "xmlns" => xml_mapping.namespace_uri }
+            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
+              end
+            end
+          end
+        end
+      end
+
+      class NokogiriElement < Element
+        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_all_children(node, root_node: root_node || self),
+            node.text,
+            parent_document: root_node,
+            namespace_prefix: node.namespace&.prefix,
+          )
+        end
+
+        def text?
+          # false
+          children.empty? && text.length.positive?
         end
 
-        def handle_nested_elements(xml, element_rule, value)
-          case value
-          when Array
-            value.each { |val| build_element(xml, val) }
+        def to_xml(builder = nil)
+          builder ||= Nokogiri::XML::Builder.new
+
+          if name == "text"
+            builder.text(text)
           else
-            build_element(xml, value)
+            builder.send(name, build_attributes(self)) do |xml|
+              children.each { |child| child.to_xml(xml) }
+            end
           end
+
+          builder
         end
 
-        def parse_element(element)
-          result = element.children.each_with_object({}) do |child, hash|
-            next if child.text?
+        private
 
-            hash[child.name] ||= []
-            hash[child.name] << parse_element(child)
+        def parse_children(node, root_node: nil)
+          node.children.select(&:element?).map do |child|
+            NokogiriElement.new(child, root_node: root_node)
           end
-          result["_text"] = element.text if element.text?
-          result
         end
-      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)
+        def parse_all_children(node, root_node: nil)
+          node.children.map do |child|
+            NokogiriElement.new(child, root_node: root_node)
           end
-          super(node.name, attributes, parse_children(node), node.text, namespace: node.namespace&.href, namespace_prefix: node.namespace&.prefix)
         end
 
-        def text?
-          false
+        def build_attributes(node)
+          attrs = node.attributes.transform_values(&:value)
+
+          attrs.merge(build_namespace_attributes(node))
         end
 
-        private
+        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
 
-        def parse_children(node)
-          node.children.select(&:element?).map { |child| NokogiriElement.new(child) }
+          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