lutaml-model 0.3.0 → 0.3.2

data/lib/lutaml/model/type.rb

@@ -1,170 +1,97 @@
-# lib/lutaml/model/type.rb
 require "date"
 require "bigdecimal"
 require "securerandom"
 require "uri"
 require "ipaddr"
-require "json"
 
 module Lutaml
   module Model
     module Type
-      %w(String
-         Integer
-         Float
-         Date
-         Time
-         Boolean
-         Decimal
-         Hash
-         UUID
-         Symbol
-         BigInteger
-         Binary
-         URL
-         Email
-         IPAddress
-         JSON
-         Enum).each do |t|
+      # This module provides a set of methods to cast and serialize values
+
+      # TODO: Make Boolean a separate class
+
+      %w(
+        String
+        Integer
+        Float
+        Date
+        Time
+        Boolean
+        Decimal
+        Hash
+        Uuid
+        Symbol
+        Binary
+        Url
+        IpAddress
+        Json
+      ).each do |t|
         class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-          class #{t}                        # class Integer
+                     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)
-          return if value.nil?
-
-          ::Time.parse(value.to_s)
-          # .strftime("%H:%M:%S")
-        end
-
-        def self.serialize(value)
-          value.strftime("%H:%M:%S")
-        end
-      end
-
-      class DateTime
-        def self.cast(value)
-          return if value.nil?
-
-          ::DateTime.parse(value.to_s).new_offset(0)
-        end
-
-        def self.serialize(value)
-          value.iso8601
-        end
-      end
-
+      # TODO: Remove this. The XSD code depends on this but actually should
+      # be converted into a collection, not a specific Array type.
       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)
         return if value.nil?
 
-        if [String, Email].include?(type)
+        case type.to_s.split("::").last
+        when "String"
           value.to_s
-        elsif [Integer, BigInteger].include?(type)
+        when "Integer"
           value.to_i
-        elsif type == Float
+        when "Float"
           value.to_f
-        elsif type == Date
+        when "Date"
           begin
             ::Date.parse(value.to_s)
           rescue ArgumentError
             nil
           end
-        elsif type == DateTime
+        when "DateTime"
           DateTime.cast(value)
-        elsif type == Time
+        when "Time"
           ::Time.parse(value.to_s)
-        elsif type == TimeWithoutDate
+        when "TimeWithoutDate"
           TimeWithoutDate.cast(value)
-        elsif type == Boolean
+        when "Boolean"
           to_boolean(value)
-        elsif type == Decimal
+        when "Decimal"
           BigDecimal(value.to_s)
-        elsif type == Hash
+        when "Hash"
           normalize_hash(Hash(value))
-        elsif type == UUID
+        when "Uuid"
           UUID_REGEX.match?(value) ? value : SecureRandom.uuid
-        elsif type == Symbol
+        when "Symbol"
           value.to_sym
-        elsif type == Binary
+        when "Binary"
           value.force_encoding("BINARY")
-        elsif type == URL
+        when "Url"
           URI.parse(value.to_s)
-        elsif type == IPAddress
+        when "IpAddress"
           IPAddr.new(value.to_s)
-        elsif type == JSON
-          JSON.cast(value)
-        # elsif type == Enum
-        #   value
+        when "Json"
+          Json.cast(value)
         else
           value
         end
@@ -173,21 +100,22 @@ module Lutaml
       def self.serialize(value, type)
         return if value.nil?
 
-        if type == Date
+        case type.to_s.split("::").last
+        when "Date"
           value.iso8601
-        elsif type == DateTime
+        when "DateTime"
           DateTime.serialize(value)
-        elsif type == Integer
+        when "Integer"
           value.to_i
-        elsif type == Float
+        when "Float"
           value.to_f
-        elsif type == Boolean
+        when "Boolean"
           to_boolean(value)
-        elsif type == Decimal
+        when "Decimal"
           value.to_s("F")
-        elsif type == Hash
+        when "Hash"
           Hash(value)
-        elsif type == JSON
+        when "Json"
           value.to_json
         else
           value.to_s
@@ -195,8 +123,13 @@ module Lutaml
       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)
+        if value == true || value.to_s =~ (/^(true|t|yes|y|1)$/i)
+          return true
+        end
+
+        if value == false || value.nil? || value.to_s =~ (/^(false|f|no|n|0)$/i)
+          return false
+        end
 
         raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
       end
@@ -217,3 +150,7 @@ module Lutaml
     end
   end
 end
+
+require_relative "type/time_without_date"
+require_relative "type/date_time"
+require_relative "type/json"

data/lib/lutaml/model/version.rb

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

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

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/nokogiri_adapter.rb
 require "nokogiri"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class NokogiriDocument < Document
+      class NokogiriAdapter < XmlDocument
         def self.parse(xml)
           parsed = Nokogiri::XML(xml)
           root = NokogiriElement.new(parsed.root)
@@ -13,11 +12,12 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Nokogiri::XML::Builder.new do |xml|
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
               root.to_xml(xml)
             else
-              options[:xml_attributes] = build_namespace_attributes(@root.class)
+              mapper_class = options[:mapper_class] || @root.class
+              options[:xml_attributes] = build_namespace_attributes(mapper_class)
               build_element(xml, @root, options)
             end
           end
