lutaml-model 0.3.0 → 0.3.2

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

@@ -0,0 +1,184 @@
+require_relative "../mapping_hash"
+require_relative "xml_element"
+require_relative "xml_attribute"
+require_relative "xml_namespace"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlDocument
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def self.parse(xml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def children
+          @root.children
+        end
+
+        def declaration(options)
+          version = "1.0"
+          version = options[:declaration] if options[:declaration].is_a?(String)
+
+          encoding = options[:encoding] ? "UTF-8" : nil
+          encoding = options[:encoding] if options[:encoding].is_a?(String)
+
+          declaration = "<?xml version=\"#{version}\""
+          declaration += " encoding=\"#{encoding}\"" if encoding
+          declaration += "?>\n"
+          declaration
+        end
+
+        def to_h
+          parse_element(@root)
+        end
+
+        def order
+          @root.order
+        end
+
+        def handle_nested_elements(builder, value, rule: nil, attribute: nil)
+          options = build_options_for_nested_elements(attribute, rule)
+
+          case value
+          when Array
+            value.each { |val| build_element(builder, val, options) }
+          else
+            build_element(builder, value, options)
+          end
+        end
+
+        def build_options_for_nested_elements(attribute, rule)
+          return {} unless rule
+
+          options = {}
+
+          options[:namespace_prefix] = rule.prefix if rule&.namespace_set?
+          options[:mixed_content] = rule.mixed_content
+
+          options[:mapper_class] = attribute&.type if attribute
+
+          options
+        end
+
+        def parse_element(element)
+          result = Lutaml::Model::MappingHash.new
+          result.item_order = element.order
+
+          element.children.each_with_object(result) do |child, hash|
+            value = child.text? ? child.text : 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
+
+          element.attributes.each_value do |attr|
+            result[attr.unprefixed_name] = attr.value
+          end
+
+          result
+        end
+
+        def build_element(xml, element, options = {})
+          if ordered?(element, options)
+            build_ordered_element(xml, element, options)
+          else
+            build_unordered_element(xml, element, options)
+          end
+        end
+
+        def ordered?(element, options = {})
+          return false unless element.respond_to?(:element_order)
+          return element.ordered? if element.respond_to?(:ordered?)
+          return options[:mixed_content] if options.key?(:mixed_content)
+
+          mapper_class = options[:mapper_class]
+          mapper_class ? mapper_class.mappings_for(:xml).mixed_content? : false
+        end
+
+        def build_namespace_attributes(klass, processed = {})
+          xml_mappings = klass.mappings_for(:xml)
+          attributes = klass.attributes
+
+          attrs = {}
+
+          if xml_mappings.namespace_prefix
+            attrs["xmlns:#{xml_mappings.namespace_prefix}"] =
+              xml_mappings.namespace_uri
+          end
+
+          xml_mappings.mappings.each do |mapping_rule|
+            processed[klass] ||= {}
+
+            next if processed[klass][mapping_rule.name]
+
+            processed[klass][mapping_rule.name] = true
+
+            type = if mapping_rule.delegate
+                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
+                   else
+                     attributes[mapping_rule.to].type
+                   end
+
+            if type <= Lutaml::Model::Serialize
+              attrs = attrs.merge(build_namespace_attributes(type, processed))
+            end
+
+            if mapping_rule.namespace
+              attrs["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+          end
+
+          attrs
+        end
+
+        def build_attributes(element, xml_mapping)
+          attrs = namespace_attributes(xml_mapping)
+
+          xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
+            if mapping_rule.namespace
+              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+
+            hash[mapping_rule.prefixed_name] = element.send(mapping_rule.to)
+          end
+
+          xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
+            if mapping_rule.namespace
+              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+          end
+        end
+
+        def attribute_definition_for(element, rule, mapper_class: nil)
+          klass = mapper_class || element.class
+          return klass.attributes[rule.to] unless rule.delegate
+
+          element.send(rule.delegate).class.attributes[rule.to]
+        end
+
+        def attribute_value_for(element, rule)
+          return element.send(rule.to) unless rule.delegate
+
+          element.send(rule.delegate).send(rule.to)
+        end
+
+        def namespace_attributes(xml_mapping)
+          return {} unless xml_mapping.namespace_uri
+
+          key = ["xmlns", xml_mapping.namespace_prefix].compact.join(":")
+          { key => xml_mapping.namespace_uri }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require_relative "xml_attribute"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlElement
+        attr_reader :attributes,
+                    :children,
+                    :text,
+                    :namespace_prefix,
+                    :parent_document
+
+        def initialize(
+          name,
+          attributes = {},
+          children = [],
+          text = nil,
+          parent_document: nil,
+          namespace_prefix: nil
+        )
+          @name = extract_name(name)
+          @namespace_prefix = namespace_prefix || extract_namespace_prefix(name)
+          @attributes = attributes # .map { |k, v| XmlAttribute.new(k, v) }
+          @children = children
+          @text = text
+          @parent_document = parent_document
+        end
+
+        def name
+          if namespace_prefix
+            "#{namespace_prefix}:#{@name}"
+          else
+            @name
+          end
+        end
+
+        def unprefixed_name
+          @name
+        end
+
+        def document
+          XmlDocument.new(self)
+        end
+
+        def namespaces
+          @namespaces || @parent_document&.namespaces || {}
+        end
+
+        def own_namespaces
+          @namespaces || {}
+        end
+
+        def namespace
+          return default_namespace unless namespace_prefix
+
+          namespaces[namespace_prefix]
+        end
+
+        def attribute_is_namespace?(name)
+          name.to_s.start_with?("xmlns")
+        end
+
+        def add_namespace(namespace)
+          @namespaces ||= {}
+          @namespaces[namespace.prefix] = namespace
+        end
+
+        def default_namespace
+          namespaces[nil] || @parent_document&.namespaces&.dig(nil)
+        end
+
+        def extract_name(name)
+          n = name.to_s.split(":")
+          return name if n.length <= 1
+
+          n[1..].join(":")
+        end
+
+        def extract_namespace_prefix(name)
+          n = name.to_s.split(":")
+          return if n.length <= 1
+
+          n.first
+        end
+
+        def order
+          children.each_with_object([]) do |child, arr|
+            arr << child.unprefixed_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_striing_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlNamespace
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :uri
+
+        # Return prefix
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :prefix
+
+        # Initialize instance
+        #
+        # @param [String, nil] name
+        # @param [String, nil] prefix
+        #
+        # @api private
+        def initialize(uri = nil, prefix = nil)
+          @uri = uri
+          @prefix = normalize_prefix(prefix)
+        end
+
+        def normalize_prefix(prefix)
+          normalized_prefix = prefix.to_s.gsub(/xmlns:?/, "")
+          return if normalized_prefix.empty?
+
+          normalized_prefix
+        end
+
+        def attr_name
+          if prefix && !prefix.empty?
+            "xmlns:#{prefix}"
+          else
+            "xmlns"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter.rb

@@ -1,273 +1,7 @@
-# lib/lutaml/model/xml_adapter.rb
-
-require_relative "xml_namespace"
-require_relative "mapping_hash"
-
 module Lutaml
   module Model
     module XmlAdapter
       XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace".freeze
-
-      class Document
-        attr_reader :root
-
-        def initialize(root)
-          @root = root
-        end
-
-        def self.parse(xml)
-          raise NotImplementedError, "Subclasses must implement `parse`."
-        end
-
-        def children
-          @root.children
-        end
-
-        def declaration(options)
-          version = "1.0"
-          version = options[:declaration] if options[:declaration].is_a?(String)
-
-          encoding = options[:encoding] ? "UTF-8" : nil
-          encoding = options[:encoding] if options[:encoding].is_a?(String)
-
-          declaration = "<?xml version=\"#{version}\""
-          declaration += " encoding=\"#{encoding}\"" if encoding
-          declaration += "?>\n"
-          declaration
-        end
-
-        def to_h
-          parse_element(@root)
-        end
-
-        def order
-          @root.order
-        end
-
-        def handle_nested_elements(builder, value, rule = nil)
-          options = {}
-
-          if rule&.namespace_set?
-            options[:namespace_prefix] = rule.prefix
-          end
-
-          case value
-          when Array
-            value.each { |val| build_element(builder, val, options) }
-          else
-            build_element(builder, value, options)
-          end
-        end
-
-        def parse_element(element)
-          result = Lutaml::Model::MappingHash.new
-          result.item_order = element.order
-
-          element.children.each_with_object(result) do |child, hash|
-            value = child.text? ? child.text : 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
-
-          element.attributes.each_value do |attr|
-            result[attr.unprefixed_name] = attr.value
-          end
-
-          result
-        end
-
-        def build_element(xml, element, _options = {})
-          if element.ordered?
-            build_ordered_element(xml, element, _options)
-          else
-            build_unordered_element(xml, element, _options)
-          end
-        end
-
-        def build_namespace_attributes(klass, processed = {})
-          xml_mappings = klass.mappings_for(:xml)
-          attributes = klass.attributes
-
-          attrs = {}
-
-          if xml_mappings.namespace_prefix
-            attrs["xmlns:#{xml_mappings.namespace_prefix}"] =
-              xml_mappings.namespace_uri
-          end
-
-          xml_mappings.mappings.each do |mapping_rule|
-            processed[klass] ||= {}
-
-            next if processed[klass][mapping_rule.name]
-
-            processed[klass][mapping_rule.name] = true
-
-            type = if mapping_rule.delegate
-                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
-                   else
-                     attributes[mapping_rule.to].type
-                   end
-
-            if type <= Lutaml::Model::Serialize
-              attrs = attrs.merge(build_namespace_attributes(type, processed))
-            end
-
-            if mapping_rule.namespace
-              attrs["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-          end
-
-          attrs
-        end
-
-        def build_attributes(element, xml_mapping)
-          attrs = namespace_attributes(xml_mapping)
-
-          xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
-            if mapping_rule.namespace
-              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-
-            hash[mapping_rule.prefixed_name] = element.send(mapping_rule.to)
-          end
-
-          xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
-            if mapping_rule.namespace
-              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
-            end
-          end
-        end
-
-        def attribute_definition_for(element, rule)
-          return element.class.attributes[rule.to] unless rule.delegate
-
-          element.send(rule.delegate).class.attributes[rule.to]
-        end
-
-        def attribute_value_for(element, rule)
-          return element.send(rule.to) unless rule.delegate
-
-          element.send(rule.delegate).send(rule.to)
-        end
-
-        def namespace_attributes(xml_mapping)
-          return {} unless xml_mapping.namespace_uri
-
-          key = ["xmlns", xml_mapping.namespace_prefix].compact.join(":")
-          { key => xml_mapping.namespace_uri }
-        end
-      end
-
-      class Element
-        attr_reader :attributes,
-                    :children,
-                    :text,
-                    :namespace_prefix,
-                    :parent_document
-
-        def initialize(
-          name,
-          attributes = {},
-          children = [],
-          text = nil,
-          parent_document: nil,
-          namespace_prefix: nil
-        )
-          @name = extract_name(name)
-          @namespace_prefix = namespace_prefix || extract_namespace_prefix(name)
-          @attributes = attributes # .map { |k, v| Attribute.new(k, v) }
-          @children = children
-          @text = text
-          @parent_document = parent_document
-        end
-
-        def name
-          if namespace_prefix
-            "#{namespace_prefix}:#{@name}"
-          else
-            @name
-          end
-        end
-
-        def unprefixed_name
-          @name
-        end
-
-        def document
-          Document.new(self)
-        end
-
-        def namespaces
-          @namespaces || @parent_document&.namespaces || {}
-        end
-
-        def own_namespaces
-          @namespaces || {}
-        end
-
-        def namespace
-          return default_namespace unless namespace_prefix
-
-          namespaces[namespace_prefix]
-        end
-
-        def attribute_is_namespace?(name)
-          name.to_s.start_with?("xmlns")
-        end
-
-        def add_namespace(namespace)
-          @namespaces ||= {}
-          @namespaces[namespace.prefix] = namespace
-        end
-
-        def default_namespace
-          namespaces[nil] || @parent_document&.namespaces&.dig(nil)
-        end
-
-        def extract_name(name)
-          n = name.to_s.split(":")
-          return name if n.length <= 1
-
-          n[1..].join(":")
-        end
-
-        def extract_namespace_prefix(name)
-          n = name.to_s.split(":")
-          return if n.length <= 1
-
-          n.first
-        end
-
-        def order
-          children.each_with_object([]) do |child, arr|
-            arr << child.unprefixed_name
-          end
-        end
-      end
-
-      class Attribute
-        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

data/lib/lutaml/model/xml_mapping.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/xml_mapping.rb
 require_relative "xml_mapping_rule"
 
 module Lutaml
@@ -82,6 +81,7 @@ module Lutaml
           namespace_set: namespace_set != false,
         )
       end
+
       # rubocop:enable Metrics/ParameterLists
 
       def map_content(

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/xml_mapping_rule.rb
 require_relative "mapping_rule"
 
 module Lutaml
@@ -24,12 +23,12 @@ module Lutaml
           with: with,
           delegate: delegate,
           mixed_content: mixed_content,
-          namespace_set: namespace_set
+          namespace_set: namespace_set,
         )
 
         @namespace = if namespace.to_s == "inherit"
-                       # we are using inherit_namespace in xml builder by
-                       # default so no need to do anything here.
+                     # we are using inherit_namespace in xml builder by
+                     # default so no need to do anything here.
                      else
                        namespace
                      end

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

@@ -0,0 +1,34 @@
+require "yaml"
+require_relative "yaml_document"
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      class StandardYamlAdapter < YamlDocument
+        def self.parse(yaml)
+          YAML.safe_load(
+            yaml,
+            permitted_classes: [Date, Time, DateTime, Symbol,
+                                BigDecimal, Hash, Array],
+          )
+        end
+
+        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
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "yaml_object"
+
+module Lutaml
+  module Model
+    module YamlAdapter
+      # Base class for YAML documents
+      class YamlDocument < YamlObject
+        def self.parse(yaml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def to_yaml(*args)
+          raise NotImplementedError, "Subclasses must implement `to_yaml`."
+        end
+      end
+    end
+  end
+end