@@ -32,7 +32,8 @@ module Lutaml
         private
 
         def build_unordered_element(xml, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
           attributes = options[:xml_attributes] ||= {}
@@ -53,7 +54,7 @@ module Lutaml
             end
 
             xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, 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?
@@ -79,7 +80,8 @@ module Lutaml
         end
 
         def build_ordered_element(xml, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          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
@@ -106,7 +108,7 @@ module Lutaml
               element_rule = xml_mapping.find_by_name(name)
               next if element_rule.nil?
 
-              attribute_def = attribute_definition_for(element, element_rule)
+              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
 
@@ -127,7 +129,12 @@ module Lutaml
 
         def add_to_xml(xml, value, attribute, rule)
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(xml, value, rule)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
           else
             xml.public_send(rule.name) do
               if !value.nil?
@@ -146,11 +153,11 @@ module Lutaml
         end
       end
 
-      class NokogiriElement < Element
+      class NokogiriElement < XmlElement
         def initialize(node, root_node: nil)
           if root_node
             node.namespaces.each do |prefix, name|
-              namespace = Lutaml::Model::XmlNamespace.new(name, prefix)
+              namespace = XmlNamespace.new(name, prefix)
 
               root_node.add_namespace(namespace)
             end
@@ -164,7 +171,7 @@ module Lutaml
                      attr.name
                    end
 
-            attributes[name] = Attribute.new(
+            attributes[name] = XmlAttribute.new(
               name,
               attr.value,
               namespace: attr.namespace&.href,

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

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/oga_adapter.rb
 require "oga"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OgaDocument < Document
+      class OgaAdapter < XmlDocument
         def self.parse(xml)
           parsed = Oga.parse_xml(xml)
           root = OgaElement.new(parsed)
@@ -51,10 +50,10 @@ module Lutaml
         end
       end
 
-      class OgaElement < Element
+      class OgaElement < XmlElement
         def initialize(node)
           attributes = node.attributes.each_with_object({}) do |attr, hash|
-            hash[attr.name] = Attribute.new(attr.name, attr.value)
+            hash[attr.name] = XmlAttribute.new(attr.name, attr.value)
           end
           super(node.name, attributes, parse_children(node), node.text)
         end

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

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/ox_adapter.rb
 require "ox"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OxDocument < Document
+      class OxAdapter < XmlDocument
         def self.parse(xml)
           parsed = Ox.parse(xml)
           root = OxElement.new(parsed)
@@ -14,9 +13,10 @@ module Lutaml
 
         def to_xml(options = {})
           builder = Ox::Builder.new
+
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.to_xml(builder)
-          elsif @root.ordered?
+          elsif ordered?(@root, options)
             build_ordered_element(builder, @root, options)
           else
             build_element(builder, @root, options)
@@ -30,7 +30,8 @@ module Lutaml
         private
 
         def build_unordered_element(builder, element, options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+          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
@@ -45,7 +46,7 @@ module Lutaml
 
           builder.element(prefixed_name, attributes) do |el|
             xml_mapping.elements.each do |element_rule|
-              attribute_def = attribute_definition_for(element, 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?
@@ -58,7 +59,7 @@ module Lutaml
 
               val.each do |v|
                 if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(el, v, element_rule)
+                  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
@@ -76,8 +77,9 @@ module Lutaml
           end
         end
 
-        def build_ordered_element(builder, element, _options = {})
-          xml_mapping = element.class.mappings_for(:xml)
+        def build_ordered_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
@@ -91,7 +93,7 @@ module Lutaml
 
               element_rule = xml_mapping.find_by_name(name)
 
-              attribute_def = attribute_definition_for(element, element_rule)
+              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
@@ -110,7 +112,12 @@ module Lutaml
 
         def add_to_xml(xml, value, attribute, rule)
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(xml, value, rule)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
           else
             xml.element(rule.name) do |el|
               if !value.nil?
@@ -129,16 +136,16 @@ module Lutaml
         end
       end
 
-      class OxElement < Element
+      class OxElement < XmlElement
         def initialize(node, root_node: nil)
           if node.is_a?(String)
             super("text", {}, [], node, parent_document: root_node)
           else
             namespace_attributes(node.attributes).each do |(name, value)|
               if root_node
-                root_node.add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                root_node.add_namespace(XmlNamespace.new(value, name))
               else
-                add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                add_namespace(XmlNamespace.new(value, name))
               end
             end
 
@@ -148,11 +155,11 @@ module Lutaml
               namespace_prefix = name.to_s.split(":").first
               if (n = name.to_s.split(":")).length > 1
                 namespace = (root_node || self).namespaces[namespace_prefix]&.uri
-                namespace ||= Lutaml::Model::XmlAdapter::XML_NAMESPACE_URI
+                namespace ||= XML_NAMESPACE_URI
                 prefix = n.first
               end
 
-              hash[name.to_s] = Attribute.new(
+              hash[name.to_s] = XmlAttribute.new(
                 name.to_s,
                 value,
                 namespace: namespace,
@@ -165,7 +172,7 @@ module Lutaml
               attributes,
               parse_children(node, root_node: root_node || self),
               node.text,
-              parent_document: root_node
+              parent_document: root_node,
             )
           end
         end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      # Represents an XML attribute
+      class XmlAttribute
+        attr_reader :name, :value, :namespace, :namespace_prefix
+
+        def initialize(name, value, namespace: nil, namespace_prefix: nil)
+          @name = name
+          @value = value
+          @namespace = namespace
+          @namespace_prefix = namespace_prefix
+        end
+
+        def unprefixed_name
+          if namespace_prefix
+            name.split(":").last
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end